class Finder {

 public:

     int findKth(vector<int> a, int n, int K) {

         // write code here

         sort(a.begin(), a.end());

         return a[n - K];

     }

 };

 #include <iostream>

 #include <vector>

 #include <string>

 #include <queue>

 #include <stack>

 #include <unordered_map>

 #include <map>

 #include <algorithm>

 using namespace std;

 //用快排的思想：例如找49个元素里面第24大的元素，那么按如下步骤：

 //1.进行一次快排（将大的元素放在前半段，小的元素放在后半段）, 假设得到的中轴为p

 //2.判断 p - low == k -1，如果成立，直接输出a[p]，（因为前半段有k - 1个大于a[p]的元素，故a[p]为第K大的元素）

 //3.如果 p - low > k-1， 则第k大的元素在前半段，此时更新high = p - 1，继续进行步骤1

 //4.如果 p - low < k-1， 则第k大的元素在后半段，此时更新low = p + 1, 且 k = k - (p - low + 1)，继续步骤1.

 //由于常规快排要得到整体有序的数组，而此方法每次可以去掉“一半”的元素，故实际的复杂度不是o(nlgn), 而是o(n)。

 class Finder {

 public:

     int partation(vector<int>& a, int low, int high) {

         int key = a[low];

         while (low < high) {

             while (low < high && a[high] <= key)

                 high--;

             a[low] = a[high];

             while (low < high && a[low] >= key)

                 low++;

             a[high] = a[low];

         }

         a[low] = key;

         return low;

     }

     int findKth(vector<int>& a, int low, int high, int k)

     {

         int part = partation(a, low, high);

         if (k == part - low + )

             return a[part];

         else if (k > part - low + )

             return findKth(a, part + , high, k - part + low - );

         else

             return findKth(a, low, part - , k);

     }

     int findKth(vector<int> a, int n, int K) {

         // write code here

         return findKth(a, , n - , K);

     }

 };

 //测试

 int main()

 {

     vector<int> v{ ,,,, };

     Finder solution;

     cout<<solution.findKth(v, , );

 }