215. Kth Largest Element in an Array

一 题目

Find the kth largest element in an unsorted array. Note that it is the kth largest element in the sorted order, not the kth distinct element.

Example 1:

Input: [3,2,1,5,6,4] and k = 2
Output: 5

Example 2:

Input: [3,2,3,1,2,4,5,5,6] and k = 4
Output: 4

Note: 
You may assume k is always valid, 1 ≤ k ≤ array's length.

二 分析

经典topk 问题

2.1 先用数组排序的方式。o(nlogn)

public static int findKthLargest(int[] nums, int k) {
		if(nums== null || k> nums.length ){
			return 0;
		}		
		//先排序
		Arrays.sort(nums);		
		return nums[nums.length-k];        
    }

Runtime: 2 ms, faster than 89.06% of Java online submissions for Kth Largest Element in an Array.

Memory Usage: 37.4 MB, less than 90.16% of Java online submissions for Kth Largest Element in an Array.

2.2 把数组换成Java的优先级队列（最小堆）

class Solution {
    public int findKthLargest(int[] nums, int k) {
        if(nums== null || k> nums.length ){
			return 0;
		}
		Queue<Integer> queue = new PriorityQueue<Integer>();
		for(int num:nums){
			queue.offer(num);
		}
		for(int i=0;i<=nums.length;i++){
			int max = queue.poll();
			if(i==nums.length-k){
				return max;
			}
		}
		return 0;
    }
}

Runtime: 8 ms, faster than 47.26% of Java online submissions for Kth Largest Element in an Array.

Memory Usage: 36.7 MB, less than 90.67% of Java online submissions forKth Largest Element in an Array.

可见这个比数组还慢。

2.3 尝试用排序法；

快速排序的主要步骤

(1)选择基准：在待排序列中，按照某种方式挑出一个元素，作为 "基准"（pivot）

(2)分割操作：以该基准在序列中的实际位置，把序列分成两个子序列。此时，在基准左边的元素都比该基准小，在基准右边的元素都比基准大

(3)递归地对两个序列进行快速排序，直到序列为空或者只有一个元素
 

从小到大排序之后，第K大变成数组里面的n.length-k的位置。

我们首先对数组进行一次Partition,得到坐标index:

如果index== k,返回array[index];

如果index > k,对数组左半部分继续进行Partition;

如果index < k, 对数组右半部分继续进行Partition.

　　算法核心是partition方法，即把元素分开两组的方法，每次把元素平均分到两边时，算法效率最高。相反，如果每次partition把元素完全分到一边，是最差情况，算法退化为O(n2)。这里采用的是j交换法：把比pivot大的元素“往下沉”，把比pivot小的元素“往上浮”。

    我们首先选定基准元素Pivot，并且设置两个指针i和j，指向数列的最左元素：

这里先尝试用左侧第一个元素为基准元素pivot。先跟最高位high进行交换。

从j=0开始，把指针所指向的元素和基准元素做比较，如果大于基准元素则j继续向右移动，否则i,j进行交互，且把i指针进行向右移动1位。当i,j指针重合后，则吧最高位与i位进行交换。此时i左侧全部小于基准，右侧全部大于基准。对应i就是排序后基准位置。

class Solution {
    public int findKthLargest(int[] nums, int k) {
        if(nums== null || k> nums.length ){
			return 0;
		}
        if(nums.length==1){
            return nums[0];
        }
	int l=0;
		int r= nums.length-1;
		k = nums.length-k;
		while(true){
			int index = partition(nums,l,r);
			if( index<k){
				l = index+1;
			}else if(index>k){
				r = index -1;
			}else{
				return nums[index];
			}
		}
		
	}
	 private int partition(int[] nums, int low, int high){
        int pivolt = nums[low];
		 swap(nums,low,high);
		 int i= low;
		for(int j=low;j< high;j++){
			if(nums[j]<=pivolt){
				swap(nums,i,j);				
				i++;
			}
		}
		 swap(nums,i,high);//交换到正确的位置
        return i;
    }

	private void swap(int[] nums ,int a,int b){
	        int tmp = nums[a];
	        nums[a] = nums[b];
	        nums[b] = tmp;
	    }
}

Runtime: 36 ms, faster than 21.06% of Java online submissions for Kth Largest Element in an Array.

Memory Usage: 36.7 MB, less than 90.67% of Java online submissions forKth Largest Element in an Array.

 

为了方便理解：以[21, 34, 74, 3, 20, 2, 56, 46, 6] 为例，k=2，输出排序后结果

0 in:[6,34,74,3,20,2,56,46,21]
1 in:[6,3,74,34,20,2,56,46,21]
2 in:[6,3,20,34,74,2,56,46,21]
3 in:[6,3,20,2,74,34,56,46,21]
4out:[6,3,20,2,21,34,56,46,74]
5out:[6,3,20,2,21,34,56,46,74]
6 in:[6,3,20,2,21,34,46,74,56]
7out:[6,3,20,2,21,34,46,56,74]

网上后来又陆续看了几篇，关于这块原理性介绍的不多。

快速排序也是分治算法，当每次划分时，算法若都能分成两个等长的子序列时，那么分治算法效率会达到最大。也就是说，基准的选择是很重要的。选择基准的方式决定了两个分割后两个子序列的长度，进而对整个算法的效率产生决定性影响

常见的基准的选择有几种：最左侧，最右侧，随机选择、中间元素。

我自己没有用大量数据验证，缺乏理论支持，只从LeetCode的测试效果来看，换成中间元素为基准。

//找基准
	 private static int partition(int[] nums, int low, int high) {
		 int pivot = nums[(low+high)/2];
		 swap(nums,(low+high)/2,high);
		 int i= low;
		for(int j=low;j< high;j++){
			if(nums[j]<=pivot){
				swap(nums,i,j);
				 System.out.println(i+" in:"+JSON.toJSON(nums));
				i++;
			}
		}
		 swap(nums,i,high);//交换到正确的位置
		 System.out.println(i+"out:"+JSON.toJSON(nums));
		return i;
	}

效果明显：

Runtime: 1 ms, faster than 99.52% of Java online submissions for Kth Largest Element in an Array.

Memory Usage: 36.5 MB, less than 90.67% of Java online submissions forKth Largest Element in an Array.

期待大神给出深入的解释。

关于快速排序，我忘了怎么写了，调起来很费劲，自己太笨了。

深入优化可参考这篇：https://blog.csdn.net/insistGoGo/article/details/7785038