merge sort and binary search recursive version

// Merge_Sort.cpp : Defines the entry point for the console application.

/*****************************************************************

*

* 2. have to adopt the same array index to C++ programming lauguage.

* notice the index of the first item is 0, and the last item is array.length-1

* 3. procedure merge_check_empty() check which subarray is empty.

* date: Sep./16/2012

*

* 4. binary search recursive version: in BUGs

* data: Sep./19/2012

*

* 5. binary search recursive version: correct

* 6. recursion procedure must consider atomic case in any time,

* becuase the terminal case of recursion is an atomic case. don't omit it.

* That is terminal condition

* data: Sep./20/2012

*

* Author: Mr. Rocky CHEN

*******************************************************************/

#include "stdafx.h"

#include <iostream>

#include <ctime>

#include <cstdlib>

using namespace std;

#define SENTINEL 9999

int _tmain(int argc, _TCHAR* argv[])

{

void random_array(int * const a, int length);//yield a ramdom array for sorting

void merge(int * const array_, int start_num, int mid_num, int end_num); //merge two array to an array

void print_array(int * const a, int length);

void merge_sort(int * const a, int star, int end);

void merge_check_empty(int * const a, int s, int m, int e);

int binary_search(int* const a, int s, int e, int key); //s=star, e=end, key = search value

int const length = 10; //array length

int a[length];

srand(unsigned (time(0)));

random_array(a, length); //yield

merge_sort(a,0, length-1);

print_array(a,length);

for(int i=0; i <10; i++)

{

cout<<"=============\n i = " << i << endl;

int position = binary_search(a,0,length-1,a[i]);

cout << "return position = " << position << endl;

}

system("pause");

return 0;

}

//yield a ramdom array for sorting

void random_array(int * const a, int length)

{

for (int i = 0; i < length; i++)

{

a[i] = rand()%30;

cout << "a[" << i <<"] = " << a[i] << endl;

}

}

void print_array(int * const a, int length)

{

cout << "==========" << endl;

for (int i = 0; i < length; i++)

{

cout << "a[" << i <<"] = " << a[i] << endl;

}

}

// subroutine "merge" in merge sort

void merge(int * const a, int s, int m, int e) //s=start, m=middle, e=end

{

//calculate the lengths of two subarray

int n1 = m-s+1; //

int n2 = e-m;

int * const larray = (int *) malloc((n1+1)* sizeof(int)); // how to repalce malloc by new******

int * const rarray = (int *) malloc((n2+1)* sizeof(int)); //******

//copy two subarray of a[]

for(int i = 0; i < n1; i++) larray[i] = a[s+i];

for(int i = 0; i < n2; i++) rarray[i] = a[m+1+i];

//set sentinel card

larray[n1] = rarray[n2] = SENTINEL;

print_array(larray,n1+1);

print_array(rarray,n2+1);

for(int i=0, j=0, k=s; k <= e ; k++) //copy smaller item between larray[i] and rarray[j] to a[]

{

if(larray[i] <= rarray[j])

a[k] = larray[i++]; //i++

else

a[k] = rarray[j++]; //j++

}

}

// have the same function to merge(), but don't use sentinels in merging.

void merge_check_empty(int * const a, int s, int m, int e)

{

//calculate length of two subarraies

int n1 = m-s +1;

int n2 = e-m;

//copy elements of array to two subarraies

int *larray = (int *) malloc(n1*sizeof(int));

int *rarray = (int *) malloc(n2*sizeof(int));

for(int i = 0; i< n1; i++) larray[i] = a[s+i];

for(int i =0; i< n2; i++) rarray[i] = a[m+1+i];

//pick up the smaller card on tops of two piles cards; if one subarray is empty, copy the remain cards directly.

for(int i=0, j=0, k=s; k <= e; k++)

{

if(i < n1 && j < n2 && larray[i] <= rarray[j])

a[k] = larray[i++];

else if( i < n1 && j < n2 && larray[i] > rarray[j])

a[k] = rarray[j++];

else if (i == n1) //larray is empty

a[k] = rarray[j++];

else // if the former three conditions are false, j must equals n2, then rarray is empty

a[k] = larray[i++];

}

}

void merge_sort(int * const a, int star, int end)

{

if(star < end)

{

int middle = (star+end)/2; //middle = (star+end)/2*******

merge_sort(a,star, middle);

merge_sort(a,middle+1,end);

//using different merge function to complete meger_sort

merge_check_empty(a,star,middle,end);

//merge(a,star,middle,end);

}

}

//binary search recursive version

int binary_search(int* const a, int s, int e, int key) //s=star, e=end, key = search value

{

//when the length of array is more than 1. don't use s <= e, because when array's length = 1, s=m=e,

//if a[m]!=key, it results in deadloop or pointer overflow.

if(s < e)

{

int m = (s+e)/2; //m = middle pivot

if (a[m]==key) // accelerate to terminate

{

cout << "position = " << m << " a[position] = " << a[m] << " key = " << key << endl;

return m;

}

else if( a[m] > key) binary_search(a,s,m,key); //search key in the left subarray

else binary_search(a,m+1,e,key); //sarch key in the right subarray

}

// s=e. recursion procedure must consider atomic case in any time,

//becuase the terminal case of recursion is an atomic case. don't omit it.

else

{

if(a[s] == key)

{

cout << "position = " << s << " a[position] = " << a[s] << " key = " << key << endl;

return s;

}

else return -1;

}

}