Lintcode: Kth Largest Element 解题报告

Kth Largest Element

Find K-th largest element in an array.

Note

You can swap elements in the array

Example

In array [9,3,2,4,8], the 3th largest element is 4

Challenge

O(n) time, O(1) space

原题链接：

http://www.lintcode.com/en/problem/kth-largest-element/

SOLUTION 1:

使用改进的Quicksort partition，可以达到O(n)的时间复杂度，并且不需要额外空间。

请参考： http://en.wikipedia.org/wiki/Quickselect#Time_complexity

 

时间复杂度：如果我们是这样的数组：1，2，3，4，5，然后又每一次取左边的当pivot，就会达到最坏的时间复杂度。也就是O(N2)

我们也有一些解决方法：

以下来自维基，我们可以取3个数进行平均。

http://stackoverflow.com/questions/7559608/median-of-three-values-strategy

The easiest solution is to choose a random pivot, which yields almost certain linear time. Deterministically, one can use median-of-3 pivot strategy (as in the quicksort), which yields linear performance on partially sorted data, as is common in the real world. However, contrived sequences can still cause worst-case complexity; David Musser describes a "median-of-3 killer" sequence that allows an attack against that strategy, which was one motivation for his introselect algorithm.

package Algorithms.algorithm.NChapter.findKthNumber;

import java.util.ArrayList;

// The link: 

// http://www.lintcode.com/en/problem/kth-largest-element/

class KthLargestElement_lintCode {
    //param k : description of k
    //param numbers : array of numbers
    //return: description of return
    public int kthLargestElement(int k, ArrayList<Integer> numbers) {
        // write your code here
        if (k < 1 || numbers == null) {
            return 0;
        }
        
        return getKth(numbers.size() - k + 1, numbers, 0, numbers.size() - 1);
    }
    
    public int getKth(int k, ArrayList<Integer> numbers, int start, int end) {
        // Choose the last one as the pivot
        int pivot = numbers.get(end);
        
        int left = start;
        int right = end;
        
        while (true) {
            while (numbers.get(left) < pivot && left < right) {
                left++;    
            }
            
            while (numbers.get(right) >= pivot && right > left) {
                right--;
            }
            
            if (left == right) {
                break;
            }
            
            swap(numbers, left, right);
        }
        
        // left: the first one which is bigger than pivot.
        swap(numbers, left, end);
        
        if (k == left + 1) {
            return pivot;
        // Try to find the element from the left side.
        } else if (k < left + 1) {
            return getKth(k, numbers, start, left - 1);
        } else {
        // Try to find the element from the right side.            
            return getKth(k, numbers, left + 1, end);
        }
    }
    
    /*
        Swap the two nodes.
    */
    public void swap(ArrayList<Integer> numbers, int n1, int n2) {
        int tmp = numbers.get(n1);
        numbers.set(n1, numbers.get(n2));
        numbers.set(n2, tmp);
    }
};

 

SOLUTION 2:

以下这些链接有详细的讨论，就不再一一叙述了。目前来讲Solution 1应该是最优的啦。

http://www.geeksforgeeks.org/k-largestor-smallest-elements-in-an-array/

http://www.quora.com/What-is-the-most-efficient-algorithm-to-find-the-kth-smallest-element-in-an-array-having-n-elements

 

GITHUB:

https://github.com/yuzhangcmu/LeetCode_algorithm/blob/master/algorithm/NChapter/findKthNumber/KthLargestElement_lintCode.java