leetcode-215-Kth Largest Element in an Array

问题

题目：[Kth Largest Element in an Array]

思路

这个是我写的第一个版本，主要是利用partition算法。
我觉得它也是最快的，因为你要找的只是第K大，不是topK。
只是定位这一个元素，所以我采用了类似遮半查找非递归的写法实现。

代码

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        int n = nums.size();
        if(k > n) return -1;

        int low = 0;
        int high = n-1;
        int pivot = -1;

        while(low <= high){
            pivot = partition(nums, low, high);
            if(pivot == n-k) break;
            else if(pivot < n-k) low = pivot + 1;
            else high = pivot-1;
        }

        return nums[pivot];
    }
private:
    int partition(vector<int>& arr, int low, int high){
        int i = low;
        int j = high;
        while(i < j){
            while(i < j && arr[i] < arr[j]) --j;
            if(i<j){ swap(arr[i], arr[j]);++i; }
            while( i < j && arr[i] < arr[j] ) ++i;
            if(i<j){ swap(arr[i], arr[j]);--j; }
        }
        return i;
    }
    void swap(int& a, int& b){
        int t = a;
        a = b;
        b = t;
    }
};

思路

topK的办法

代码

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        int n = nums.size();
        if(k>n) return -1;
        for( int i = n/2-1; i >= 0; --i ){
            max_sift( nums, i, n-1 );
        }
        for(int i = 0; i < k; ++i){
            swap( nums[0], nums[n-1-i] );
            max_sift( nums, 0, n-2-i );
        }
        return nums[n-k];
    }
private:
    void max_sift(vector<int>& arr, int i, int m){
        int j = 2*i + 1;
        while(j <= m){
            if(j+1 <= m && arr[j] < arr[j+1]) ++j;
            if( arr[i] > arr[j] ) break;
            else{
                swap(arr[i], arr[j]);
                i = j; j = 2*i + 1;
            }
        }
        return;
    }
private:
    void swap(int& a, int& b){
        int t = a;
        a = b;
        b = t;
    }
};

思路

还是partition的思路

代码

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        int low = 0;
        int high = nums.size() - 1;
        int n = nums.size();

        while(1){
            int pivot = partition(nums, low, high);
            if( pivot == n-k ) return nums[pivot];
            else if( pivot < n-k ) low = pivot + 1;
            else high = pivot - 1;
        }
        return -1;
    }
private:
    void swap( int& a, int& b ){ int t = a; a = b; b = t; }
    int partition( vector<int>& arr, int low, int high){
        int i = low;
        int j = high;
        while( i < j ){
            while( i < j && arr[i] < arr[j] ) --j;
            if( i < j ){
                swap( arr[i], arr[j] );
                ++i;
            }
            while( i < j && arr[i] < arr[j] ) ++i;
            if( i < j ){
                swap( arr[i], arr[j] );
                --j;
            }
        }
        return i;
    }
};

时间复杂度

这个题目最精妙的讨论是在时间复杂度上面。
先说partition算法，每次进行partition的时间复杂度是o(n)。
回想你写的代码，是不是两根指针相遇才结束，那不就是o(n)。
这个题我要知道partition的问题在哪里？partition的问题在于每次划分可能不平均。最好的情况是两分。因为假设不平均，那么partition的时间复杂度取决与区间的长度，划分不平均，自然要长一点。所以，问题在这里。

那么，假设最好的情况。
第一次划分，平均划分，t(n) = n. 平均意味着下次partition的区间长度为n/2;
第二次划分，平均划分，t(n) = n/2。时间消耗在partition上面。
假设找了K次找到了，是按复杂度$t(n) = \frac{n}{2^{k-1}}$

所以，总的时间函数为$T(n) = \frac{n}{2^{0}} + \frac{n}{2^{1}} + ...\frac{n}{2^{k-1}}$

因为，无论如何 k < n，那么对上面的等式放缩，有：
$T(n) < \frac{n}{2^{0}} + \frac{n}{2^{1}} + ...\frac{n}{2^{k-1}} + ... + \frac{n}{2^{n-1}}$

对右面取极限有，T(n) = O(n).