在文章開頭先了解隨機快速排序，隨機排序之前博文中有，在此增加快速排序中partition函式，參照http://www.cnblogs.com/sdlwlxf/p/5131793.html

Master公式：用於算複雜度

此公式只適用於每次遞迴量相同的情況，可以簡化理解為一下過程：

a表示遞迴的次數，b表示遞迴規程中每次遞迴縮小是的資料量，n^d為遞迴後續行為的複雜度。比如，資料量為n，歸併排序時複雜度=前n/2的複雜度+後n/2的複雜度+將這兩個n/2合併成一個數組時的複雜度。

bfprt演算法原理：

在無序陣列中，找到最小或最大第k個數的演算法思想：

在快速排序或是隨機快速排序中，步驟為：1、用速排序或是隨機快速排序方法

若在即可得到第k個數，若不在，則在>x  或<x  中步驟1 開始重新查詢，直至找到。此方法的平均複雜度為O（n），但單次複雜度不一定是。

bfprt演算法只是在選擇劃分值的策略上不一樣，其他的與快排一樣。

bfprt演算法的劃分策略是：1、將陣列每五個劃為一組，不夠5個單列一組     複雜度O(1)

                                            2、每個組中的資料進行組內排序         複雜度O(n)

                                            3、把每個組中的中位數拿出，組成一個新的陣列   n/5    複雜度O(n)

                                            4、求出n/5這個陣列的中位數，這個數在陣列中是第n/10個數，用重複呼叫自己的方法來找。此處的中位數就是所要找的劃分值 F(n/5)

                                            5、partition函式把陣列排成 >x  ==x  <x   複雜度O(n)

                                            6、看==x的下標分為是否包含k若在即可得到第k個數，若不在，則在>x  或<x  中步驟1 開始重新查詢，直至找到。

假設五組已經排好的序列，X出為最後找的中位數，在陣列的n/10的位置上。<=這個值的有n*3/10,>這個值的為n*7/10

整個複雜度：F(n)=F(n/5)+F(n*7/5)+O(n)

JAVA程式：

package douyu_2017_07_31;


public class Problem_01_FindMinKNums {


// O(N*logK)
public static int[] getMinKNumsByHeap(int[] arr, int k) {
if (k < 1 || k > arr.length) {
return arr;
}
int[] kHeap = new int[k];
for (int i = 0; i != k; i++) {
heapInsert(kHeap, arr[i], i);
}
for (int i = k; i != arr.length; i++) {
if (arr[i] < kHeap[0]) {
kHeap[0] = arr[i];
heapify(kHeap, 0, k);
}
}
return kHeap;
}


public static void heapInsert(int[] arr, int value, int index) {
arr[index] = value;
while (index != 0) {
int parent = (index - 1) / 2;
if (arr[parent] < arr[index]) {
swap(arr, parent, index);
index = parent;
} else {
break;
}
}
}


public static void heapify(int[] arr, int index, int heapSize) {
int left = index * 2 + 1;
int right = index * 2 + 2;
int largest = index;
while (left < heapSize) {
if (arr[left] > arr[index]) {
largest = left;
}
if (right < heapSize && arr[right] > arr[largest]) {
largest = right;
}
if (largest != index) {
swap(arr, largest, index);
} else {
break;
}
index = largest;
left = index * 2 + 1;
right = index * 2 + 2;
}
}


// O(N)
public static int[] getMinKNumsByBFPRT(int[] arr, int k) {
if (k < 1 || k > arr.length) {
return arr;
}
int minKth = getMinKthByBFPRT(arr, k);
int[] res = new int[k];
int index = 0;
for (int i = 0; i != arr.length; i++) {
if (arr[i] < minKth) {
res[index++] = arr[i];
}
}
for (; index != res.length; index++) {
res[index] = minKth;
}
return res;
}


public static int getMinKthByBFPRT(int[] arr, int K) {
int[] copyArr = copyArray(arr);
return select(copyArr, 0, copyArr.length - 1, K - 1);
}


public static int[] copyArray(int[] arr) {
int[] res = new int[arr.length];
for (int i = 0; i != res.length; i++) {
res[i] = arr[i];
}
return res;
}


public static int select(int[] arr, int begin, int end, int i) {
if (begin == end) {
return arr[begin];
}
int pivot = medianOfMedians(arr, begin, end);
int[] pivotRange = partition(arr, begin, end, pivot);
if (i >= pivotRange[0] && i <= pivotRange[1]) {
return arr[i];
} else if (i < pivotRange[0]) {
return select(arr, begin, pivotRange[0] - 1, i);
} else {
return select(arr, pivotRange[1] + 1, end, i);
}
}


public static int medianOfMedians(int[] arr, int begin, int end) {
int num = end - begin + 1;
int offset = num % 5 == 0 ? 0 : 1;
int[] mArr = new int[num / 5 + offset];
for (int i = 0; i < mArr.length; i++) {
int beginI = begin + i * 5;
int endI = beginI + 4;
mArr[i] = getMedian(arr, beginI, Math.min(end, endI));
}
return select(mArr, 0, mArr.length - 1, mArr.length / 2);
}


public static int[] partition(int[] arr, int begin, int end, int pivotValue) {
int small = begin - 1;
int cur = begin;
int big = end + 1;
while (cur != big) {
if (arr[cur] < pivotValue) {
swap(arr, ++small, cur++);
} else if (arr[cur] > pivotValue) {
swap(arr, cur, --big);
} else {
cur++;
}
}
int[] range = new int[2];
range[0] = small + 1;
range[1] = big - 1;
return range;
}


public static int getMedian(int[] arr, int begin, int end) {
insertionSort(arr, begin, end);
int sum = end + begin;
int mid = (sum / 2) + (sum % 2);
return arr[mid];
}


public static void insertionSort(int[] arr, int begin, int end) {
for (int i = begin + 1; i != end + 1; i++) {
for (int j = i; j != begin; j--) {
if (arr[j - 1] > arr[j]) {
swap(arr, j - 1, j);
} else {
break;
}
}
}
}


public static void swap(int[] arr, int index1, int index2) {
int tmp = arr[index1];
arr[index1] = arr[index2];
arr[index2] = tmp;
}


public static void printArray(int[] arr) {
for (int i = 0; i != arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}


public static void main(String[] args) {
int[] arr = { 6, 9, 1, 3, 1, 2, 2, 5, 6, 1, 3, 5, 9, 7, 2, 5, 6, 1, 9 };
// sorted : { 1, 1, 1, 1, 2, 2, 2, 3, 3, 5, 5, 5, 6, 6, 6, 7, 9, 9, 9 }
printArray(getMinKNumsByHeap(arr, 10));
printArray(getMinKNumsByBFPRT(arr, 10));


}


}

C++程式：

//求第k小的數
#include<iostream>
#include<stdlib.h>
using namespace std;


int partition(int* a,int low,int high)
{
int temp=a[low];
int curr=low;
int dex=low-1;
while(low<high)
{
while(low<high&&a[high]>temp)
high--;
if(low<high)a[low]=a[high];
while(low<high&&a[low]<=temp)
low++;
if(low<high)a[high]=a[low];
    }
a[low]=temp;
return low;
}
void found(int* a,int low,int high,int k)
{
int temp=partition(a,low,high);
if(temp==(k-1))
cout<<"第k小數"<<a[temp]<<endl;
else if(temp>(k-1))
found(a,low,temp-1,k);
else
found(a,temp+1,high,k);
}


int main()
{
int a[10]={15,25,9,48,36,100,58,99,126,5};
int n;
while(cin>>n)
{
found(a,0,9,n);
}


system("pause");
return 0;
}