本次選擇的題目是

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;
        }
    }
};