十大基础实用算法补全——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 0
5个进行插入排序，其他不变
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 4
2个进行插入排序，其他不变
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第四次

当前数列：4
1个进行插入排序，其他不变
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;
}