学完排序算法，终于知道用什么方法给监考完收上来的试卷排序……

由于每个老师批改完卷子之后装袋不一定是有序的，鼠鼠我被拉去当给试卷排序的苦力。面对堆积成山的试卷袋，每一份试卷袋的试卷集又很重，鼠鼠我啊为了尽早下班，决定用一种良好的办法进行排序。

1.插入排序

首先考虑的是插入排序。第一份试卷就当做已经有序了；第二份试卷序号如果比第一份试卷小，那么放在第一份试卷的上面，否则放在下面；第三份试卷又放在前两份试卷集合的正确位置。总之，保证我拿到一份试卷，这一份试卷就插入到了正确的位置。

这一个排序算法看起来是生活中用的最常见的（因为看上去其他苦力鼠鼠也是这么干的），代码也是比较好写的：i迭代完1次说明1个元素有了相对排好序的位置。注意，第一次我们跳过了i=0，实际上默认第一个就是相对有序的（本来它就只有一个，所以有序）。i = 1，说明我们正在给i=1的试卷进行插入操作，而前面如果排好序的元素大于它，就一个一个往后移，直到找到一个学号小于当前我们拿到的试卷上填的学号，我们就放在这个试卷的后面。

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        for(int i = 1; i < nums.size(); ++i){//从第二个开始排
            int key = nums[i];
            int j = i - 1;
            while(j >= 0 && nums[j] > key){
                nums[j + 1] = nums[j];
                j = j - 1;
            }
            nums[j + 1] = key;

        }
        return nums;
    }
};

再来一个注释版本，跟上面是一样的

#include <vector>
using namespace std;

class Solution {
public:
    void insertionSort(vector<int>& nums) {
        int n = nums.size();
        for (int i = 1; i < n; i++) {
            int key = nums[i]; // 取出未排序部分的第一个元素
            int j = i - 1;

            // 将大于key的元素向后移动一个位置
            while (j >= 0 && nums[j] > key) {
                nums[j + 1] = nums[j];
                j = j - 1;
            }
            nums[j + 1] = key; // 找到了key的正确位置，插入key
        }
    }

    vector<int> sortArray(vector<int>& nums) {
        insertionSort(nums);
        return nums;
    }
};

2. 改良：归并+插入排序

但是试卷实在太重了，一个班有60个人，每个人有2页试卷，2页答题纸，2页草稿纸……排序到后面，鼠鼠真的没有力气捧着排好序的试卷挨个插入。

于是聪明的鼠鼠想了一个办法：把试卷分成两叠（或者更多叠，看试卷一共有多少份）。两叠内用插入排序，那么能够得到两叠排好序的试卷，这样鼠鼠每次捧在手上的试卷少了，插入排序也排的很轻松（知识点：插入排序对小数据集非常高效）。

而针对两叠有序的试卷，就可以进行归并排序了。注意，这只是归并排序中两块merge的部分操作，而省去了归并排序中递归拆分到大小为1然后再两两merge的操作。简单来说，这里使用到了归并排序的最后一步，在我参考的博客中找了个图如下，用到的是红框中标出的排序理念：

此时，我们其实是双指针分别指着两堆试卷的头，哪个序号小就放在temp数组里面，最后我们的temp数组就存放了所有的排好序的试卷（真是伟大的鼠鼠，聪明的鼠鼠！）如果一个班的同学更多一点，那么我们实际上可以将其分成四份，合并过程则为该图的后三行。1、2两个数组先合并，3、4两个数组先合并，最后剩下来的两个数组继续合并。

归并排序算法如下：

代码思路也很简单，主要是用到的递归。第一个merge块其实就是做了我刚刚给两坨有序试卷双指针飞快排序的过程；而第二个merge_recursive实际上是做了图上第一块讲的“一拆二”的过程，拆到每份试卷只剩一个，再进行merge。

class Solution {
public:
    void merge(int left,  int mid, int right,vector<int>& nums, vector<int>& temp){
        int i = left;
        int j = mid + 1;
        int k = 0;
        while(i <= mid && j <= right){
            if(nums[i] <= nums[j])
                temp[k++] = nums[i++];
            else temp[k++] = nums[j++];
        }
        while(i <= mid){
            temp[k++] = nums[i++];
        }
        while(j <= right){
            temp[k++] = nums[j++];
        }

        for (i = left, k = 0; i <= right; i++, k++) {
            nums[i] = temp[k];
        }
    }

