O（n）获得中位数及获得第K小（大）的数

首先，中位数问题可以归结为求 K=n/2的 第K小元素，并无明显区别。

第一种方法，用MaxHeap，大小为K的大顶堆，能够求出最小的K的元素，复杂度为O(n*logK). 当K较大时，复杂度会较高。其实只需要求出第K小，而不是全部前K的序列，可以有更优化的方式。(大顶堆的方法就不贴代码了)

第二种方法，采用partition能够进行一定程度的改进，开始我认为这种方式已经是O(n)，实际上如果partition选取的pivot导致每次partition都偏向一边，那么最坏情况是O(n^2). 先贴代码如下：

#include <iostream>
#include <stdio.h>
#include <unistd.h>

using namespace std;

int array[] = {, , , , , , };
const int size = sizeof(array) /  sizeof (*array);

int partition(int *array, int left, int right) {
    if (array == NULL) {
        return -;
    }

    int pos = right;
    right--;

    while (left <= right) {
        while (left <= right && array[left] <= array[pos]) {
            left++;
        }
        while (right > left && array[right] > array[pos]) {
            right--;
        }
        if (left >= right) {
            break;
        }
        swap(array[left], array[right]);
    }
    swap(array[left], array[pos]);
    return left;

}

int getMinKth(int *array, int size, int k) {
    if (array == NULL) {
        return -;
    }
    int left = ;
    int right = size - ;
    int index = -;

    while (index != k) {
        index = partition(array, left, right);
        if (index < k) {
            left = index + ;
        }
        else if (index > k) {
            right = index - ;
        }
        else {
            break;
        }
    }

    cout << "Value of k " << k << ":" << array[index] << endl;
    return array[index];
}

int main(int argc, char** argv) {

    if (argc < ) {
        printf("Run cmd %s kth\n", basename(argv[]));
        return ;
    }

    int k = atoi(argv[]);
    int value = getMinKth(array, size, k);
    return ;
}

运行结果：

[getMinKth]$ ./getMinKth
Value of k :
[getMinKth]$ ./getMinKth
Value of k :
[getMinKth]$ ./getMinKth
Value of k :
[getMinKth]$ ./getMinKth
Value of k :
[getMinKth]$ ./getMinKth
Value of k :
[getMinKth]$ ./getMinKth
Value of k :
[getMinKth]$ ./getMinKth
Value of k :

第三种方法，是真的O(n)，方法是采用5个一组的数列，取出中间一个，然后再从中取出中间一个，使用这个数作为pivot。

这样，至少有1/2 * 3/5个数比pivot小，也有1/2 * 3/5个数比pivot大。所以，每次最坏情况是划分成3:7或者7:3.

时间复杂度的证明方法：

T(n)<=T(n/)+T(/*n)+O(n)<=c*n*(+/+(/)^....)
所以T(n)=O(n)

写代码如下：

review时注：我觉得可以用上面的end比较的方式，先把pivot交换到最后，这样虽然多了一个swap，但是代码简洁很多，也不容易出错。

#include <algorithm>
#include <iostream>

using namespace std;

void printArr(int *arr, int first, int end) {
    cout << "Array first " << first << "end " << end << ":";
    for (int i=first; i<=end; ++i) {
        cout << arr[i] << " ";
    }
    cout << endl;
}
int getMinKth(int *arr, int first, int end, int k);

int partition(int *arr, int first, int end, int pivot) {

    int ret = -;
    int tmp = -;
    while (first <= end) {
        while (arr[first] <= pivot) {
            if (arr[first] == pivot) {
                ret = first;
            }
            first++;
        }
        while (arr[end] > pivot) {
            end--;
        }
        if (first < end) {
            tmp = arr[first];
            arr[first] = arr[end];
            arr[end] = tmp;
            if (arr[first] == pivot) {
                ret = first;
            }
            first++;
            end--;
        }
    }
    tmp = arr[end];
    arr[end] = arr[ret];
    arr[ret] = tmp;
    return end;

}

int getPivot(int *arr, int first, int end) {
    if (end - first +  <= ) {
        sort(arr+first, arr+end+);
        return arr[(first+end)/];
    }

    int grp = (end - first + ) / ;
    int *tmpArr = new int[grp];

    for (int i=; i<grp; i++) {
        int tmpFirst = first +  * i;
        int tmpEnd = first +  * i + ;
        if (tmpEnd > end) {
            tmpEnd = end;
        }
        tmpArr[i] = getPivot(arr, tmpFirst, tmpEnd);
    }
    int ret = getMinKth(tmpArr, , grp-, (grp-)/);
    delete []tmpArr;
    return ret;
}

int getMinKth(int *arr, int first, int end, int k) {

    if (first == end) {
        return arr[first];
    }
    if (k < first || k > end) {
        return -;
    }

    int index = -;
    int pivot = -;
    while (index != k) {
        pivot = getPivot(arr, first, end);
        index = partition(arr, first, end, pivot);
        if (index < k) {
            first = index + ;
        }
        else if (index > k) {
            end = index - ;
        }
        else {
            break;
        }
    }
    return arr[k];
}

int main(int argc, char **argv) {
    int array[] = {, , , , , , , };
    if (argc <= ) {
        printf("%s kth\n", argv[]);
        return ;
    }

    printArr(array, , );
    int k = atoi(argv[]);
    int ret = getMinKth(array, , , k);
    printf("The %dth val is %d\n", k, ret);
    return ;
}

编译命令：

g++ -o getMinKthOn getMinKthOn.cpp 

执行命令：

[getMinKthOn]$ ./getMinKthOn
Array first 0end :
The 0th val is
[getMinKthOn]$ ./getMinKthOn
Array first 0end :
The 1th val is
[getMinKthOn]$ ./getMinKthOn
Array first 0end :
The 2th val is
[getMinKthOn]$ ./getMinKthOn
Array first 0end :
The 3th val is
[getMinKthOn]$ ./getMinKthOn
Array first 0end :
The 4th val is
[getMinKthOn]$ ./getMinKthOn
Array first 0end :
The 5th val is
[getMinKthOn]$ ./getMinKthOn
Array first 0end :
The 6th val is
[getMinKthOn]$ ./getMinKthOn
Array first 0end :
The 7th val is 

代码写的有点罗嗦，中间也调试了好几次。

后面有时间的时候，可以慢慢改进。