查找数组中第k大的数字

 可以通过堆排序和快速排序来查找

堆排序应该是最直观最快速的。大顶堆建立之后，每次从堆中拿最顶端的最大值，第K个就是第K次拿最大值。

快速降序排序查找，每走一趟排序之后通过基准值和k比较，如果k大于基准值的index则到左边找，k小于基准值的index则在右边找，等于的话那就是基准值本身。每次只查找一边，不用像快速排序一样两边都要排序，查找效率比排序效率高一倍。

#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <inttypes.h>
#include <string>
#include <string.h>
#include <sstream>
#include <memory>
#include <map>
#include <unordered_map>
#include <list>
#include <vector>
#include <set>
#include <deque>
#include <sys/time.h>
#include <unistd.h>
#include <sys/timeb.h>
#include <thread>
#include <iostream>

//g++ -std=c++11 -o exe_main main.cpp
//g++ -Wl,-as-needed -std=c++11 -o exe_main main.cpp -lpthread


//堆排序查找数组中第k大的数字
int heap_find_k_max(int data[], int n, int k)
{
        int k_max = 0;
        create_heap(data, n);

        int reverse_i = n - 1;

        for(int i = 0; i < k; ++i)
        {
                k_max = data[0];
                reverse_i = n - i - 1;
                swap(data[reverse_i], data[0]);
                heap_adjust(data, reverse_i, 0);
        }
        return k_max;
}

void heap_find_max(int data[], int n)
{
        printf("please input k:\n");
        int k = 0;
        scanf("%d", &k);
        int k_max = heap_find_k_max(data, sizeof(data)/sizeof(data[0]), k);
        printf("k_max:%d\n", k_max);
}

//快速排序查找数组中第k大的数字
int quick_find_k_max(int data[], int n, int begin, int end, int k)
{
        if(begin >= end){
                printf("begin:%d >= end:%d, return data[end]:%d\n", begin, end, data[end]);
                return data[end];
        }
        int k_index = k - 1;
        int key = data[begin];
        int i = begin, j = end;
        printf("i:%d, j:%d, key:%d\n", i, j, key);

        while (i < j)
        {
                while (i < j && data[j] <= key)
                {
                        printf("--j:%d, i:%d, key:%d\n", j, i, key);
                        --j;
                }
                if(i < j){
                        data[i] = data[j];
                }

                while (i < j && data[i] >= key)
                {
                        printf("++i:%d, j:%d, key:%d\n", i, j, key);
                        ++i;
                }
                if (i < j)
                {
                        data[j] = data[i];
                }
        }
        data[i] = key;

        if (k_index > i)
        {
                return quick_find_k_max(data, n, i + 1, end, k);
        }
        else if (k_index < i)
        {
                return quick_find_k_max(data, n, begin, i - 1, k);
        }
        else
        {
                printf("return:%d, k_index:%d, i:%d, j:%d\n", data[i], k_index, i, j);
                return data[i];
        }
        printf("err k_index:%d, i:%d, j:%d\n", k_index, i, j);
        return 0;
}

void quick_find_max(int data[], int n)
{
        printf("please input k:\n");
        int k = 0;
        scanf("%d", &k);
        int k_max = quick_find_k_max(data, n, 0, n-1, k);
        printf("k_max:%d\n", k_max);
}

int main()
{
        int data[] = {12,34,67,8,12,9842,789,23,978,3,10000,234,56,78,243,423,34,243,43,6785,312,1};

        //heap_find_max(data, sizeof(data)/sizeof(data[0]));

        quick_find_max(data, sizeof(data)/sizeof(data[0]));

        print_data(data,  sizeof(data)/sizeof(data[0]));

        return 0;
}