输出数组第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-1)return arr[i];
    else if (i < k-1) return findkth(arr, i+1, end, k);
    else return findkth(arr, begin, i-1, 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=0,high=n-1;
    while(1)
    {
        int pos=partition(a,low,high);
        if(pos==n-k) return a[pos];
        else if(pos<n-k)
        {
            low=pos+1;
            high=n-1;
        }
        else if(pos>n-k)
        {
            high=pos-1;
            low=0;
        }
    }
}

int main()  
{
    int a[11]={78934,234,65,32,543,354,567,3412,23,547,423};
    int b[11]={78934,234,65,32,543,354,567,3412,23,547,423};
    int c[11]={78934,234,65,32,543,354,567,3412,23,547,423};
    
    for(int i=0;i<11;i++) cout<<a[i]<<" ";
    cout<<endl;
    sort(a,a+11);
    for(int i=0;i<11;i++) cout<<a[i]<<" ";
    cout<<endl;
    
    for(int i=11;i>=1;i--)
        cout<<findkth(b,0,10,i)<<" ";
    cout<<endl;
    
    for(int i=11;i>=1;i--)
        cout<<findkth2(c,11,i)<<" ";
    cout<<endl;
    
    
    cout<<endl<<endl;
    for(int i=0;i<11;i++) cout<<b[i]<<" ";
    cout<<endl;
    for(int i=0;i<11;i++) cout<<c[i]<<" ";
    cout<<endl;
    return 0;
}  

参考：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
來源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。*/