BFPRT 算法

转载 2016年08月30日 15:06:12

http://blog.csdn.net/acdreamers/article/details/44656295

通常,我们需要在一大堆数中求前K大的数,或者求前K小的。比如在搜索引擎中求当天用户点击次数排名

10000的热词;在文本特征选择中求IF-IDF值按从大到小排名前K个的等等问题,都涉及到一个核心问

题,即TOP-K问题

 

通常来说,TOP-K问题可以先对所有数进行快速排序,然后取前K大的即可。但是这样做有两个问题。

 

(1)快速排序的平均复杂度为,但最坏时间复杂度为,不能始终保证较好的复杂度。

(2)我们只需要前K大的,而对其余不需要的数也进行了排序,浪费了大量排序时间。

 

除这种方法之外,堆排序也是一个比较好的选择,可以维护一个大小为K的堆,时间复杂度为

 

我们的目的是求前K大的或者前K小的元素,实际上有一个比较好的算法,叫做BFPTR算法,又称为中位数

的中位数算法,它的最坏时间复杂度为,它是由Blum、Floyd、Pratt、Rivest、Tarjan提出。

该算法的思想是修改快速选择算法的主元选取方法,提高算法在最坏情况下的时间复杂度。我们先来看看

快速排序是如何进行的。

 

一趟快速排序的过程如下

 

  (1)先从序列中选取一个数作为基准数

  (2)将比这个数大的数全部放到它的右边,把小于或者等于它的数全部放到它的左边

 

一趟快速排序也叫做Partion,即将序列划分为两部分,一部分比基准数小,另一部分比基准数大,然后

再进行分治过程,因为每一次Partion不一定都能保证划分得很均匀,所以最坏情况下的时间复杂度不能

保证总是为

 

对于Partion过程,通常有两种方法

 

(1)两个指针从首尾向中间扫描(双向扫描)

 

    这种方法可以用挖坑填数来形容,比如

 

    

 

    初始化:i = 0; j = 9; pivot = a[0];

 

    现在a[0]保存到了变量pivot中了,相当于在数组a[0]处挖了个坑,那么可以将其它的数填到这里

    来。从j开始向前找一个小于或者等于pivot的数,即将a[8]填入a[0],但a[8]又形成了一个新坑,

    再从i开始向后找一个大于pivot的数,即a[3]填入a[8],那么a[3]又形成了一个新坑......

 

    就这样,直到i==j才停止,最终得到结果如下

 

    

 

    上述过程就是一趟快速排序

 

代码:

#include <iostream>
#include <string.h>
#include <stdio.h>
#include <algorithm>
#include <time.h>
 
using namespace std;
const int N = 10005;
 
int Partion(int a[], int l, int r)
{
    int i = l;
    int j = r;
    int pivot = a[l];
    while(i < j)
    {
        while(a[j] >= pivot && i < j)
            j--;
        a[i] = a[j];
        while(a[i] <= pivot && i < j)
            i++;
        a[j] = a[i];
    }
    a[i] = pivot;
    return i;
}
 
void QuickSort(int a[], int l, int r)
{
    if(l < r)
    {
        int k = Partion(a, l, r);
        QuickSort(a, l, k - 1);
        QuickSort(a, k + 1, r);
    }
}
 
int a[N];
 
int main()
{
    int n;
    while(cin >> n)
    {
        for(int i = 0; i < n; i++)
            cin >> a[i];
        QuickSort(a, 0, n - 1);
        for(int i = 0; i < n; i++)
            cout << a[i] << " ";
        cout << endl;
    }
    return 0;
}

(2)两个指针一前一后逐步向前扫描(单向扫描)

 

代码:

#include <iostream>
#include <string.h>
#include <stdio.h>
 
using namespace std;
const int N = 10005;
 
int Partion(int a[], int l, int r)
{
    int i = l - 1;
    int pivot = a[r];
    for(int j = l; j < r; j++)
    {
        if(a[j] <= pivot)
        {
            i++;
            swap(a[i], a[j]);
        }
    }
    swap(a[i + 1], a[r]);
    return i + 1;
}
 
