DArray* _merge_sort(DArray* array, DArray_compare cmp) { DArray_check(array); if(array->end <= 1) return array; DArray* left = DArray_create(array->element_size, array->max); check_mem(left); DArray* right = DArray_create(array->element_size, array->max); check_mem(right); int middle = array->end/2; int i = 0; for(i = 0; i < array->end; i++) { if(i < middle) { DArray_push(left, DArray_get(array, i)); } else { DArray_push(right, DArray_get(array, i)); } } DArray* sort_left = _merge_sort(left, cmp); check(left != NULL, "Error in left merge sort"); DArray* sort_right = _merge_sort(right, cmp); check(right != NULL, "Error in right merge sort"); if(sort_left != left) DArray_destroy(left); if(sort_right != right) DArray_destroy(right); return _merge_array(sort_left, sort_right, cmp); error: return NULL; }
void _merge_sort(int* arr, int start, int end) { // printf("END: %d\n", end); if (start < end) { int mid = (start+end)>>1; _merge_sort(arr, start, mid); _merge_sort(arr, mid+1, end); _merge_merge(arr, start, mid, end); }
static SdbListIter * _merge_sort(SdbListIter *head, SdbListComparator cmp) { SdbListIter *second; if (!head || !head->n) { return head; } second = _sdb_list_split (head); head = _merge_sort (head, cmp); second = _merge_sort (second, cmp); return _merge (head, second, cmp); }
void _merge_sort(int list[], int low, int high) { if (low < high) { int mid = (high+low)/2; _merge_sort(list, low, mid); _merge_sort(list, mid+1, high); merge(list, low, mid, high); } }
static void _merge_sort(int array[], int temp_array[], int length) { if (length > 1) { int left = length / 2, right = length - left; _merge_sort(array, temp_array, left); _merge_sort(array + left, temp_array, right); merge(array, temp_array, length); } }
static void _merge_sort(int* array, unsigned int p, unsigned int r) { if (p < r) { unsigned int q = (p+r)/2; _merge_sort(array, p, q); _merge_sort(array, q+1, r); merge(array, p, q, r); } }
static void _merge_sort(int array[], int temparr[], int left, int right) { if(left < right) { int middle = (left+right)/2; _merge_sort(array, temparr, left, middle); _merge_sort(array, temparr, middle+1, right); merge(array, temparr, left, middle, right); } }
int _merge_sort(int *arr, int left_index, int right_index) { int inv_count = 0; if (left_index >= right_index) { return 0; } int middle_index = (left_index + right_index)/2; inv_count += _merge_sort(arr, left_index, middle_index); inv_count += _merge_sort(arr, middle_index+1, right_index); inv_count += merge(arr, left_index, middle_index+1, right_index); return inv_count; }
void _merge_sort(int* nums, int left, int right) { if (left >= right) { return; } int mid = (left + right) / 2; _merge_sort(nums, left, mid); _merge_sort(nums, mid+1, right); // _merge(nums, left, mid, right); _merge_without_extra_space(nums, left, mid, right); }
void _merge_sort(void *data, void *tmp, int begin, int end, size_t size, DataCompFunc cmpf, int order) { int mid; if(begin < end) { mid = (begin+end)/2; _merge_sort(data, tmp, begin, mid, size, cmpf, order); _merge_sort(data, tmp, mid+1, end, size, cmpf, order); if(order == QSORT_DESCEND) _merge_descend(data, tmp, begin, mid, end, size, cmpf); else _merge_ascend(data, tmp, begin, mid, end, size, cmpf); } }
void merge_sort(int array[], int size) { int *temparr = (int*)malloc(size*sizeof(int)); _merge_sort(array, temparr, 0, size-1); free(temparr); }
DArray* DArray_mergesort(DArray* array, DArray_compare cmp) { DArray_check(array); DArray* result = _merge_sort(array, cmp); check(result != NULL, "merge sort failed."); DArray_check(result); return result; error: return NULL; }
int merge_sort(int array[], int length) { int *temp_array; temp_array = malloc(length * sizeof(int)); _merge_sort(array, temp_array, length); free(temp_array); return 0; }
void _mergeSort(QSort *sort) { int begin, end; size_t size; DataCompFunc cmpf; void *tmp; size = sort->m_elemsize; cmpf = sort->cmpf; begin = sort->m_begin; end = sort->m_length - 1; tmp = QMem_Malloc(size*sort->m_length);//memory complexity of merge sort is O(n) _merge_sort(sort->m_data, tmp, begin, end, size, cmpf, sort->m_order); QMem_Free(tmp); }
SDB_API bool ls_merge_sort(SdbList *list, SdbListComparator cmp) { if (!cmp) { return false; } if (list && list->head && cmp) { SdbListIter *iter; list->head = _merge_sort (list->head, cmp); //update tail reference iter = list->head; while (iter && iter->n) { iter = iter->n; } list->tail = iter; list->sorted = true; } return true; }
void merge_sort(struct array thanger) { _merge_sort(thanger.list, 0, thanger.len); }
void merge_sort(int* nums, int n) { _merge_sort(nums, 0, n-1); }
void merge_sort(int* array, unsigned int num) { _merge_sort(array, 0, num-1); }
void merge_sort(int *arr, int size) { int start_index = 0; int inv_count = _merge_sort(arr, start_index, size-1); printf("Inversion Count : %d\n", inv_count); }