int main() {
array first, second, result;
init_array(&first, 20);
append_in_array(&first, 10);
append_in_array(&first, 20);
append_in_array(&first, 30);
append_in_array(&first, 40);
append_in_array(&first, 50);
init_array(&second, 5);
append_in_array(&second, 12);
append_in_array(&second, 15);
append_in_array(&second, 27);
append_in_array(&second, 29);
append_in_array(&second, 55);
print_array(&first);
print_array(&second);
merge_array(&first, &second);
print_array(&first);
return 0;
}
void merge_sort(T a[],int begin, int end)
{
if(!a||begin>=end) return;
int mid = (begin+end)/2;
merge_sort(a, begin, mid);
merge_sort(a, mid+1, end);
merge_array(a,begin,mid,end);
}
void merge_sort(int a[], int first, int last)
{
if(first+1 < last)
{
int mid = (first+last)/2;
merge_sort(a,first,mid);
merge_sort(a,mid,last);
merge_array(a,first,mid,last);
}
}
void merge_sort(int arr[],int first,int last,int tmp[])//递归地将小组分开，使每个小组变得有序
{
if(first < last)
{
int mid = (first + last)/2;
merge_sort(arr,first,mid,tmp);
merge_sort(arr,mid + 1,last,tmp);
merge_array(arr,first,mid,last,tmp);
}
}
void mergesort(int *ar, int size)
{
if(size <= 1)
return;
int mid = size/2;
// QUICK_LOG("Mid is %d",mid);
mergesort(ar, mid);
mergesort(ar+mid, size-mid);
merge_array(ar,mid,ar+mid,size-mid);
}
static void Merge_sort(int *array, int begin, int end, int *temp)
{
int mid = 0;
if(end > begin){ //还可进行拆分
// mid = (begin + end ) / 2;
mid = begin + (end - begin >> 1);
Merge_sort(array, begin, mid, temp);
Merge_sort(array, mid + 1, end, temp);
merge_array(array, begin, mid, end, temp);
}
void merge_sort(int a[], int lo, int hi, int temp[])
{
if(lo < hi) { //exit condition lo=hi
int mid = (lo+hi)/2;
// recursive
merge_sort(a, lo, mid, temp);
merge_sort(a, mid+1, hi, temp);
// 2 array is in sort, merge into one array
merge_array(a, lo, hi, temp);
}
}
void
merge_sort (int data[], int start, int end)
{
if (start < end && data)
{
int mid = (end + start) / 2;
merge_sort (data, start, mid);
merge_sort (data, mid + 1, end);
merge_array (data, start, mid, end);
}
}
void merge_sort(int *a, int length) {
if (length>1)
{
merge_sort(a,length/2);
merge_sort(a+length/2,length-length/2);
merge_array(a,length/2,a+length/2,length-length/2);
}
}
void merge_sort(int a[], int begin, int end, int tmp[])
{
int mid = (end+begin)/2;
if(begin == end)
return;
// sub array A, B is sorted
merge_sort(a, begin, mid, tmp);
merge_sort(a, mid+1, end, tmp);
// merge A and B
merge_array(a, begin, mid, end, tmp);
}
void merge_sort(int *a, int len)
{
if( len > 1 )
{
int *a1 = a;
int len1 = len/2;
int *a2 = a+len1;
int len2 = len - len1;
merge_sort(a1, len1);
merge_sort(a2, len2);
merge_array( a1, len1, a2, len2);
}
}
void do_merge_sort(T* array, T* widget, int dest, int size, int max_size)
{
T* space = new T[max_size];
memset(space, 0, sizeof(space));
if (size <= 1)
{
widget[dest] = array[dest];
return;
}
int index = dest + size / 2;
int size1 = index - dest;
int size2 = dest + size - index;
do_merge_sort(array, space, dest, size1, max_size);
do_merge_sort(array, space, index, size2, max_size);
merge_array(space, widget, dest, index, size);
delete [] space;
}
/* omp version of qsort */
static void omp_qsort (int* base, size_t num, size_t size, int (*comp)(const void*,const void*))
{
int i;
int *index;
index = (int *)malloc((omp_threads+1)*sizeof(int));
omp_set_num_threads(omp_threads);
for(i = 0; i < omp_threads; i++) {
index[i]= (i*num/omp_threads);
}
index[omp_threads] = num;
/* Sort partial arrays in parallel */
#pragma omp parallel for private(i)
for(i=0; i<omp_threads; i++) {
qsort(base+index[i], index[i+1]-index[i], size, comp);
}
/* Merge sorted array pieces */
merge_array(base, num, index);
}
