插入排序与归并排序

浅谈插入排序与归并排序

关于排序似乎从大一开始学习变成就开始在使用各种排序方法了，今天看了下有关于插入排序和归并排序的内容，并且对应在 LeetCode 上面做了两道测试题，因此就对插入排序和归并排序做一个简单的小结吧，就当做是我的学习笔记，大佬请勿嘲笑！

• 插入排序
• 归并排序

---

插入排序

关于插入排序主要的思想就是从左到右的遍历一个序列，有一个标识来标记，保证左边的序列有序，再往右遍历的过程中将序列中的一个元素插入到左边的序列里面，插入之后左边的序列仍然保持有序，如果是一个数组的话那么在遍历插入之前会伴随着数字的移动。

具体的来看一个例子：题目很简洁，只有一句话：Sort a linked list using insertion sort. 对于这样一个题目，虽然要采用插入算法的思路但是我在做的时候并没有直接对链表使用插入算法，而是用一个数组将链表中的内容复制下来，排序之后再放回到链表中！以下是代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* insertionSortList(struct ListNode* head) {
    if(head != NULL) {
        int* arr = (int*)malloc(sizeof(1) * 10000);
        int len = 0;
        int key = 0;
        int j = 0;
        struct ListNode* start = head;
        while (start != NULL) {
            arr[len] = start->val;
            len++;
            start = start->next;
        }
        if (len > 1) {
            for (int i = 1; i < len; i++) {
                key = arr[i];
                j = i - 1;
                while (j >= 0 && arr[j] > key) {
                    arr[j + 1] = arr[j];
                    j -= 1;
                }
                arr[j + 1] = key;
            }
        }
        start = head;
        j = 0;
        while (start != NULL) {
            start->val = arr[j];
            start = start->next;
            j += 1;
        }
        free(arr);
    }
    return head;
}

这个算法在最好的情况下的时间复杂度就是遍历这个序列的时间复杂度O（n），这个时候这个序列是已经排好序的；最糟糕的情况下的时间复杂度的O（n^2），这个时候这个序列是按照相反的顺序排列的，这里就不再赘述对这个算法正确性以及时间复杂度的分析，接下来以归并排序为例来分析时间复杂度！

归并排序

归并排序遵循了分治模式，直观上就是分解：分解带排序的元素的序列成各具n/2个元素的两个子序列；解决：使用归并排序递归的排序两个子序列；合并：合并两个已排序的子序列以产生已排序的答案。

首先看看如何合并已排序的两个数组，为了避免在每一个基本步骤都必须检查数组是否已经到了最末端，在两个数组的最末端都放置了哨兵——将两个数组的最末端的元素设置为最大，这样就可以避免对数组的检查：

 int* MergeSort(int* arr, int p, int q, int r) {
        //the sort interval is arr[p, q] to arr[q + 1, r]
        int n1 = q - p + 1;
        int n2 = r - q;
        int* left = (int*)malloc(sizeof(1) * (n1+1));
        int* right = (int*)malloc(sizeof(1) * (n2+1));
        for (int i = p; i <= q; i++)
            left[i-p] = arr[i];
        for (int i = q + 1; i <= r; i++)
            right[i - q - 1] = arr[i];
        left[n1] = INT_MAX;
        right[n2] = INT_MAX;
        int i = 0;
        int j = 0;
        for (int k = p; k <= r; k++) {
            if (left[i] <= right[j]) {
                arr[k] = left[i];
                i += 1;
            }
            else if (left[i] > right[j]) {
                arr[k] = right[j];
                j += 1;
            }
        }
        free(left);
        free(right);
        return arr;
    }

下面使用循环不变式方法来证明这个算法的正确性：
初始化：在循环的第一次迭代之前，有k=p,数组arr[p, k - 1]为空，i， j 均为0，说明left[i]和right[j]都是各自所在数组里最小的元素，且这两个元素均没有被复制到arr数组里面；
保持：为了更好的理解循环不变式，首先假设left[i] <= right[j]，这时left[i]是最小的没有被复制到数组里的最小的元素，将left[i]复制到数组里面之后数组arr[p…k]包含了k-p-1个最小的元素，然后p 和 i，均加1，为下一次迭代重新建立了循环不变式。
终止：循环终止的条件是k=r+1。这个时候数组包含了两个数组的所有元素，且是有序的。
综上所述，证明了上述算法的正确性！

接下来考虑递归算法：

 int* Merge(int* arr, int p, int r) {
        if (p < r) {
            int q = (p + r) / 2;
            Merge(arr, p, q);
            Merge(arr, q + 1, r);
            MergeSort(arr, p, q, r);
        }
        return arr;
    }

递归算法将一个数组分成两半，分别对这两半进行排序之后，再将这两个排好序的数组组合成为一个数组。

接下来分析归并算法的时间复杂度：
每一次都将一个节点划分成为两个，直到所有的节点都被划分成为最小的单位为止，划分的时候会产生log n + 1层，而对于每一层的划分，总的代价都是cn(遍历大数组，产生每一个小数组)，所以递归的总的代价就是cn(log n + 1) ，时间复杂度为 n(log n).

以下是本次在LeetCode上面所做的题目： Sort a linked list in O(n log n) time using constant space complexity.
根据上面的分析，程序如下所示：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* sortList(struct ListNode* head) {
     int* MergeSort(int* arr, int p, int q, int r) {
        //the sort interval is arr[p, q] to arr[q + 1, r]
        int n1 = q - p + 1;
        int n2 = r - q;
        int* left = (int*)malloc(sizeof(1) * (n1+1));
        int* right = (int*)malloc(sizeof(1) * (n2+1));
        for (int i = p; i <= q; i++)
            left[i-p] = arr[i];
        for (int i = q + 1; i <= r; i++)
            right[i - q - 1] = arr[i];
        left[n1] = INT_MAX;
        right[n2] = INT_MAX;
        int i = 0;
        int j = 0;
        for (int k = p; k <= r; k++) {
            if (left[i] <= right[j]) {
                arr[k] = left[i];
                i += 1;
            }
            else if (left[i] > right[j]) {
                arr[k] = right[j];
                j += 1;
            }
        }
        free(left);
        free(right);
        return arr;
    }

    int* Merge(int* arr, int p, int r) {
        if (p < r) {
            int q = (p + r) / 2;
            Merge(arr, p, q);
            Merge(arr, q + 1, r);
            MergeSort(arr, p, q, r);
        }
        return arr;
    }

    int size = 0;
    struct ListNode* temp = head;
    while (temp != NULL) {
        size ++;
        temp = temp -> next;
    }
    if (size > 1) {
        int* arr1 = (int*)malloc(sizeof(1) * size);
        size = 0;
        temp = head;
        while (temp != NULL) {
            arr1[size] = temp -> val;
            size ++;
            temp = temp -> next;
        }

        Merge(arr1, 0, size - 1);
        temp = head;
        size = 0;
        while (temp != NULL) {
            temp -> val = arr1[size];
            size ++;
            temp = temp -> next;
        }
        free(arr1);
    }

    return head;
}

参考: 算法导论 Thomas H. Cormen Charles E. Leiserson
Ronald L. Rivest Clifford Stein. 机械工业出版社！