排序相关知识（归并排序&快速排序代码）

插入排序（稳定）

void insertSort(vector<int>& nums) {
    int len = nums.size();
    for(int i = 1; i < len; i++) {
        int key = nums[i];
        int j = i - 1;
        while(j >= 0 && nums[j] > key) {
            nums[j + 1] = nums[j];
            j--;
        }
        nums[j + 1] = key;
    }
}

快速排序代码：

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        quickSort(nums, 0, (int) nums.size() - 1);
        return nums;
    }
    void quickSort(vector<int>& nums, int left, int right) {
        if(left > right) return;
        int j = partition(nums, left, right);
        quickSort(nums, left, j - 1);
        quickSort(nums, j + 1, right);
    }
    int partition(vector<int>& nums, int left, int right) {
        
        int i = left + 1;
        int j = right;
        int pivot = nums[left];
        
        while(i <= j) {
            
            while (i <= j && nums[i] <= pivot) i++; //之前没有加上 i <= j就出现了一堆问题。
            while (i <= j && nums[j] >= pivot) j--;
            
            if(i < j) swap(nums[i++], nums[j--]);
            else i++;
        }
        swap(nums[j], nums[left]);
        return j;
    }
};

归并排序(稳定）：

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
     
        mergeSort(nums, 0, (int) nums.size() - 1);
        return nums;
    }
    
    void mergeSort(vector<int>&nums, int start, int end) {
        if(start >= end) return;
        
        int mid = start + (end - start) / 2;
        mergeSort(nums, start, mid);
        mergeSort(nums, mid + 1, end);
        return merge(nums, start, mid, end);
    }
    
    void merge(vector<int>& nums, int start, int mid, int end) {
        
        vector<int> tmp(end - start + 1);
        int i = start, j = mid + 1, k = 0;
        while( i <= mid && j <= end){
            if(nums[i] < nums[j]) tmp[k++] = nums[i++];
            else tmp[k++] = nums[j++];
        }
        while(i <= mid) tmp[k++] = nums[i++];
        while(j <= end) tmp[k++] = nums[j++];
        for(int idx = start; idx <= end; idx++) {
            nums[idx] = tmp[idx - start];
        }
    }
};

堆排序：

void swap(vector<int>& arr, int a, int b) {
    arr[a] = arr[a] ^ arr[b];
    arr[b] = arr[a] ^ arr[b];
    arr[a] = arr[a] ^ arr[b];
}

void adjust(vector<int>& arr, int len, int index) {
    
    int maxid = index;
    int left = 2 * index + 1, right = 2 * index + 2;
    
    if(left < len && arr[left] < arr[maxid]) maxid = left;
    if(right < len && arr[right] < arr[maxid]) maxid = right;
    
    if(maxid != index) {
        swap(arr, maxid, index);
        adjust(arr, len, maxid);
    }

}
void HeapSort(vector<int>& arr, int len) {
    
    for(int i = (len - 1 - 1) / 2; i >= 0; i--) 
        adjust(arr, len, i);
    
    for(int i = len - 1; i > 0; i--) {
        swap(arr, 0, i);
        adjust(arr, i, 0);
     }
}