手撕力扣之排序：排序数组、数组中的逆序对、排序链表、最小的k个数、数组中的第K个最大元素、前 K 个高频元素、根据身高重建队列、最大数、下一个排列、下一个更大元素 III、最大交换、字典序的第K小数字

力扣912. 排序数组
给你一个整数数组 nums，请你将该数组升序排列。
方法一：归并排序

class Solution {
   
public:
    vector<int> tmp;
    void mergeSort(vector<int>& nums, int l, int r) {
   
        if (l >= r) return;
        int mid = (l + r) >> 1;
        mergeSort(nums, l, mid);
        mergeSort(nums, mid + 1, r);
        int i = l, j = mid + 1;
        int cnt = 0;
        while (i <= mid && j <= r) {
   
            if (nums[i] < nums[j]) {
   
                tmp[cnt ++] = nums[i ++];
            } else {
   
                tmp[cnt ++] = nums[j ++];
            }
        }
        while (i <= mid) tmp[cnt ++] = nums[i ++];
        while (j <= r) tmp[cnt ++] = nums[j ++];
        for (int i = 0; i < r - l + 1; i ++) nums[i + l] = tmp[i];
    }
    vector<int> sortArray(vector<int>& nums) {
   
        tmp.resize((int)nums.size(), 0);
        mergeSort(nums, 0, (int)nums.size() - 1);
        return nums;
    }
};

作者：yizhe-shi
链接：https://leetcode-cn.com/problems/sort-an-array/solution/c-ji-chong-ji-ben-de-pai-xu-suan-fa-by-yizhe-shi/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

方法二：堆排序
思路：建立最大堆，下标为0的数组值是最大值。不断地取出堆顶的值放到数组的最后，而堆的规模也在一直调整，变小。

class Solution {
   
public:
    void heapAdjust(vector<int>& nums,int startIndex,int length)
    {
   
        int maxIndex=2*startIndex+1;
        while(maxIndex<length)
        {
   
            if((maxIndex+1)<length&&nums[maxIndex+1]>nums[maxIndex])  maxIndex++;
            if(nums[maxIndex]>nums[startIndex])
            {
   
                int temp=nums[maxIndex];
                nums[maxIndex]=nums[startIndex];
                nums[startIndex]=temp;
                startIndex=maxIndex;
                maxIndex=2*startIndex+1;
            }
            else break;
        }
    }
    vector<int> sortArray(vector<int>& nums) {
   
        int n=nums.size();
        // 所有非叶子节点从后往前依次下沉
        for(int i=n/2-1;i>=0;i--)
        {
   
            heapAdjust(nums,i,n);
        }
        for(int i=n-1;i>0;i--)
        {
   
            int temp=nums[0];
            nums[0]=nums[i];
            nums[i]=temp;
            heapAdjust(nums,0,i);
        }
        return nums;
    }
};

方法三：快速排序

class Solution {
   
public:
    int partition(vector<int>& nums,int l,int r){
   
        int begin=l;
        swap(nums[l],nums[l+rand()%(r-l)]);
        while(l<r){
   
            while(l<r && nums[begin]<nums[r]){
   
                r--;
            }
            while(l<r && nums[begin]>=nums[l]){
   
                l++;
            }
            swap(nums[l],nums[r]);
        }
        swap(nums[l],nums[begin]);

        return l;
    }

    void quick_sort(vector<int>& nums,int l,int r){
   
        if(l>=r){
   
            return;
        }
        int index=partition(nums,l,r);
        
        quick_sort(nums,l,index-1);
        quick_sort(nums,index+1,r);
    }

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

作者：zhang-jian-qi-shi
链接：https://leetcode.cn/problems/sort-an-array/solution/by-zhang-jian-qi-shi-3722/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

剑指 Offer 51. 数组中的逆序对
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。
归并排序法：

class Solution {
   
public:
    int count;
    vector<int> tmp;
    void mergeSort(