/* private stuff */
void merge_sort_recursive(void *base, size_t size, int (*comparator)(const void*,const void*), int p, int q)
{
if(q > p) {
int m = (p+q)/2;
merge_sort_recursive(base, size, comparator, p, m);
merge_sort_recursive(base, size, comparator, m+1, q);
merge_sort_mix(base, size, comparator, p, q, m);
}
}
void merge_sort_recursive(int arr[], int reg[], int start, int end) {
if (start >= end)
return;
int len = end - start, mid = (len >> 1) + start;
int start1 = start, end1 = mid;
int start2 = mid + 1, end2 = end;
merge_sort_recursive(arr, reg, start1, end1);
merge_sort_recursive(arr, reg, start2, end2);
int k = start;
while (start1 <= end1 && start2 <= end2)
reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
while (start1 <= end1)
reg[k++] = arr[start1++];
while (start2 <= end2)
reg[k++] = arr[start2++];
for (k = start; k <= end; k++)
arr[k] = reg[k];
}
int main(int argc, char** args)
{
if (argc < 3) {
std::cerr<<"Not enouht parameters"<<std::endl;
exit(-1);
}
std::vector<Int> v;
read_binary_vector(v, args[1]);
merge_sort_recursive(v);
write_binary_vector(v, args[2]);
}
/*
* merge_sort()
* Similar to stdlib's qsort, but merge_sort is
* a stable sorting algorithm
*
* base - Pointer to the first element of the array to be sorted
* num - Number of elements in the array pointed by base
* size - Size in bytes of each element in the array
* comparator - The return value of this function should represent
* whether elem1 is considered less than, equal to,
* or greater than elem2 by returning, respectively,
* a negative value, zero or a positive value
* int comparator(const void *elem1, const void *elem2)
*/
void merge_sort(void *base, size_t num, size_t size, int (*comparator)(const void*,const void*))
{
merge_sort_recursive(base, size, comparator, 0, num-1);
}
int main(){
int abc[10] = {5,3,6,7,2,1,9,10,4,8};
merge_sort_recursive(abc, 10);
printf("%d\n",abc[3] );
return 0;
}
void merge_sort(int arr[], const int len) {
int reg[len];
merge_sort_recursive(arr, reg, 0, len - 1);
}
