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);
}
