[leetcode]解决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.

For example, Given [3,2,1,5,6,4] and k = 2, return 5.

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

1.按照书本的方法，可以由递归完成：

class Solution {
public:
    int findKthLargest(vector<int>& List, int k){
        return FindKth(List, k, 0, List.size() - 1);
    }
    int FindKth(vector<int>& List, int k, int left, int right)   {
        /*利用递归求第K大的函数*/   
        /*第一个数字为分隔量*/
        int e=List[left];  
        int L,R;  
        L=left;  
        R=right;  
        while(1){  
            /*在一个数组中将以基础变量，将数组分成两个部分,大的部分在左边，小的部分在右边*/   
            while((List[left]>=e)&&(left<=right)){   
            left++;  
            }  
            while((List[right]<=e)&&(left<right)){   
            right--;  
            }    
            if (left<right){
                swap(List[left], List[right]);
            }  
            else break;  
        }  
        swap(List[L], List[left-1]);  

        if ((left-1-L)>=k)  
        /*去左边找第K大*/   
        return FindKth(List,k,L,left-2);  
        else if((left-1-L)<k-1)  
        /*去左边找第K大*/   
        return FindKth(List,k-left+L,left,R);   
        /*递归终止条件,仅剩一个元素时，就是这个数*/   
        else return e;  
    }
};

2.直接的方法，与递归有一些不同：
Quicksort

In quicksort, in each iteration, we need to select a pivot and then partition the array into three parts:

- Elements smaller than the pivot;
- Elements equal to the pivot;
- Elements larger than the pivot.

sum up:

1. Initialize left to be 0 and right to be nums.size() - 1;
2. Partition the array, if the pivot is at the k-1-th position, return
it (we are done);
3. If the pivot is right to the k-1-th position, update right to be the
left neighbor of the pivot;
4. Else update left to be the right neighbor of the pivot.
5. Repeat 2.

class Solution { 
public:
    int partition(vector<int>& nums, int left, int right) {
        int pivot = nums[left];
        int l = left + 1, r = right;
        while (l <= r) {
            if (nums[l] < pivot && nums[r] > pivot)
                swap(nums[l++], nums[r--]);
            if (nums[l] >= pivot) l++; 
            if (nums[r] <= pivot) r--;
        }
        swap(nums[left], nums[r]);
        return r;
    }

    int findKthLargest(vector<int>& nums, int k) {
        int left = 0, right = nums.size() - 1;
        while (true) {
            int pos = partition(nums, left, right);
            if (pos == k - 1) return nums[pos];
            if (pos > k - 1) right = pos - 1;
            else left = pos + 1;
        }
    }
};