    void merge_recursive(int left, int right, vector<int>&nums, vector<int>& temp){
        if(left < right){
            int mid = left + (right - left)/2;
            merge_recursive(left, mid, nums, temp);
            merge_recursive(mid + 1, right, nums, temp);
            merge(left, mid, right, nums, temp);
        }
    }
    vector<int> sortArray(vector<int>& nums) {
        vector<int> temp(nums.size());
        merge_recursive(0, nums.size() - 1, nums, temp);
        return nums;
    }
};

下面仍旧是一个写好注释的版本：

#include <vector>
using namespace std;

// 归并操作，合并两个有序数组段[arr[left..mid]]和[arr[mid+1..right]]为一个有序数组段[arr[left..right]]
// temp是一个临时数组，用于存储合并后的有序序列，避免直接在原数组上操作导致的数据错乱
void merge(vector<int>& arr, int left, int mid, int right, vector<int>& temp) {
    int i = left; // 左半部分的起始位置
    int j = mid + 1; // 右半部分的起始位置
    int k = 0; // temp数组的当前索引

    // 遍历两个数组，按顺序选择较小的元素放入temp中
    while (i <= mid && j <= right) {
        if (arr[i] <= arr[j]) {
            temp[k++] = arr[i++];
        } else {
            temp[k++] = arr[j++];
        }
    }

    // 如果左半部分还有剩余，将剩余元素复制到temp中
    while (i <= mid) {
        temp[k++] = arr[i++];
    }

    // 如果右半部分还有剩余，将剩余元素复制到temp中
    while (j <= right) {
        temp[k++] = arr[j++];
    }

    // 将排序后的temp数组复制回原数组arr
    for (i = left, k = 0; i <= right; i++, k++) {
        arr[i] = temp[k];
    }
}

// 递归执行归并排序
// left是数组段的起始位置，right是数组段的结束位置
void mergeSortRecursive(vector<int>& arr, int left, int right, vector<int>& temp) {
    if (left < right) { // 如果当前数组段不是单元素
        int mid = left + (right - left) / 2; // 计算中间位置
        // 递归排序左半部分
        mergeSortRecursive(arr, left, mid, temp);
        // 递归排序右半部分
        mergeSortRecursive(arr, mid + 1, right, temp);
        // 合并两个有序的部分
        merge(arr, left, mid, right, temp);
    }
}

// 归并排序的主函数，返回排序后的数组
vector<int> sortArray(vector<int>& nums) {
    vector<int> temp(nums.size()); // 创建一个临时数组，大小与原数组相同
    mergeSortRecursive(nums, 0, nums.size() - 1, temp); // 从整个数组的范围开始递归排序
    return nums;
}

3.在排好试卷以后……

鼠鼠希望找到更加高效的方法，于是深入学习了冒泡排序、快速排序、堆排序、选择排序、希尔排序、桶排序和基数排序。在这里与大家分享学习心得，让大家加入鼠鼠大家庭 更快地排序。

对于桶排序、基数排序、希尔排序，不打算写代码，所以浅讲思路。

3.1 桶排序：

假设我们有一组0到99的数字，我们用10个桶来对它们进行排序，每个桶负责一个范围：0-9, 10-19, …, 90-99。将数字根据它们的十位数分配到对应的桶中。
每个桶里面，再进行排序，这里随便你选用什么算法，最好还是插入排序，又稳定，又适应小数据集。这样，每个桶内都是有序的。如果选择插入排序，那么顺带着整个桶排序都是稳定的。
此时再对桶间进行排序。由于每个桶对应的数字范围是不重叠的，我们只需要按桶的顺序依次将桶内的元素合并起来，就可以得到一个有序数组，所以桶间不需要排序。

3.2 基数排序

假设有很多长度相同的数字，我们有0-9 一共10个桶。个位为1的全放到桶1，为2的全放到桶2，……按个位排好了再去排十位，百位。排到最后一位，就是全部有序的了。

3.3 希尔排序

希尔排序是插入排序的升级版，它的优势在于能够快速地把较大的数放到该去的位置附近。第一次排序以较大的一个数x作为间隔，相隔x的数都收集起来进行一个插入排序；然后间隔减小，再插入排序；最后间隔减小到1，此时就已经基本上完全有序了。这个解释不清楚，需要看动图理解。此处略过。

4. 冒泡排序、快速排序、选择排序、堆排序

4.1 冒泡排序

