常见排序：快排、堆排；快速选择

912. 排序数组 - 力扣（LeetCode） (leetcode-cn.com)

快速排序

原理：随机选取一个元素作为pivot，对其左右进行划分，并对新的到的部分重复上述操作。最后得到的就是有序数列。

划分partition：

• 对于左右边界分别为l和r的子数组，设置两个指针i和j，初始i=l-1，j=l。指针i和j维护一个子数组中的划分：i以及i左侧的元素均<=pivot；i+1至j的元素则均>pivot，j后的元素还未遍历。
• 对于i到j的子数组，首先随机选取一个元素作为主元pivot，将其与末尾元素交换位置（就是把pivot放最后）。这一步在调用partition之前就完成了。
• j指针用于向后遍历，寻找小于pivot的元素。如果找到了，那么i=i+1（即i右移），并交换nums[i] 和 nums[j]，这样就能保持i及i左侧的元素都<=pivot。
• 当j遍历到r-1位置时，遍历停止。此时i+1元素是第一个>pivot的元素，将其与pivot（r）交换，得到的子数组符合pivot左侧的元素都不大于pivot，而pivot右侧的元素都大于pivot。
• 返回pivot的下标

随机选取主元：

        在主函数中初始化srand((unsigned)time(NULL)); 随后在选主元时设随机下标i = rand() %(r-l+1)+l. 

这一步可以不单独拿出来，也可以直接不写，而直接选取子数组中第一个元素作为枢轴元素。

复杂度分析：

时间复杂度：基于随机选取主元的快速排序时间复杂度为期望 O(nlogn)，其中 n 为数组的长度。最坏情况为数组有序，时间复杂度为O(n^2)

空间复杂度：O(h)，其中 h 为快速排序递归调用的层数。我们需要额外的 O(h) 的递归调用的栈空间，由于划分的结果不同导致了快速排序递归调用的层数也会不同，最坏情况下需 O(n) 的空间，最优情况下每次都平衡，此时整个递归树高度为 logn，空间复杂度为 O(logn)。

class Solution {
private:
    //划分函数
    int partition(vector<int>& nums, int l, int r) {
        int i = l - 1, j = l; //左右指针
        int pivot = nums[r]; //主元
        //j指针遍历
        for( ; j <= r - 1; j++) {
            //寻找<=pivot的元素
            if(nums[j] <= pivot) {
                ++i;
                swap(nums[i], nums[j]); //将 寻找到的<=pivot的元素 与 目前>pivot的元素中最左侧的一个 交换
            }
        }
        swap(nums[i + 1], nums[r]); //将pivot放在应该在的位置：目前>pivot的元素中最左侧的一个
        return i + 1; //返回pivot的下标
    }
    //随机选取主元
    int randomPartition(vector<int>& nums, int l, int r) {
        int i = rand() % (r - l + 1) + l; //随机选取主元
        swap(nums[i], nums[r]); //把主元放最后
        return partition(nums, l, r); //进行划分，并返回主元的下标
    }

    //递归调用快速排序
    void quickSort(vector<int>& nums, int l, int r) {
        if(l < r) {
            int pivotIdx = randomPartition(nums, l, r);
            quickSort(nums, l, pivotIdx - 1);
            quickSort(nums, pivotIdx + 1, r);
        }
    }

public:
    vector<int> sortArray(vector<int>& nums) {
        // srand((unsigned)time(NULL)); //随机数初始化
        quickSort(nums, 0, nums.size()-1);
        return nums;
    }
};

快速选择

215. 数组中的第K个最大元素 - 力扣（LeetCode） (leetcode-cn.com)

class Solution {
public:
    //快速选择主函数
    int findKthLargest(vector<int>& nums, int k) {
        int left = 0, right = nums.size()-1;
        int targetIdx = nums.size() - k;
        while(left < right) {
            int pivotIdx = quickSelect(nums, left, right);
            if(pivotIdx == targetIdx) return nums[pivotIdx];
            else if(pivotIdx < targetIdx) {
                left = pivotIdx + 1;
            } else {
                right = pivotIdx - 1;
            }
        }
        return nums[left];
    }
    //划分函数
    int quickSelect(vector<int>& nums, int left, int right) {
        //随机选取枢轴元素
        int pivotIdx = rand() % (right - left + 1) + left;
        int pivot = nums[pivotIdx];
        //数轴元素与最后一个元素交换位置
        swap(nums[pivotIdx], nums[right]);
        
        //i的左侧都是<=pivot的数字；j用于把<=pivot的元素交换位置
        int i = left - 1, j = left;
        //遍历
        for( ; j <= right - 1; j++) {
            if(nums[j] <= pivot) {
                ++i;
                swap(nums[i], nums[j]);
            }
        }
        //枢轴元素回归原位
        swap(nums[i+1], nums[right]);
        return i + 1;
    }
};

堆排序

原理：将待排序元素建成大根堆，这样堆顶的元素就是最大元素，取堆顶元素与末尾元素交换，随后调整大顶堆，不断重复这一过程，就能得到一个降序序列。

步骤：

1. 建堆：从len/2的位置开始不断进行调整（取最大值放在堆顶）
2. 不断从堆顶取最大值放在当前长度下的数组末尾位置，缩小数组长度，并调整大顶堆

复杂度：

1. 时间复杂度：最好、平均、最差 都为O(n logn)

2. 空间复杂度：O(1)

class Solution {
private:
    //调整大顶堆：将最大值放在堆顶，对应数组的nums[0]
    void maxHeapify(vector<int>& nums, int i, int len) {
        //i为当前结点下标，i*2+1为其左孩子
        for( ; (i << 1) + 1 <= len; ) {
            int leftChild = (i << 1) + 1; //堆中左孩子在序列中的下标
            int rightChild = (i << 1) + 2;//右孩子
            int large; //暂存较大值

            //将当前结点分别与左右孩子比较：

            //用large存储，当前结点和左孩子两者中较大者的下标
            if(leftChild <= len && nums[leftChild] > nums[i])
                large = leftChild;
            else
                large = i;
            //两者中的较大者与右孩子比较
            if(rightChild <= len && nums[rightChild] > nums[large])
                large = rightChild;
            //如果有比当前结点更大的点，那就将其放在当前结点的位置
            if(large != i) {
                swap(nums[large], nums[i]);
                i = large;
            } else
                break;
        }
    }

    //构建大顶堆
    void buildMaxHeap(vector<int>& nums, int len) {
        //对于一个堆，从len/2开始向前遍历
        for(int i = len / 2; i >= 0; i--) {
            maxHeapify(nums, i, len);
        }
    }

    //堆排序
    void heapSort(vector<int>& nums) {
        int len = nums.size() - 1; //不是要统计长度，而是数组中末尾元素的下标
        buildMaxHeap(nums, len);
        //开始逐步取最大值放在当前长度下的末尾位置
        for(int i = len; i >= 1; i--) {
            swap(nums[i], nums[0]);
            --len;
            maxHeapify(nums, 0, len); //调整大顶堆，重新获取最大值放在堆顶
        }
    }

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