【算法训练-数组三】数组中的第K个最大元素（TOPK问题|寻找第K大）

废话不多说，喊一句号子鼓励自己：程序员永不失业，程序员走向架构！本篇Blog的主题是【寻找第K大】，使用【数组】这个基本的数据结构来实现，这个高频题的站点是：CodeTop，筛选条件为：目标公司+最近一年+出现频率排序，由高到低的去牛客TOP101去找，只有两个地方都出现过才做这道题（CodeTop本身汇聚了LeetCode的来源），确保刷的题都是高频要面试考的题。
在这里插入图片描述

名曲目标题后，附上题目链接，后期可以依据解题思路反复快速练习，题目按照题干的基本数据结构分类，且每个分类的第一篇必定是对基础数据结构的介绍。

数组中的第K个最大元素【MID】

一道中等难度使用快排可以解决的题

题干

在这里插入图片描述

输入：
[1,3,5,2,2],5,3

返回值：
2

输入：
[10,10,9,9,8,7,5,6,4,3,4,2],12,3

返回值：
9

说明：
去重后的第3大是8，但本题要求包含重复的元素，不用去重，所以输出9

解题思路

使用快速排序的思路来解决，快速排序（Quick Sort）是一种基于分治思想的排序算法，它通过将数组分成较小和较大的两部分，并分别对这两部分进行排序，最终将整个数组排序。快速排序是一种高效的排序算法，通常在平均情况下具有较快的执行速度。

下面是快速排序的基本思想和步骤：

[划分]选择基准元素（Pivot）： 从数组中选择一个元素作为基准元素。
[划分]划分（Partition）： 将数组分成两部分，使得基准元素左边的元素都小于等于基准元素，右边的元素都大于基准元素。这一步骤通常称为“划分”。
[解决]递归排序： 递归地对基准元素左边和右边的子数组进行排序。也就是说，对小于基准元素的子数组和大于基准元素的子数组分别执行快速排序。
[合并] 合并： 由于子数组都是在原数组中进行排序，所以最终整个数组也就被排序了。

这些步骤使得较大问题被分解成较小的子问题，这些子问题又能通过递归地应用快速排序来解决。在最好情况下，每次划分都能将数组均匀分成两半，这使得算法的时间复杂度为O(n log n)。

然而，需要注意的是，快速排序的性能高度依赖于基准元素的选择。最坏情况下，如果每次划分都使数组分成极不平衡的两部分，算法的时间复杂度可能会退化到O(n^2)。为了应对这种情况，通常可以选择合适的基准元素，如随机选择或者采用三数取中等方法。

总之，快速排序是一种常用且高效的排序算法，尤其适用于大规模数据的排序。

代码实现

给出代码实现基本档案

基本数据结构：数组
辅助数据结构：无
算法：快速排序（分治算法）、二分查找
技巧：双指针

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param a int整型一维数组
     * @param n int整型
     * @param K int整型
     * @return int整型
     */
    public int findKth (int[] a, int n, int K) {
        return quikSort(a, 0, n - 1, K);
    }

    public int quikSort(int[] a, int start, int end, int K) {
        // 找到基准元素的位置，这个位置是第 pivot+1(因为数组下标从0开始) 大的元素
        int pivot = partion(a, start, end);
        if (K == pivot + 1 ) {
            // 正好命中
            return a[pivot]  ;
        } else if (K < pivot + 1) {
            // K小于基准位置，说明它是更大的数，在基准位置左边搜索
            return quikSort(a, start, pivot - 1, K);
        } else {
            // K大于基准位置，说明它是更小的数，在基准位置右边搜索，
            return quikSort(a, pivot + 1, end, K );
        }

    }

    // 获取一个基准元素，倒排，所以大于基准元素的数在左，小于基准元素的数在右
    private int partion(int[] a, int start, int end) {
        int pivotValue = a[start];
        int i = start, j = end;
        while (i != j) {
            // (a[j]只有大于基准元素才停止，因为大的放基准元素左边
            while (a[j] <= pivotValue && i < j) {
                // 一定要j先走，因为j先走ij就会在j的位置交汇，而基准元素的左边一定要比自己大，所以为了保证后续基准元素交换正确，一定要保证交汇位置元素值大于等于基准元素，所以要优先满足j的条件（即找到大于基准元素的值并停下），如果i先走，在靠近交互点时，i会越过大于基准元素的值与j交汇。
                j--;
            }

            // (a[i]只有小于基准元素才停止，因为大的放基准元素左边
            while (a[i] >= pivotValue && i < j) {
                i++;
            }

            if (i < j) {
                swap(a, i, j);
            }
        }

        // 全部交换完后，基准元素交换
        swap(a, start, j);
        return j;
    }

    // 辅助函数，交换数组元素
    private void swap(int[] a, int i, int j) {
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

复杂度分析

快速排序的时间复杂度和空间复杂度如下：

时间复杂度：

平均情况： 在平均情况下，快速排序的时间复杂度为O(n log n)，其中n是待排序数组的长度。这是因为每次划分都能将数组大致均匀地分成两部分，导致递归的深度大约为log n，而每次划分的过程需要O(n)的时间。
最坏情况： 在最坏情况下，如果每次划分都导致一个极不平衡的分割（例如每次选取的基准元素都是当前子数组的最大或最小元素），那么快速排序的时间复杂度可能退化到O(n^2)。这是因为需要执行n次划分，每次划分都需要O(n)的时间。为了避免最坏情况，通常采用随机选择基准元素或者三数取中法来减少极端情况的发生。
最好情况： 快速排序的最好情况时间复杂度为O(n log n)，与平均情况相同。这种情况发生在每次划分都能将数组准确地分成相等的两部分时。

空间复杂度：

快速排序的空间复杂度主要取决于递归调用的深度和每次划分所使用的额外空间。