输出数组第k大的元素

用快速排序的思想输出数组第k大的元素：

 #include<iostream>
 #include<algorithm>
 using namespace std;

 //递归实现:返回数组第k大的值.数组下标区间是[begin,end].其中数组假定n个元素，则k的值在区间[1,n].
 //能够使用这种方法的前提条件是：n个数不能重复。如果n个数中有重复，那么区间的大小不能保证就是第K大。
 int findkth(int* arr, int begin, int end, int k)
 {
     int key=arr[begin];
     int i=begin,j=end;
     while(i<j)
     {
         while(i<j && arr[j]<=key) j--;
         arr[i]=arr[j];
         while(i<j && arr[i]>=key) i++;
         arr[j]=arr[i];
     }
     arr[i]=key;

     //递归的结束条件为某一记录刚好划分到第k个位置
     //由于数组从0开始，所以需要加1了
     if (i == k-)return arr[i];
     else if (i < k-) return findkth(arr, i+, end, k);
     else return findkth(arr, begin, i-, k);
 }

 //只做了一轮划分，没有递归完成快速排序.返回的是划分的下标。数组a[]下标区间[low,high]
 template <class T>
 int partition(T a[],int low,int high)
 {
     T key=a[low];
     int i=low,j=high;
     while(i<j)
     {
         while(i<j && a[j]>=key) j--;
         a[i]=a[j];
         while(i<j && a[i]<=key) i++;
         a[j]=a[i];
     }
     a[i]=key;
     return i;
 }

 //利用快速排序的思想查找第K大的数值
 //第一个参数代表要查找的数组
 //第二个参数代表数组的长度
 //第三个参数代表要查找第几大的元素
 //非递归
 template <class T>
 T findkth2(T a[],int n,int k)
 {
     int low=,high=n-;
     while()
     {
         int pos=partition(a,low,high);
         if(pos==n-k) return a[pos];
         else if(pos<n-k)
         {
             low=pos+;
             high=n-;
         }
         else if(pos>n-k)
         {
             high=pos-;
             low=;
         }
     }
 }

 int main()
 {
     int a[]={,,,,,,,,,,};
     int b[]={,,,,,,,,,,};
     int c[]={,,,,,,,,,,};

     for(int i=;i<;i++) cout<<a[i]<<" ";
     cout<<endl;
     sort(a,a+);
     for(int i=;i<;i++) cout<<a[i]<<" ";
     cout<<endl;

     for(int i=;i>=;i--)
         cout<<findkth(b,,,i)<<" ";
     cout<<endl;

     for(int i=;i>=;i--)
         cout<<findkth2(c,,i)<<" ";
     cout<<endl;

     cout<<endl<<endl;
     for(int i=;i<;i++) cout<<b[i]<<" ";
     cout<<endl;
     for(int i=;i<;i++) cout<<c[i]<<" ";
     cout<<endl;
     return ;
 }  

参考：http://blog.csdn.net/guangwen_lv/article/details/39674241

利用快速排序的特点：第一遍排序会确定一个数的位置，这个数左边都比它大，右边都比他小（降序），当左边区间大于K时，说明我们求的第K大数在左边区间，这时我们可以舍弃右边区间，将范围缩小到左边区间从而重复上述过程，直到确定一个数的位置时，左边区间的小是K-1那么这个数字就是我们所求。右边同理。

能够使用这种方法的前提条件是：n个数不能重复。如果n个数中有重复，那么区间的大小不能保证就是第K大。可以用HASH判重来将重复的数据去掉。然后再使用上述方法。

也可阅读如下另一位网友的java代码：

 /** * Created with IntelliJ IDEA.
 * User: hqtc
 * Date: 16-3-22
 * Time: 下午9:52
 * To change this template use File | Settings | File Templates.
 */
 public class QuickSort{

     private int getSeparatorIndex(int[] nums, int low, int high) {
         int k = nums[low];
         while (low < high) {
             while (k < nums[high] && low < high) {
                 high--;
             }
             if (low < high)
                 nums[low++] = nums[high];
             while (k > nums[low] && low < high) {
                 low++;
             }
             if (low < high)
                 nums[high--] = nums[low];
         }
         nums[low] = k;
         return low;
     }

     public void sort(int num[], int low, int high) {
         if (low < high) {
             int sepIndex = getSeparatorIndex(num, low, high);
             sort(num, low, sepIndex - 1);
             sort(num, sepIndex + 1, high);
         }
     }

     public int findKthMax(int arr[], int k, int left, int right) {
         int sepIndex = getSeparatorIndex(arr, left, right);
         if (k == arr.length - sepIndex) {
             return arr[sepIndex];
         } else {
             if (k > arr.length - sepIndex) {
                 return findKthMax(arr, k, left, sepIndex - 1);
             } else {
                 return findKthMax(arr, k, sepIndex + 1, right);
             }
         }
     }
 }

 /*作者：环球探测
 链接：http://www.jianshu.com/p/9f887dfc374a
 來源：简书
 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。*/