题目：
在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

示例 1:

输入: [3,2,1,5,6,4] 和 k = 2
输出: 5

示例 2:

输入: [3,2,3,1,2,4,5,5,6] 和 k = 4
输出: 4

说明:

你可以假设 k 总是有效的，且 1 ≤ k ≤ 数组的长度。

万能的最小堆思路。

java代码实现：

 

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {

    	int n = nums.size();
    	if(k < 1 || n < k)
    		return INT_MIN;
        //用最小堆还是最大堆，主要是为了确保我们最终要得到的元素位于堆顶，可以直接取出，
        //这时可以看一看堆顶元素在堆中元素中是最大的，还是最小的
        //其实这个问题还可以使用最大堆，堆中的元素为最小的n-k+1个元素，则最大堆的堆顶元素即
        //为第n-k+1小元素(也就是第k大元素)，但是一般来说，k<<n,所以为了节约堆的空间大小，这里
        //我们使用最小堆
    	priority_queue<int,vector<int>,greater<int>> q;//最小堆
    	for(int i = 0;i < n;i++)
    	{
    		if(i < k)
    			q.push(nums[i]);
    		else
    		{
    			int temp = q.top();
    			if(nums[i] > temp)
    			{
    				q.pop();
    				q.push(nums[i]);
    			}
    		}
    	}
    	return q.top();        
    }
};

 

　　

 

利用快排的思想。

代码：

 

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {

    	int n = nums.size();
    	if(k < 1 || n < k)
    		return INT_MIN;
    	int start = 0;
	    int end = n - 1;
	    int index = partition(nums,start, end);
		//循环前循环用到的变量进行的变量初始值操作
	    while(index != k-1)
	    {
	        if(index > k-1)
	        {
	            end = index-1;
	            index = partition(nums,start, end);
	        }
	        else
	        {
	            start = index + 1;
	            index = partition(nums,start, end);
	        }
	    }
	    return nums[k-1];
    	     
    }
	int partition(vector<int>& a, int left, int right)
	{
	    int i = left;
	    int j = right;
	    int pivot = a[left];
	    while(i < j)                               
	    {   //注意：根据本题的题意，我们需要降序排序，所以这里需要修改为<=
	        while(i < j && a[j] <= pivot) 
	        {
	            j--;
	        } 
	        a[i] = a[j];
            //注意：根据本题的题意，我们需要降序排序，所以这里需要修改为>=
	        while(i < j && a[i] >= pivot)
	        {
	            i++;
	        }
	         
	        a[j] = a[i];
	    }    
	    a[i] = pivot;//根据算法的流程，跳出循环时i==j
	    return i;
	}
};

 

　　

快速排序：　　

//快速排序总的写法
void quick_sort(int a[], int left, int right)
{
    if(left >= right)
        return;
    int i = left;
    int j = right;
    int pivot = a[left];
    while(i < j)                               
    {
        while(i < j && a[j] >= pivot) 
        {
            j--;
        } 
        a[i] = a[j];
        while(i < j && a[i] <= pivot)
        {
            i++;
        }
         
        a[j] = a[i];
    }    
    a[i] = pivot;//根据算法的流程，跳出循环时i==j
    quick_sort(a, left, i - 1);
    quick_sort(a, i + 1, right);                      
}

//分离出主要的功能函数的写法
int partition(int a[], int left, int right)
{
    int i = left;
    int j = right;
    int pivot = a[left];
    while(i < j)                               
    {
        while(i < j && a[j] >= pivot) 
        {
            j--;
        } 
        a[i] = a[j];
        while(i < j && a[i] <= pivot)
        {
            i++;
        }
         
        a[j] = a[i];
    }    
    a[i] = pivot;//根据算法的流程，跳出循环时i==j
    return i;
}
void quick_sort(int a[], int left, int right)
{

    if(left >= right)
        return;
    int index = partition(a,left,right);
    quick_sort(a, left, index - 1);
    quick_sort(a, index + 1, right);                      
}