void QuickSort(int a[], int l, int r)
{
    if(l < r)
    {
        int k = Partion(a, l, r);
        QuickSort(a, l, k - 1);
        QuickSort(a, k + 1, r);
    }
}
 
int a[N];
 
int main()
{
    int n;
    while(cin >> n)
    {
        for(int i = 0; i < n; i++)
            cin >> a[i];
        QuickSort(a, 0, n - 1);
        for(int i = 0; i < n; i++)
            cout << a[i] << " ";
        cout << endl;
    }
    return 0;
}

实际上基于双向扫描的快速排序要比基于单向扫描的快速排序算法快很多。接下来,我们学习BFPTR算法的原理。

 

BFPTR算法中,仅仅是改变了快速排序Partion中的pivot值的选取,在快速排序中,我们始终选择第一个元

素或者最后一个元素作为pivot,而在BFPTR算法中,每次选择五分中位数的中位数作为pivot,这样做的目的

就是使得划分比较合理,从而避免了最坏情况的发生。算法步骤如下

 

(1)将输入数组的个元素划分为组,每组5个元素,且至多只有一个组由剩下的个元素组成。

(2)寻找个组中每一个组的中位数,首先对每组的元素进行插入排序,然后从排序过的序列中选出中位数。

(3)对于(2)中找出的个中位数,递归进行步骤(1)和(2),直到只剩下一个数即为这个元素

    的中位数,找到中位数后并找到对应的下标

(4)进行Partion划分过程,Partion划分中的pivot元素下标为

(5)进行高低区判断即可。

 

本算法的最坏时间复杂度为,值得注意的是通过BFPTR算法将数组按第K小(大)的元素划分为两部分,而

这高低两部分不一定是有序的,通常我们也不需要求出顺序,而只需要求出前K大的或者前K小的。

 

另外注意一点,求第K大就是求第n-K+1小,这两者等价。TOP K问题在工程中有重要应用,所以很有必要掌握。

 

代码:

#include <iostream>
#include <string.h>
#include <stdio.h>
#include <time.h>
#include <algorithm>
 
using namespace std;
const int N = 10005;
 
int a[N];
 
//插入排序
void InsertSort(int a[], int l, int r)
{
    for(int i = l + 1; i <= r; i++)
    {
        if(a[i - 1] > a[i])
        {
            int t = a[i];
            int j = i;
            while(j > l && a[j - 1] > t)
            {
                a[j] = a[j - 1];
                j--;
            }
            a[j] = t;
        }
    }
}
 
//寻找中位数的中位数
int FindMid(int a[], int l, int r)
{
    if(l == r) return a[l];
    int i = 0;
    int n = 0;
    for(i = l; i < r - 5; i += 5)
    {
        InsertSort(a, i, i + 4);
        n = i - l;
        swap(a[l + n / 5], a[i + 2]);
    }
 
    //处理剩余元素
    int num = r - i + 1;
    if(num > 0)
    {
        InsertSort(a, i, i + num - 1);
        n = i - l;
        swap(a[l + n / 5], a[i + num / 2]);
    }
    n /= 5;
    if(n == l) return a[l];
    return FindMid(a, l, l + n);
}
 
//寻找中位数的所在位置
int FindId(int a[], int l, int r, int num)
{
    for(int i = l; i <= r; i++)
        if(a[i] == num)
            return i;
    return -1;
}
 
//进行划分过程
int Partion(int a[], int l, int r, int p)
{
    swap(a[p], a[l]);
    int i = l;
    int j = r;
    int pivot = a[l];
    while(i < j)
    {
        while(a[j] >= pivot && i < j)
            j--;
        a[i] = a[j];
        while(a[i] <= pivot && i < j)
            i++;
        a[j] = a[i];
    }
    a[i] = pivot;
    return i;
}
 
