十大基础实用算法补全——BFPRT算法

　　假如现在有一个数组，要求出第K大的数，我们该怎么做呢？

1. 本人第一反应:先把数组排序，再顺序读出第k大的数;2. 学过快排后:我们不需要对原数组进行排序，只通过选基准数进行分区，比较基准数所在位置来得出;

　　第一种情况直接把问题变成了排序问题，复杂度与对应选取的排序算法挂钩，目前最好情况也为O(nlogn)；
　　第二种情况是采用所谓的快速选择算法（QuickSelect），平均复杂度为O(N)，最坏复杂度为O(N^2);
　　
　　而下面要介绍的BFPRT算法可以保证在最坏情况下时间复杂度仍为O(N)
　　

算法简介：

　　BFPRT算法，又称为中位数的中位数…(注意不是第二层的中位数)算法，由5位大牛（Blum 、 Floyd 、 Pratt 、 Rivest 、 Tarjan）提出，并以他们的名字命名。
　　算法的思想是修改快速选择算法的主元选取方法，提高算法在最坏情况下的时间复杂度。
　　

基本步骤

　　1.首先把数组按5个数为一组进行分组，最后不足5个的为一组。对每组数进行排序（如插入排序）求取其中位数，并将所有中位数移到当前数组的前面
　　2.对这些中位数重复1操作，直到只有一个中位数(中位数的中位数的中位数的中位数…)；
　　3.将上一步得到的中位数作为划分的主元进行整个数组的划分。（这里你需要事先了解快速排序算法）
　　　4.判断第k个数在划分结果的左边、右边还是恰好是划分结果本身，前两者递归处理，后者直接返回答案。

例子

　　这里将代码段选取的数组作为例子讲解

原数组：2 3 8 5 6 — 7 9 0 4 1 — 11 12
求寻找第k=5大的数

第一轮

FindMid第一次

当前数列：2 3 8 5 6 --- 7 9 0 4 1 --- 11 12(1)判断“数列长度是否为1”，是则跳出递归，否则继续第一次前5个进行插入排序，其他不变2 3 5 6 8 --- 7 9 0 4 1 --- 11 12中位数按顺序换到原数列前面:5与2换位5 3 2 6 8 ----7 9 0 4 1 --- 11 12第二次中间5个进行插入排序，其他不变5 3 2 6 8 --- 0 1 4 7 9 --- 11 12中位数按顺序换到原数列前面:4与3换位5 4 2 6 8 --- 0 1 3 7 9 --- 11 12 第三次后2个进行插入排序，其他不变5 4 2 6 8 --- 0 1 3 7 9 --- 11 12中位数按顺序换到原数列前面:11与2换位5 4 11 6 8 --- 0 1 3 7 9 --- 2 12 取中位数构成的数列当前数列：5 4 11(2)判断“中位数构成的新数列长度是否为1”，是则跳出递归，否则继续3个进行插入排序4 5 11中位数按顺序换到原数列前面:5与4换位5 4 11取中位数构成的数列当前数列：5(3)判断“中位数构成的新数列长度是否为1”，是则跳出递归，否则继续跳出

Portition第一次

具体步骤略得结果：2 4 3 1 0 --- 5 8 6 7 9 --- 11 12

BFPTR第一次

判断5位于新数列的第几个位置，此处为第6个位置>k;选择前面的区间(不包括5)继续不再变化的数组部分:X X X X X --- 5 8 6 7 9 --- 11 12

第二轮

FindMid第二次

当前数列：2 4 3 1 05个进行插入排序，其他不变0 1 2 3 4中位数按顺序换到原数列前面:5与4换位2 0 1 3 4取中位数构成的数列当前数列：2(3)判断“中位数构成的新数列长度是否为1”，是则跳出递归，否则继续跳出

Portition第二次

具体步骤略得结果：0 1 2 3 4

BFPTR第二次

判断2位于新数列的第几个位置，此处为第3个位置<k;选择后面的区间(不包括2)继续不再变化的数组部分:0 1 2 X X --- 5 8 6 7 9 --- 11 12

第三轮

FindMid第三次

当前数列：3 42个进行插入排序，其他不变3 4中位数按顺序换到原数列前面:不用换3 4取中位数构成的数列当前数列：3(3)判断“中位数构成的新数列长度是否为1”，是则跳出递归，否则继续跳出

Portition第三次

具体步骤略得结果：3 4

BFPTR第三次

判断3位于新数列第几个位置，此处为第1个位置<k-3;选择后面的区间(不包括2)继续不再变化的数组部分:0 1 2 3 X --- 5 8 6 7 9 --- 11 12

