手撕排序算法：归并排序

归并是一种常见的算法思想，在许多领域都有广泛的应用。归并排序的主要目的是将两个已排
序的序列合并成一个有序的序列。

1.算法思想

当然，对于一个非有序的序列，可以拆成两个非有序的序列，然后分别调用归并排序，然后对
两个有序的序列再执行合并的过程。所以这里的“归”其实是递归，“并”就是合并。
整个算法的执行过程用mergeSort(a[],l,r)描述，代表当前待排序数组a,左区间下标l,右区
间下标r,分以下几步：
第一步、计算中点mid=(l+r)/2;
第二步、递归调用mergeSort(a[,l,mid)和mergeSort(a[],mid+1,r);
第三步、第二步中两个有序数组进行有序合并，再存储到a[l:];调用时，调用mergeSort(a[],0,n-1)就能得到整个数组的排序结果了。

2.算法分析

2.1时间复杂度

我们假设「比较」和「赋值」的时间复杂度为O(1)。
我们首先讨论「归并排序」算法的最重要的子程序：O()的合并，然后解析这个归并排序算法。
给定两个大小为n1和2的排序数组A和B,我们可以在O(n)时间内将它们有效地归并成一个大
小为n=n1+n2的组合排序数组。可以通过简单地比较两个数组的前面的元素，并始终取两个中较小
的一个来实现的。
问题是这个归并过程被调用了多少次？
由于每次都是对半切，所以整个归并过程类似于一颗二叉树的构建过程，次数就是二叉树的高
度，即log2n,所以归并排序的时间复杂度为O(nlog2n)。

2.2空间复杂度

由于归并排序在归并过程中需要额外的一个「辅助数组」，并且最大长度为原数组长度，所
以「归并排序」的空间复杂度为O(n)。

3.算法优缺点

3.1算法的优点

1.稳定性：归并算法是一种稳定的排序算法，这意味着在排序过程中，相同元素的相对顺序保持不
变。
2.可扩展性：归并算法可以很容易地扩展到并行计算环境中，通过并行归并来提高排序效率。

3.2算法的缺点

1.额外空间：归并算法需要使用额外的辅助空间来存储合并后的结果，这对于内存受限的情况可自
是一个问题。
2.复杂性：归并算法的实现相对复杂，相比于其它一些简单的排序。

4.优化方案

「归并排序」在众多排序算法中效率较高，时间复杂度为O(nlog2n)。
但是，由于归并排序在归并过程中需要额外的一个「辅助数组」，所以申请「辅助数组」内存空间带来的时间消耗会比较大，比较好的做法是，实现用一个和给定元素个数一样大的数组，作为函数传参传进去，所有的「辅助数组」干的事情，都可以在这个传参进去的数组上进行操作，这样就免去了内存的频繁申请和释放。

5.代码演示

void merge(int arr[], int left, int mid, int right) {  
    int i, j, k;  
    int n1 = mid - left + 1;  
    int n2 = right - mid;  
      
    // 创建临时数组  
    int L[n1], R[n2];  
    // 将数据复制到临时数组 L[] 和 R[]    for (i = 0; i < n1; i++)  
        L[i] = arr[left + i];  
    for (j = 0; j < n2; j++)  
        R[j] = arr[mid + 1 + j];  
      
    // 归并临时数组到 arr[]    i = 0; // 初始化第一个子数组的索引  
    j = 0; // 初始化第二个子数组的索引  
    k = left; // 初始化合并后子数组的索引  
    while (i < n1 && j < n2) {  
        if (L[i] <= R[j]) {  
            arr[k] = L[i];  
            i++;  
        }  
        else {  
            arr[k] = R[j];  
            j++;  
        }  
        k++;  
    }  
    // 将 L[] 的剩余元素复制到 arr[]    while (i < n1) {  
        arr[k] = L[i];  
        i++;  
        k++;  
    }  
    // 将 R[] 的剩余元素复制到 arr[]    while (j < n2) {  
        arr[k] = R[j];  
        j++;  
        k++;  
    }  
}  
  
// 归并排序函数  
void merge_sort(int arr[], int left, int right) {  
    if (left < right) {  
        // 找到中间点  
        int mid = left + (right - left) / 2;  
          
        // 递归地对左右两半进行排序  
        merge_sort(arr, left, mid);  
        merge_sort(arr, mid + 1, right);  
          
        // 合并已排序的两个子数组  
        merge(arr, left, mid, right);  
    }  
}

6.实战

6.1力扣912 排序数组

给你一个整数数组 nums，请你将该数组升序排列。

void merge(int arr[], int left, int mid, int right) {

    int i, j, k;

    int n1 = mid - left + 1;

    int n2 = right - mid;

    // 创建临时数组

    int L[n1], R[n2];

    // 将数据复制到临时数组 L[] 和 R[]

    for (i = 0; i < n1; i++)

        L[i] = arr[left + i];

    for (j = 0; j < n2; j++)

        R[j] = arr[mid + 1 + j];

    // 归并临时数组到 arr[]

    i = 0; // 初始化第一个子数组的索引

    j = 0; // 初始化第二个子数组的索引

    k = left; // 初始化合并后子数组的索引

    while (i < n1 && j < n2) {

        if (L[i] <= R[j]) {

            arr[k] = L[i];

            i++;

        }

        else {

            arr[k] = R[j];

            j++;

        }

        k++;

    }

    // 将 L[] 的剩余元素复制到 arr[]

    while (i < n1) {

        arr[k] = L[i];

        i++;

        k++;

    }

    // 将 R[] 的剩余元素复制到 arr[]

    while (j < n2) {

        arr[k] = R[j];

        j++;

        k++;

    }
}

// 归并排序函数
void merge_sort(int arr[], int left, int right) {
    if (left < right) {
        // 找到中间点
        int mid = left + (right - left) / 2;

        // 递归地对左右两半进行排序
		merge_sort(arr, left, mid);
        merge_sort(arr, mid + 1, right);

        // 合并已排序的两个子数组
        merge(arr, left, mid, right);
    }

}

int* sortArray(int* nums, int numsSize, int* returnSize) {
    merge_sort(nums,0,numsSize - 1);
    *returnSize = numsSize;
    return nums;

}

6.2力扣148 排序链表

给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表。

struct ListNode* sortList(struct ListNode* head) {  
    //排序板子  
    struct ListNode *radix[10], *ptr[10];  
    for(int i = 0; i < 10; ++i){  
        radix[i] = (struct ListNode*)malloc(sizeof(struct ListNode));  
        radix[i]->next = NULL;  
        ptr[i] = radix[i];  
    }  
    //开始基数排序，cur为当前待排序节点  
    struct ListNode* cur = head, *temp;  
    for(int bit = 1; bit <= 100000; bit *= 10){  
        //插到板子上  
        while(cur){  
            temp = cur->next;  
            int px = ((cur->val+100000)/ bit) % 10;  
            ptr[px]->next = cur;  
            cur->next = NULL;  
            ptr[px] = ptr[px]->next;  
            cur = temp;  
        }  
        //收集  
        struct ListNode *prev = ptr[0];  
        for(int i = 1; i < 10; ++i){  
            if(radix[i]->next){  
                prev->next = radix[i]->next;  
                prev = ptr[i];  
            }  
        }  
        //新的开始节点  
        cur = radix[0]->next;  
        //恢复板子为空  
        for(int i = 0; i < 10; ++i){  
            radix[i]->next = NULL;  
            ptr[i] = radix[i];  
        }  
    }  
    return cur;  
}