int BFPTR(int a[], int l, int r, int k)
{
    int num = FindMid(a, l, r);    //寻找中位数的中位数
    int p =  FindId(a, l, r, num); //找到中位数的中位数对应的id
    int i = Partion(a, l, r, p);
 
    int m = i - l + 1;
    if(m == k) return a[i];
    if(m > k)  return BFPTR(a, l, i - 1, k);
    return BFPTR(a, i + 1, r, k - m);
}
 
int main()
{
    int n, k;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
        scanf("%d", &a[i]);
    scanf("%d", &k);
    printf("The %d th number is : %d\n", k, BFPTR(a, 0, n - 1, k));
    for(int i = 0; i < n; i++)
        printf("%d ", a[i]);
    puts("");
    return 0;
}
 
/**
10
72 6 57 88 60 42 83 73 48 85
5
*/

关于本算法最坏时间复杂度为的证明可以参考《算法导论》9.3节,即112页,有详细分析。


BFPRT 算法

通常,我们需要在一大堆数中求前K大的数,或者求前K小的。比如在搜索引擎中求当天用户点击次数排名 前10000的热词;在文本特征选择中求IF-IDF值按从大到小排名前K个的等等问题,都涉及到一个核心问 ...

BFPTR算法(中位数的中位数算法)求n个数中第k大的数

BFPTR算法求n个数中第k大(即第n-1-k小)的数,其思想是基于快速排序中对Partion的pivot值进行优化,快速排序中每一趟快排的pivot的选取一般是数组的首项或者尾项(数值比较随机),而...

bfptr算法

以下转自:http://noalgo.info/466.html BFPRT算法是解决从n个数中选择第k大或第k小的数这个经典问题的著名算法,但很多人并不了解其细节。本文将首先介绍求解这个第...

【算法题】BFPRT算法:求第K小或者第K大的数

2017/11/21BFPRT问题问题描述:一个数组中求第k小或者第k大的数思路不通过排序求第k小的数,时间复杂度为O(N)。主要是利用快排中的partition过程。(随机快排见上一篇博客)1、找到...

BFPRT算法解决求前k(大或小)数的问题

文章转载自:http://blog.csdn.net/acdreamers/article/details/44656295 通常,我们需要在一大堆数中求前K大的数,或者求前K小的。比如在搜索引...

BFPRT算法(TOP-K问题)

一:背景介绍  在一大堆数中求其前K大或前K小的问题,简称TOP-K问题。而目前解决TOK-K问题最有效的算法即是BFPRT算法,又称为中位数的中位数算法,该算法由Blum、Floyd、Pratt、R...
  • LaoJiu_
  • LaoJiu_
  • 2017年02月11日 20:53
  • 2564

BFPRT 算法java实现

通常,我们需要在一大堆数中求前K大的数,或者求前K小的。比如在搜索引擎中求当天用户点击次数排名 前10000的热词;在文本特征选择中求IF-IDF值按从大到小排名前K个的等等问题,都涉及到一个核...

bfprt算法求最小的k个数

bfprt算法是一种经典的线性时间内求最小的第k个数或者最小的k个数的算法。 比如我们要知道销量是前几名商品或者是浏览量最多的前几个网站,我们不需要排序,利用bfprt算法就可以完成。 bfprt算法...

求n个数中的最小的k个数的BFPRT算法

最近在学习算法,平常没有写博客的习惯,慢慢发现,有些东西写了自己的印象才会更加深刻,每次看着那些牛人写的博客,总是心生感叹,琢磨着自己也写几篇博客。                          ...
  • adong76
  • adong76
  • 2013年08月19日 20:47
  • 4207

bfprt算法----找出数组中最小的k个数(Java)

无序数组中最小的k个数 对于一个无序数组,数组中元素为互不相同的整数,请返回其中最小的k个数。 给定一个整数数组A及它的大小n,同时给定k,请返回其中最小的k个数。 测试样例: [1,2,4,3]...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:BFPRT 算法
举报原因:
原因补充:

(最多只允许输入30个字)