牛客题解 | 寻找第K大

原创已于 2025-03-04 09:59:15 修改 · 691 阅读

28 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #力扣 #面试 #算法力扣

于 2025-03-04 09:58:44 首次发布

牛客面试必刷101题单题解专栏收录该内容

103 篇文章

订阅专栏

题目## 题目

题目链接

题目主要信息：

利用快速排序的思想寻找数组中的第k大元素
有重复数字，不用去重，也不用管稳定性与否

举一反三：

学习完本题的思路你可以解决快速排序或者分治类的问题：

BM5. 合并k个有序链表

BM20. 数组中的逆序对

方法：快排+二分查找（推荐使用）

知识点：分治

分治即“分而治之”，“分”指的是将一个大而复杂的问题划分成多个性质相同但是规模更小的子问题，子问题继续按照这样划分，直到问题可以被轻易解决；“治”指的是将子问题单独进行处理。经过分治后的子问题，需要将解进行合并才能得到原问题的解，因此整个分治过程经常用递归来实现。

思路：

本题需要使用快速排序的思想，快速排序：每次移动，可以找到一个标杆元素，然后将大于它的移到左边，小于它的移到右边，由此整个数组划分成为两部分，然后分别对左边和右边使用同样的方法进行排序，不断划分左右子段，直到整个数组有序。这也是分治的思想，将数组分化成为子段，分而治之。

放到这道题中，如果标杆元素左边刚好有 $k - 1$ 个比它大的，那么该元素就是第 $k$ 大：

//若从0开始，刚好是第K个点，则找到
if(K == j + 1)  
    return a[p];

如果它左边的元素比 $k - 1$ 少，说明第 $k$ 大在其右边，直接二分法进入右边，不用管标杆元素左边:

if(j + 1 < k)
    return partition(a, j + 1, high, k);

同理如果它右边的元素比 $k - 1$ 少，那第 $k$ 大在其左边，右边不用管。

return partition(a, low, j - 1, k);

具体做法：

step 1：进行一次快排，大元素在左，小元素在右，得到的标杆j点.在此之前要使用随机数获取标杆元素，防止数据分布导致每次划分不能均衡。
step 2：如果 j + 1 = k ，那么j点就是第K大。
step 3：如果 j + 1 > k，则第k大的元素在左半段，更新high = j - 1，执行step 1。
step 4：如果 j + 1 < k，则第k大的元素在右半段，更新low = j + 1, 再执行step 1.

图示：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Java实现代码：

import java.util.*;
public class Solution {
    //交换函数
    Random r = new Random();
    public static void swap(int arr[], int a, int b) {
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}
    public int partition(int[] a, int low, int high, int k){
        //随机快排划分
        int x = Math.abs(r.nextInt()) % (high - low + 1) + low;
        swap(a, low, x);
        int v = a[low];
        int i = low + 1;
        int j = high;
        while(true){
            //小于标杆的在右
            while(j >= low + 1 && a[j] < v) 
                j--;
            //大于标杆的在左
            while(i <= high && a[i] > v) 
                i++;
            if(i > j) 
                break;
            swap(a, i, j);
            i++;
            j--;
        }
        swap(a, low, j);
        //从0开始，所以为第j+1大
        if(j + 1 == k)
            return a[j];
        //继续划分
        else if(j + 1 < k)
            return partition(a, j + 1, high, k);
        else
            return partition(a, low, j - 1, k);
    }
    public int findKth(int[] a, int n, int K) {
        return partition(a, 0, n - 1, K);
    }
}

C++实现代码：

class Solution {
public:
    int partition(vector<int>& a, int low, int high, int k){
        //随机快排划分
        swap(a[low], a[rand() % (high - low + 1) + low]);
        int v = a[low];
        int i = low + 1;
        int j = high;
        while(true){
            //小于标杆的在右
            while(j >= low + 1 && a[j] < v) 
                j--;
            //大于标杆的在左
            while(i <= high && a[i] > v) 
                i++;
            if(i > j) 
                break;
            swap(a[i], a[j]);
            i++;
            j--;
        }
        swap(a[low], a[j]);
        //从0开始，所以为第j+1大
        if(j + 1 == k)
            return a[j];
        //继续划分
        else if(j + 1 < k)
            return partition(a, j + 1, high, k);
        else
            return partition(a, low, j - 1, k);
    }
    int findKth(vector<int> a, int n, int K) {
        return partition(a, 0, n - 1, K);
    }
};

Python代码实现：

import random
class Solution:
    def partition(self, a: List[int], low: int, high: int, k: int) -> int:
        #随机快排划分
        x = random.randint(0, 10000)
        a[low], a[x % (high - low + 1) + low] = a[x % (high - low + 1) + low], a[low]
        v = a[low]
        i = low + 1
        j = high
        while True:
            #小于标杆的在右
            while j >= low + 1 and a[j] < v:
                j -= 1
            #大于标杆的在左
            while i <= high and a[i] > v:
                i += 1
            if i > j:
                break
            a[i], a[j] = a[j], a[i]
            i += 1
            j -= 1
        a[low], a[j] = a[j], a[low]
        #从0开始，所以为第j+1大
        if j + 1 == k:
            return a[j]
        #继续划分
        elif j + 1 < k:
            return self.partition(a, j + 1, high, k)
        else:
            return self.partition(a, low, j - 1, k)
    def findKth(self , a: List[int], n: int, K: int) -> int:
        return self.partition(a, 0, n - 1, K)

复杂度分析：

时间复杂度： $O (n)$ ，利用二分法缩短了时间—— $T (2/ N) + T (N /4) + T (N /8) + \dots\dots = T (N)$
空间复杂度： $O (n)$ ，递归栈最大深度

题目链接

题目主要信息:

给定一个长度为n的数组，返回其中任何一个峰值的索引
峰值元素是指其值严格大于左右相邻值的元素
数组两个边界可以看成是最小， $-\infty$
峰值不存在平的情况，即相邻元素不会相等

举一反三：

学习完本题的思路你可以解决如下题目：

BM17.二分查找-I

BM18.二维数组中的查找

BM21.旋转数组

方法：二分查找（推荐使用）