获取一个数组里面第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)。