使用flag来标明排好序，也就是说在一次遍历的过程中没有发生任何交换。注意，看代码是从j开始看，外层的i仅仅用来表明j应该到哪里结束（每一次循环，把最大的放到nums的尾部，这样尾部就不用参加两两交换的过程了。）

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        int n = nums.size();
        bool flag = true;
        for(int i = 0; flag && i < n - 1; ++i){
            bool flag = false;
            for(int j = 0; j < n - i - 1; ++j){
                if(nums[j] > nums[j + 1]){
                    flag = true;
                    // swap(nums[j], nums[j + 1]);
                    nums[j] = nums[j]^nums[j + 1];
                    nums[j + 1] = nums[j] ^ nums[j + 1];
                    nums[j] = nums[j] ^ nums[j + 1];
                }
            }
        }
        return nums;
    }
};

4.2 快速排序

这里我使用了双指针，似乎还有什么单指针，还有随机化、三向之类的用于描述快排算法细分类的写法。我自定义这里为未随机化（因为每次基准选的是最后一位）+二向（我是两个方向，前后夹击），不知道是否正确，总之感觉这是一个比较好理解的代码。
在quickSort函数里，我们定义了partition_id,并且根据这个partition_id左右切分，继续快排，直到start >= end， 也就是说没有计算partition_id的必要了。
再看partition函数，左右指针分别抓取一个不合规的元素(左边指针指着比最后一个元素小的值，右边指针指着一个比最后一个元素大的值)，然后交换，一直到左右指针重叠，或者左指针大于右指针。此时把最后一个元素和左指针指向的元素进行交换（这里如果不懂为什么是左指针指向的，手动排个序试一试吧），返回的partition就是left指针指向的id。

class Solution {
public:
    int partition(int start, int end, vector<int>& nums){
        int pivot = end;
        int left = start;
        int right = end - 1;

        while(1){
            while(left <= right && nums[left] <= nums[pivot]){
                left++;
            }

            while(left <= right && nums[right] > nums[pivot]){
                right--;
            }
            if(left >= right) break;
            swap(nums[left], nums[right]);
            left++;
            right--;
        }

        swap(nums[pivot], nums[left]);
        return left;
    }

    void quickSort(int start, int end, vector<int>& nums){
        if(start < end){
            int partition_id = partition(start, end, nums);
            quickSort(start, partition_id - 1, nums);
            quickSort(partition_id + 1, end, nums);
        }
    }

    vector<int> sortArray(vector<int>& nums) {
        quickSort(0, nums.size() - 1, nums);
        return nums;
    }
};

4.3 选择排序

我宣布选择排序是最简单的排序算法，就是选最小值，放到第一个，选后面最小值，放到第二个。

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        for(int i = 0; i < nums.size(); ++i){
            int min_index = i;
            for(int j = i; j < nums.size(); ++j){
                if(nums[j] < nums[min_index]) min_index = j;
            }
            swap(nums[i], nums[min_index]);
        }

        return nums;
    }
};

4.4 堆排序

堆排序让我很意外时间复杂度是O(nlogn)。其实是不信建堆时间只要O(n)。但是：我们对n/2 个节点以它们为根节点的树进行调整，确实是每个只要跟子节点进行比较一下就好了，如果有涉及到子节点调整那也不会增加太多时间。或者这么理解：虽然对于每个节点调用heapify的成本是O(log n)，但是按照完全二叉树的性质，底层的节点数量最多，而且对于这些节点heapify的成本接近于O(1)。因此，整体平均下来，构建最大堆的过程可以被认为是线性的。所以说确实是O(n)的建堆时间。heapSort里先对于非叶子节点一层一层往上调整根为最大，然后如果交换完了则需要对交换的子节点再次调整。heapify即是一个能够把当前i节点视为树根节点，并且保证i节点为树里最大节点、底下节点也满足根最大的一个函数

class Solution {
public:
    void heapify(vector<int>&nums, int n, int i){
        int largest = i;
        int left = 2*i + 1;
        int right = 2*i + 2;
        if(left < n && nums[left] > nums[largest])
            largest = left;
        if(right < n && nums[right] > nums[largest])
            largest = right;
        if(largest != i){
            swap(nums[i], nums[largest]);
            heapify(nums, n, largest);
        }
    }
    
    void heapSort(vector<int>& nums){
        int n = nums.size();
        // 构建最大堆
        for(int i = n/2 - 1; i >= 0; i--){
            heapify(nums, n, i);//nums一共是n个节点，根是第i个节点
        } 
        //堆顶取值
        for(int i = n - 1; i > 0; i--){
            swap(nums[0],nums[i]);
            heapify(nums, i, 0);//剩下要调整的nums一共是i个节点，根是第0个节点
        }
    }
    
    vector<int> sortArray(vector<int>& nums) {
        heapSort(nums);
        return nums;
    }
};

至于稳定性、时间复杂度，鼠鼠又搬运一波