获取一个数组里面第K大的元素

如何在O(n)内获取一个数组比如{9, 1, 2, 8, 7, 3, 6, 4, 3, 5, 0, 9, 19, 39, 25, 34, 17, 24, 23, 34, 20}里面第K大的元素呢？

我们可以使用类似快排的分区方式，将第K大的元素限定在数组的左边或右边，递归求取。

 

我的Java代码实现如下：

package com.structure.sort;

/**
 * @author zhangxingrui
 * @create 2019-01-27 22:52
 **/
public class QuickSort {

    public static void main(String[] args) {
        int[] numbers = {9, 1, 2, 8, 7, 3, 6, 4, 3, 5, 0, 9, 19, 39, 25, 34, 17, 24, 23, 34, 20};
//        int[] numbers = {3,1,2};
        // 快速排序借助递归来实现，重要的是要找到递归的终结条件（不然容易发生堆栈异常）
        // 递推公式：quickSort(p...r) = merge(p, q - 1) + merge(q+1, r)
        // 终结条件：p >= r
        /*quickSort(numbers, 0, numbers.length - 1);
        for (int number : numbers) {
            System.out.println(number);
        }*/

        int k = getK(4, numbers, 0, numbers.length - 1);
        System.out.println(k);
    }

    private static void quickSort(int[] numbers, int p, int r){
        if(p >= r)
            return;
        int q = partition(numbers, p, r, false);
        quickSort(numbers, p, q - 1);
        quickSort(numbers, q + 1, r);
    }

    /**
     * @Author: xingrui
     * @Description: 分区
     * @Date: 23:13 2019/1/27
     */
    private static int partition(int[] numbers, int p, int r, boolean isAsc){
        int k = numbers[r];
        int i = p;

        if(isAsc){
            for (int j = p; j <= r; ++j) {
                if(numbers[j] < k){
                    int temp = numbers[i];
                    numbers[i] = numbers[j];
                    numbers[j] = temp;
                    i++;
                }
            }
            numbers[r] = numbers[i];
            numbers[i] = k;
            return i;
        }else{
            for (int j = p; j <= r; ++j) {
                if(numbers[j] > k){
                    int temp = numbers[i];
                    numbers[i] = numbers[j];
                    numbers[j] = temp;
                    i++;
                }
            }
            numbers[r] = numbers[i];
            numbers[i] = k;
            return i;
        }

    }

    /**
     * @Author: xingrui
     * @Description: 获取第K大的元素
     * @Date: 23:15 2019/1/29
     */
    private static int getK(int k, int[] numbers, int p, int r){
        int q = partition(numbers, p, r, false);

        if(q + 1 == k)
            return numbers[q];

        if(q + 1 > k){
            return getK(k, numbers, p, q - 1);
        }else{
            return getK(k, numbers, q + 1, r);
        }
    }

}

原理就是我们先任取一个数作为分区的数，把大于它的数放在它的左边，小于它的数放在它的右边。

假设我们有数组array[p...r]，那么第一次分区之后就形成了array[p...q-1]，q，array[q+1...r]三个部分，如果我们要求取第3大的元素，

那么就将3与q+1做比较，

如果3==q+1，那么说明array[p...q-1]里面只有两个元素且都>array[q]，而array[q+1,r]都<q，所以array[q]

就是第三大的元素；

如果3 > q+1，说明array[p...q-1]里面的元素只有一个元素，所以我们需要到array[q+1...r]里面再去找；

如果3 < q+1，则说明array[p...q-1]里面有三个元素，所以我们还需要到array[p...q-1]里面去找。

 

这样的话，每次只会到分区的一半的数组里面去找：n/2 + n/4 + n/8 + 直到区间缩小为1，最终可得2n - 1，

所以这样做的时间复杂的就是O(n)。