LintCode 5: Kth Largest Element in an Array (经典题, LeetCode-215)

这题是经典题中的经典题。
解法主要有3个：

解法1： 用quickSort的思路，每次选一个pivot(可以去中间，也可以取两边)。然后把array分成3部分，左边[start, j]都小于等于pivot，右边[i, end]都大于等于pivot，中间的那个刚好就是pivot。
情况1：那我们把start+k-1与j相比，如果start+k-1<=j，那说明这个第k大的数混在左边部分。为什么这里不是start+k<=j呢? 我们看看极端情况，如果k=1，start=j这种情况我们也是要从左边找，那么start+k<=j就不对了，所以必须要k-1。
情况2：我们把start+k-1与i相比，如果start+k-1>=i，那说明这个第k大的数混在右边部分。这个时候我们把k减掉(i-start), 因为左边和中间那个不用管了。
情况3：如果情况1和情况2都不满足，我们就返回pivot，那就是nums[j+1]。

注意：

1. 除了最开始的比较是start==end之外，其他比较都是left和right比较。
2. 因为是求Kth largest element，所以元素要从大到小排列。所以两个内while循环是用的nums[left] > pivot和 nums[right] < pivot，与正常的quickSort相反。
3. 时间复杂度O(n)。
   代码如下：

class Solution {
public:
    /**
     * @param n: An integer
     * @param nums: An array
     * @return: the Kth largest element
     */
    int kthLargestElement(int n, vector<int> &nums) {
        int len = nums.size();
        if (len == 0 || len < n) return -1;
        
        return quickSelect(n, nums, 0, len - 1);
    }
    
private:
    int quickSelect(int n, vector<int> &nums, int start, int end) {
        if (start == end) return nums[start];
        
        int left = start, right = end;
        int pivot = nums[start + (end - start) / 2];
        
        while(left <= right) {
            while(left <= right && nums[left] > pivot) {
                left++;
            }
            while(left <= right && nums[right] < pivot) {
                right--;
            }
            
            if (left <= right) {
                swap(nums[left], nums[right]);
                left++;
                right--;
            }
        }
        
        if (start + n - 1 <= right) {
            quickSelect(n, nums, start, right);
        } else if (start + n - 1 >= left) {
            quickSelect(n - (left - start), nums, left, end);
        } else {
            return nums[right + 1];
        }
    }
};

二刷

class Solution {
public:
    /**
     * @param k: An integer
     * @param nums: An array
     * @return: the Kth largest element
     */
    int kthLargestElement(int k, vector<int> &nums) {
        int n = nums.size();
        return quickSelect(nums, 0, nums.size() - 1, n - k + 1); 

    }
private:
    int quickSelect(vector<int> &nums, int start, int end, int k) {
        if (start >= end) return nums[start];
        int pivot = nums[start + (end - start) / 2];
        int left = start, right = end;
        while (left <= right) {
            while (left <= right && nums[left] < pivot) left++;
            while (left <= right && nums[right] > pivot) right--;
            if (left <= right) {
                int tmp = nums[left];
                nums[left] = nums[right];
                nums[right] = tmp;
                left++;
                right--;
            }
        }
        if (right - start + 1 >= k) return quickSelect(nums, start, right, k);
        if (left - start < k) return quickSelect(nums, left, end, k - left + start);
        return nums[right + 1];
    }
};

解法2：最小堆。空间复杂度O(k)，时间复杂度O(nlogk)。

class Solution {
public:
    /**
     * @param n: An integer
     * @param nums: An array
     * @return: the Kth largest element
     */
    int kthLargestElement(int n, vector<int> &nums) {
        int len = nums.size();
        priority_queue<int, vector<int>, greater<int>> pq;

        for (int i = 0; i < len; ++i) {
            int number = nums[i];
            if (i < n) {
                pq.push(number);
            } else {
                if (number > pq.top()) {
                    pq.pop();
                    pq.push(number);
                }
            }
        }
        
        return pq.top();
    }
};

二刷：
下面这个不如上面的好。上面的算法，在i>n后，minHeap内已经有了k个元素，minHeap.top()就是前k个元素里第k大的元素，那么如果比minHeap.top()还小的话，肯定不会是全局第k大的元素(至少是第k+1大)，所以也就不用push进去了。下面的算法是不管三七二十一都push进去，然后把最小的一个pop出来(也就是比旧的minHeap.top()还小的pop()出来)。这里做了很多无用功。实际上，应该像上面的算法一样，第k个元素以后的新元素，如果比当前的minHeap.top()还小，也就没有必要push进去了。

class Solution {
public:
    /**
     * @param k: An integer
     * @param nums: An array
     * @return: the Kth largest element
     */
    int kthLargestElement(int k, vector<int> &nums) {
        priority_queue<int, vector<int>, greater<int>> minHeap;
        int len = nums.size();
        for (int i = 0; i < len; i++) {
            minHeap.push(nums[i]);
            if (minHeap.size() > k) {
                minHeap.pop();
            }
        }
        return minHeap.top();
    }
};

解法3：最大堆。这个空间复杂度是O(n)，时间复杂度O(nlogn)。其实这个还不如直接排序，时间复杂度是一样的，空间复杂度O(n) (因为递归，最坏情况)。

代码如下：

    int findKthLargest(vector<int> &nums, int k)
    {
        priority_queue<int> pq(nums.begin(), nums.end());
        for (int i = 0; i < k - 1; i++)
        {
            pq.pop();
        }
        return pq.top();
    }