数组：经典排序

LeetCode912. 堆排序

https://leetcode-cn.com/problems/sort-an-array/

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

输入：nums = [5,2,3,1]
输出：[1,2,3,5]

思路

采用堆排序。

首先，将数组调整大根堆；

然后，每次将队头元素与队尾元素交换，队尾元素已放到最终位置，对队头元素向下调堆(重新调整为大根堆)。循环此操作直到大根堆中仅剩一个元素。

代码

class Solution 
{
private:
    void adjustDown(vector<int>& nums, int k, int end)
    {
        for (int i = 2 * k + 1; i <= end; i = 2 * i + 1)
        {
            if (i + 1 <= end && nums[i] < nums[i + 1])
            {
                ++i;
            }
            if (nums[k] > nums[i])
            {
                break;
            }
            else
            {
                swap(nums[k], nums[i]);
            }
            k = i;
        }
    }
    
    void buildMaxHeap(vector<int>& nums)
    {
        int sz = nums.size();

        for (int k = sz / 2 - 1; k >= 0; --k)
        {
            adjustDown(nums, k, sz - 1);
        }
    }

    void heapSort(vector<int>& nums)
    {
        int sz = nums.size();

        buildMaxHeap(nums);
        for (int i = sz - 1; i >= 1; --i)
        {
            swap(nums[0], nums[i]);
            adjustDown(nums, 0, i - 1);
        }
    }

public:
    vector<int> sortArray(vector<int>& nums) 
    {
        heapSort(nums);
        
        return nums;
    }
};

Leet215. 数组中的第K个最大元素

https://leetcode-cn.com/problems/kth-largest-element-in-an-array/

在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

输入: [3,2,1,5,6,4] 和 k = 2
输出: 5

思路

使用快速排序思想。

由于快速排序的每一趟partition都会确定一个元素的最终位置，所以只要确定的位置是倒数第 k 个下标的时候，我们就已经找到了答案。

代码

class Solution 
{
private:
    int partition(vector<int>& nums, int left, int right)
    {
        int randPos = left + rand() % (right - left + 1);
        swap(nums[left], nums[randPos]);

        int pivot = nums[left];
        while (left < right) 
        {
            while (left < right && nums[right] >= pivot)
            {
                --right;
            }
            nums[left] = nums[right];

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

        nums[left] = pivot;
        
        return left;
    }

    int quickSort(vector<int>& nums, int left, int right, int target)
    {
        int pivotPos = partition(nums, left, right);

        if (pivotPos == target)
        {
            return nums[pivotPos];
        }
        else if (pivotPos > target)
        {
            return quickSort(nums, left, pivotPos - 1, target);           
        }
        else
        {
            return quickSort(nums, pivotPos + 1, right, target);
        }
    }
public:
    int findKthLargest(vector<int>& nums, int k) 
    {
        int size = nums.size();
        
        return quickSort(nums, 0, size - 1, size - k);
    }
};

剑指Offer40. 最小的k个数

https://leetcode-cn.com/problems/zui-xiao-de-kge-shu-lcof/

输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。

输入：arr = [3,2,1], k = 2
输出：[1,2] 或者 [2,1]

思路

使用快速排序思想。

由于快速排序的每一趟partition都会确定一个元素的最终位置，所以只要确定的位置是第 k 个下标的时候，我们就已经找到了答案。

代码

class Solution 
{
private:
    int partition(vector<int>& arr, int left, int right)
    {
        int randPos = left + rand() % (right - left + 1);
        swap(arr[left], arr[randPos]);

        int pivot = arr[left];
        while (left < right)
        {
            while (left < right && arr[right] >= pivot)
            {
                --right;
            }
            arr[left] = arr[right];

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

        return left;
    }

    vector<int> quickSearch(vector<int>& arr, int left, int right, int target)
    {
        int pivotPos = partition(arr, left, right);

        if (pivotPos == target)
        {
            return vector<int>(arr.begin(), arr.begin() + target + 1);
        }
        else if (pivotPos > target)
        {
            return quickSearch(arr, left, pivotPos - 1, target);   
        }
        else
        {
            return quickSearch(arr, pivotPos + 1, right, target);
        }
    }
public:
    vector<int> getLeastNumbers(vector<int>& arr, int k) 
    {
        int size = arr.size();
        if (size == 0 || k == 0)
        {
            return vector<int>{};
        }

        return quickSearch(arr, 0, size - 1, k - 1);
    }
};

剑指Offer51. 数组中的逆序对

https://leetcode-cn.com/problems/shu-zu-zhong-de-ni-xu-dui-lcof/

在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。

输入: [7,5,6,4]
输出: 5

思路

使用归并排序思想。

归并排序采用先分后合的策略：前面「分」的时候什么都不做，「合」的过程中计算「逆序对」的个数，关键就在于「合并两个有序数组」的步骤，利用数组的部分有序性，一下子计算出右区间中的数对应左区间所有逆序对的个数。由于左右区间两个数组有序，所以只要在「合」的过程中发现右区间中的数小于左区间的数就可以将这个数对应左区间所有逆序对的个数求出。

代码

class Solution {
private:
    int merge(vector<int>& nums, vector<int>& temp, int left, int mid, int right)
    {
        for (int i = left; i <= right; ++i)
        {
            temp[i] = nums[i];
        }

        int count = 0;       
        int i = left, j = mid + 1, k = left;
        while (i <= mid && j <= right)
        {
            if (temp[i] <= temp[j])
            {
                nums[k++] = temp[i++];
            }
            else
            { 
                count = count + (mid - i + 1);
                nums[k++] = temp[j++];
            }
        }

        while (i <= mid)
        {
            nums[k++] = temp[i++];
        }

        while (j <= right)
        {
            nums[k++] = temp[j++];
        }

        return count;    
    }

    int mergeSort(vector<int>& nums, vector<int>& temp, int left, int right)
    {
        if (left == right)
        {
            return 0;
        }

        int mid = left + (right - left) / 2;
        int leftCount = mergeSort(nums, temp, left, mid);
        int rightCount = mergeSort(nums, temp, mid + 1, right);
        int crossCount = merge(nums, temp, left, mid, right);

        return leftCount + rightCount + crossCount;
    }
public:
    int reversePairs(vector<int>& nums) 
    {
        int size = nums.size();
        if (size == 0 || size == 1)
        {
            return 0;
        }

        vector<int> temp(size);
        return mergeSort(nums, temp, 0, size - 1);
    }
};