leecode 解题总结：215. Kth Largest Element in an Array

#include <iostream>
#include <stdio.h>
#include <vector>
#include <string>
using namespace std;
/*
问题:
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.

分析:返回第k大的数字。可以用快速排序的随机划分来做。时间复杂度为O(N)
还有一种线性时间选择，采用中位数的中位数，算法比较复杂。时间复杂度为O(1)
如果是求前k个最大的数字，就用大顶堆来做。时间复杂度O(N*logN)

第K大的数字，说明前面。
随机划分每次将一个枢轴，放到指定位置。
划分的左边个数为p, p > K ,则还在左边，继续划分
划分的左边个数为p, p < K,说明在右边，
  如果p+1=K,返回数轴本身
  否则，在右边寻找K=K-p-1(数轴本身占据一个元素)

输入:
6 2
3 2 1 5 6 4
2 1
99 99
输出:
5

关键:
1 			
while(low < high && nums.at(high) < value)
{
	high--;
}
nums.at(low) = nums.at(high);//将后面较大的数放到前面
2
		//如果左边部分(包含数轴本身)的个数 > k，说明在左边
		int leftSize = pivot - low + 1;
		if(leftSize > k )
		{
			//这里数轴肯定不可能，所以下标减少
			return dfs(nums, low , pivot - 1 , k);
		}
*/

class Solution {
public:
	void swap(int* num1 ,int* num2)
	{
		int temp = *num1;
		*num1 = *num2;
		*num2 = temp;
	}

	int randRange(int min , int max)
	{
		if(min > max)
		{
			swap(&min , &max);
		}
		return ( rand() % (max - min + 1) + min );
	}

	int partition(vector<int>& nums , int low , int high)
	{
		int pivot = randRange(low , high);
		//随机选择一个数轴，并与low交换
		swap(&nums.at(pivot) , &nums.at(low));
		int value = nums.at(low);
		//交换之后，接下来，开始进行选择数轴
		//我要让左边是最大的数，右边是较小的数
		while(low < high)
		{
			while(low < high && nums.at(high) < value)
			{
				high--;
			}
			nums.at(low) = nums.at(high);//将后面较大的数放到前面
			//左边是>=数轴的元素
			while(low < high && nums.at(low) >= value)
			{
				low++;
			}
			nums.at(high) = nums.at(low);
		}
		//最后一步忘记设置枢轴
		nums.at(low) = value;
		return low;
	}

	int dfs(vector<int>& nums, int low , int high, int k)
	{
		//递归出口
		if(low > high || k < 0)
		{
			return 0 ;
		}
		int pivot = partition(nums , low , high);
		//如果左边部分(包含数轴本身)的个数 > k，说明在左边
		int leftSize = pivot - low + 1;
		if(leftSize > k )
		{
			//这里数轴肯定不可能，所以下标减少
			return dfs(nums, low , pivot - 1 , k);
		}
		//左边部分个数 <= k
		else
		{
			//当前元素就是数轴
			if(leftSize == k)
			{
				return nums.at(pivot);
			}
			//继续在右边寻找，需要减掉 leftSize + 1
			else
			{
				k -= leftSize;
				return dfs(nums , pivot + 1 , high , k);
			}
		}
	}

	//寻找第K个最大的数
    int findKthLargest(vector<int>& nums, int k) {
        if(nums.empty())
		{
			return 0;
		}
		int size = nums.size();
		if(k > size || k < 1)
		{
			return 0;
		}
		int result = dfs(nums , 0 , size - 1 , k);
		return result;
    }
};

void print(vector<int>& result)
{
	if(result.empty())
	{
		cout << "no result" << endl;
		return;
	}
	int size = result.size();
	for(int i = 0 ; i < size ; i++)
	{
		cout << result.at(i) << " " ;
	}
	cout << endl;
}

void process()
{
	 vector<int> nums;
	 int value;
	 int num;
	 Solution solution;
	 vector<int> result;
	 int k;
	 while(cin >> num >> k )
	 {
		 nums.clear();
		 for(int i = 0 ; i < num ; i++)
		 {
			 cin >> value;
			 nums.push_back(value);
		 }
		 int answer = solution.findKthLargest(nums , k);
		 cout << answer << endl;
	 }
}

int main(int argc , char* argv[])
{
	process();
	getchar();
	return 0;
}