第四轮

FindMid第四次

当前数列：41个进行插入排序，其他不变4中位数按顺序换到原数列前面:不用换4取中位数构成的数列当前数列：4(3)判断“中位数构成的新数列长度是否为1”，是则跳出递归，否则继续跳出

Portition第四次

具体步骤略得结果：4

BFPTR第四次

判断4位于新数列第几个位置，此处为第1个位置=k-3-1;找到了跳出不再变化的数组部分:0 1 2 3 4 --- 5 8 6 7 9 --- 11 12

最终结果：
当前数组：0 1 2 3 4 — 5 8 6 7 9 — 11 12
第5大的数为4

---

代码实现

//本代码有许多注释掉的代码，目的是便于观察算法是怎么执行的#include <iostream>#include <string.h>using namespace std;int m;void printArray(int array[], int length){    for (int i = 0; i < length; i++)        printf("%d ", array[i]);    printf("\n\n");}//插入排序void InsertSort(int a[], int l, int r){    int i, j;    //边界问题    for (i = l + 1; i <= r; i++)    {        //前面的大于后面的，防止空操作        if (a[i - 1] > a[i])        {            //记录下待插值            int temp = a[i];            //未到头，当前数大于就把它往后挪            for(j = i; j > l&&a[j - 1] > temp; j--)            {                a[j] = a[j - 1];            }            a[j] = temp;        }    }}//递归寻找中位数的中位数的中位数...int FindMid(int a[], int l, int r){    int length = r - l + 1;//数列长度    //printf("FindMid\n");    if (length == 1)//只有一个数，返回本身    {        return a[l];    }    int first = 0;//子数列的第一个数    int size = 5;    int gourpCount = 0;    //将原数列分成若干个size=5的子数列,进行操作    for (first = l; first + size <= length; first += size)    {        gourpCount++;        int last = first + size-1;//子数列的最后一个数        InsertSort(a, first, last);        //printArray(a, m);        //printf("swap a[%d]=%d,a[%d]=%d\n", l + first / 5, a[l + first / 5], first + (size - 1) / 2, a[first + (size - 1) / 2]);        swap(a[l + first / 5], a[first + (size - 1) / 2]);//将中位数按顺序放到原数列的头部        //printArray(a, m);    }    //同理，剩余元素处理    size = length%size;    if (size > 0)    {        gourpCount++;        //printf("length=%d,size =%d\n", length,size);        int last = first + size - 1;        InsertSort(a, first, last);        //printArray(a, m);        //printf("swap a[%d]=%d,a[%d]=%d\n", l + first / 5, a[l + first / 5], first + (size -1) / 2, a[first + (size - 1) / 2]);        swap(a[l + first / 5], a[first + (size -1) / 2]);        //printArray(a, m);    }    return FindMid(a, l, l + (gourpCount-1));}//进行划分过程int Partition(int a[], int l, int r){    //printf("Partion\n");    int i = l;    int j = r;    int pivot = a[l];    //双向扫描挪动    while (i < j)    {        while (a[j] >= pivot && i < j)        {            j--;        }        a[i] = a[j];        //printArray(a, m);        while (a[i] <= pivot && i < j)        {            i++;        }        a[j] = a[i];        //printArray(a, m);    }    a[i] = pivot;    //printArray(a, m);    return i;}int BFPTR(int a[], int l, int r, int k){    int count = 0;    int num = FindMid(a, l, r);    int i = Partition(a, l, r);    //看前面有几个数,根据此来判断是否找到    int m = i - l + 1;    if (m == k)     //当前恰好是第k个，返回当前值    {        return a[i];    }       else if (m > k) //前面的数多于k-1，缩小至前面范围（不包括基点），寻找第k个    {        return BFPTR(a, l, i - 1, k);    }    else           //前面的数少于k-1，缩小至后面范围，寻找第k-m个    {        return BFPTR(a, i + 1, r, k - m);    }}int main(){    int a[20] = { 2, 3, 8 ,5, 6, 7, 9, 0, 4, 1,11,12};    int n = 12, k=5;    m = n;    printArray(a, n);    printf("The %d th number is : %d\n", k, BFPTR(a, 0, n - 1, k));    printArray(a, n);    return 0;}

运行结果：

---

复杂度分析

　　关于BFPRT算法的复杂度分析参考：快速选择算法——BFPRT算法。
　　个人感觉以上分析过于简单，更详细的证明请参考《算法导论》9.3节。

---

　　如果有什么错误之处或建议，请在评论区告诉我，谢谢！