精华内容
下载资源
问答
  • bfptr算法(即中位数中位数算法)

    万次阅读 多人点赞 2018-08-25 22:35:16
    BFPRT算法是解决从n个数中选择第k大或第k小的这个经典问题的著名算法,但很多人并不了解其细节。本文将首先介绍求解这个第k小数字问题的几个思路,然后重点介绍在最坏情况下复杂度仍然为O(n)的BFPRT算法。 一 ...

    BFPRT算法是解决从n个数中选择第k大或第k小的数这个经典问题的著名算法,但很多人并不了解其细节。本文将首先介绍求解这个第k小数字问题的几个思路,然后重点介绍在最坏情况下复杂度仍然为O(n)的BFPRT算法。

    一 基本思路

    关于选择第k小的数字有许多方法,其效率和复杂度各不一样,可以根据实际情况进行选择。

    1. 将n个数排序(比如快速排序或归并排序),选取排序后的第k个数,时间复杂度为O(nlogn)。使用STL函数sort可以大大减少编码量。
    2. 将方法1中的排序方法改为线性时间排序算法(如基数排序或计数排序),时间复杂度为O(n)。但线性时间排序算法使用限制较多,不常使用。
    3. 维护一个k个元素的最大堆,存储当前遇到的最小的k个数,时间复杂度为O(nlogk)。这种方法同样适用于海量数据的处理。
    4. 部分的选择排序,即把最小的放在第1位,第二小的放在第2位,直到第k位为止,时间复杂度为O(kn)。实现非常简单。
    5. 部分的快速排序(快速选择算法),每次划分之后判断第k个数在左右哪个部分,然后递归对应的部分,平均时间复杂度为O(n)。但最坏情况下复杂度为O(n^2)。
    6. BFPRT算法,修改快速选择算法的主元选取规则,使用中位数的中位数作为主元,最坏情况下时间复杂度为O(n)

    二 快速选择算法

    快速选择算法就是修改之后的快速排序算法,前面快速排序的实现与应用这篇文章中讲了它的原理和实现。

    其主要思想就是在快速排序中得到划分结果之后,判断要求的第k个数是在划分结果的左边还是右边,然后只处理对应的那一部分,从而达到降低复杂度的效果。

    在快速排序中,平均情况下数组被划分成相等的两部分,则时间复杂度为T(n)=2*T(n/2)+O(n),可以解得T(n)=nlogn。
    在快速选择中,平均情况下数组也是分成相等的两部分,但是只处理其中一部分,于是T(n)=T(n/2)+O(n),可以解得T(n)=O(n)。

    但是两者在最坏情况下的时间复杂度均为O(n^2),出现在每次划分之后左右总有一边为空的情况下。为了避免这个问题,需要谨慎地选取划分的主元,一般的方法有:

    1. 固定选择首元素或尾元素作为主元。
    2. 随机选择一个元素作为主元。
    3. 三数取中,选择三个数的中位数作为主元。一般是首尾数,再加中间的一个数或者随机的一个数。

    ============================================================

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

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

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

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

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

    我们的目的是求前K大的或者前K小的元素,实际上有一个比较好的算法,叫做BFPTR算法,又称为中位数的中位数算法,它的最坏时间复杂度为,它是由Blum、Floyd、Pratt、Tarjan、Rivest 提出。

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

    一趟快速排序的过程如下

    (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页,有详细分析。

     

    原文链接:https://blog.csdn.net/wyq_tc25/article/details/51801885

    展开全文
  • 快速中位数的算法

    万次阅读 2019-07-14 07:35:59
    众所周知,quick sort的时间复杂度为O(N*log(N)),利用quick sort的原理可以实现经典的找任意...找了一下快速计算中位数的方法,找到一篇有趣的报告:“Fast Median Search: an ANSI C implementation”。这篇报告提...

    众所周知,quick sort的时间复杂度为O(N*log(N)),利用quick sort的原理可以实现经典的找任意第K大的数的算法:时间复杂度为O(N)。不过这个算法基于快速排序,常数项很大,只是理论上很有意思的方法,但实践中很少拿来用。

    找了一下快速计算中位数的方法,找到一篇有趣的报告:“Fast Median Search: an ANSI C implementation”。这篇报告提供了几种找中位数的方法以及时间比较和实验计算的分析,并附有 C source code。这篇报告用的方法都是从没排序的数组中找第k小的数字,而找中位数只是这个问题的特殊化罢了。关键在于从不同的角度思考中位数的定义:

    The median of a list of N values has the property that in the list there are as many greater as smaller values than this element.

    对于找中位数这个特殊应用来说,这是一个很漂亮的出发点,值得学习。

    转载于:https://www.cnblogs.com/clive/archive/2009/09/14/Fast_Median_Search.html

    展开全文
  • 快速排序和寻找中位数复杂度分析

    千次阅读 2019-02-20 09:45:10
    之所以,起“快速排序和寻找中位数”这个题目,并不是因为寻找中位数的时候使用了快速排序,而是这两个算法使用了一个同一个预处理结构 —— 划分,然后都是递归解决!中位数的也是根据一个数把原来的数划分一下,...

    转载自:http://ilovers.sinaapp.com/article/快速排序和寻找中位数

    寻找中位数

    之所以,起“快速排序和寻找中位数”这个题目,并不是因为寻找中位数的时候使用了快速排序,而是这两个算法使用了一个同一个预处理结构 —— 划分,然后都是递归解决!中位数的也是根据一个数把原来的数划分一下,形成两部分。如果前半部分足够长,就在前部分找,否则在后半部分找!(这不仅适合中位数,实际上适合寻找第 k 大的数!!而 select_middle 其实不是来寻找中位数,是在寻找第 nth 大的数,如果 nth == (n+1)/2,这就是中位数!)

    select_middle(int *data, int start, int last, int nth); 说明:data 是数据,start 是起始位置,last 是最后一个数据的下一个位置,nth 指定要寻找第 nth 大的数!划分和快速排序是一模一样的,递归那部分也很简单,如果左半部分长就在左半部分找,如果右半部分长,就在右半部分找剩下的小一部分,比如 nth == 10,如果左边个数是 4,那么就在右边找第 6th 大的数!跟快速排序不同的是,递归只需要针对一部分处理!

    复杂度分析

    blog 还不能到此结束!O__O"…快速排序写起来不容易,插入排序、冒泡儿排序和简单选择排序,都很容易写出来丫,那 me 们为什么要花这么长时间写个快速排序呢?时间复杂度低?低在哪里?还有就是寻找中位数的程序,不,是寻找第 k 大数的程序,那样写有神马好处?它的复杂度能低于 O(nlogn) 吗?!基于划分的求 nth 大的数的那个程序,最坏情况是 O(n^2),平均是 O(n) ! O__O"…

    严格的分析是 me 不喜欢的,但是 me 也不希望太过于“想当然”。先看快速排序 —— 先划分再递归排序。当然有极端情况,有木有!比如 1 2 3 4 5 这样的,每次划分,一部分只有一个数据,另外一部分还是特别多,这样的话,递归要多少次呢?差不多 n 次吧?每递归一次对于数据还很多的那一部分差不多还需要 n 的重新划分吧,那么复杂度上限就是 O(n^2) 有木有!所以快速排序最坏情况的时间复杂度是 O(n^2) 。但是,最坏的情况,要么就是正向有序,要么就是逆向有序,而多数情况,可以想象(就权当是吧),每次划分,分成差不多相等的两部分,然后每一部分再处理,直到每一部分只有 1 个元素为止!如果用递推公式描述复杂度,可以用下图的第三个表示:

    T(n) = T(n/2)

    T(n) = 2T(n/2)

    T(n) = 2T(n/2) + n

    T(n) = T(n/2) + n

    如果最初是 8 个元素,第一次划分,大体是 4+4,第二次划分大体是 2+2,第三次是 1+1,递归深度是 log n 有木有!每次重新划分,就按 n 算,时间复杂度 O(nlogn) !那 O(nlogn) 是不是选择中位数的那个程序的时间复杂度呢?

    前面的四个式子,实际反应了四种情况,虽然看上去都是分治,然后递归解决!第一种情况是个神马情况呢?意思是处理 100 个数据,和处理其中 50 个数据是一样的!处理 50 个和处理其中的 25 个一样的!而这种划分,竟然没有代价,因为后面没有 + 任何东西!这样的话,想象一下,对于所有的 n,问题都可以转化为处理 1 个数据的情况,而且几乎不增加额外开销,那么复杂度就是 O(1) 丫,有木有!再看第三个式子,反映的是,需要 100 个工作量将 100 化成 50+50 的两部分,每一部分的 50 都要递归求解,所以是 2 倍丫!上面说了,复杂度是 O(nlogn),如果用式子看:T(8) = 2T(4) + 8 = 4T(2) + 2*4 + 8 = 8T(1) + 4*2 + 2*4 + 8 = 8 + 8 + 8 + 8 + 8 = 4*8,更通用有点:

    T(2^n) = 2^n + 2 (2^ n-1) + 4() + 8 () + ... + 2^n = (n+1)2^n,也就是 T(n) = (logn+1)n

    上面虽然是近似计算,但是已经能反映问题了。还有就是第二个式子和第四个式子反映的是神马情况?第二个式子反映,划分不需要代价,划分成两部分,两部分工作量再加在一起,O__O"… !给人感觉,这样的话,T(n) = n ! 有木有!比如 n = 8,T(8) = 2T(4) = 4T(2) = 8 T(1) = 8 ,这貌似是个线性时间!O__O"…

    第四个式子反映,需要 n 步将一个工作量为 n 的划分成两部分,后续只需要处理两部分中的一部分!没有 2 倍关系有木有!将递推式子迭代下去:

    T(n) = n + n/2 + n/4 + n/8 + ... + 1 = 2n !O__O"…,

    这是神马情况?!线性时间?系数是 2 ?!好吧,也就是说,如果真的能均匀划分的话,上面求中位数的程序的时间复杂度就是 O(n) ! 当然,实际上常量系数要高一些,不会仅仅只有 2 !

    寻找中位数题目因为每次划分后只需要处理其中的一半,另外一般不用管,所以应该用T(n) = T(n/2)计算时间复杂度。

    后话

    上面的程序和复杂度分析是 me 写的,而主要的算法思想等来自数据结构、算法(算法导论)和程序设计语言(c程序设计语言)。对于程序和复杂度分析,或是 blog 有其他错误的地方,不吝赐教丫,O__O"…对了,编程之美上有一道题,这里作为最后一个补充呈献上来:n 个数中,已知某个数出现的次数多于一半,请找出来这个数!为嘛留这个题了,貌似要找的数,一定是中位数有木有!!当然还有其他解法,而且复杂度可以降到 O(n),O__O"…

    展开全文
  • O(n)的时间复杂度求中位数

    千次阅读 2020-09-26 14:45:14
    在开始O(n)时间复杂度求中位数之前,先手写一下快速排序。 快速排序的实现 Reference: 快速排序|菜鸟教程 白话经典算法系列之六 快速排序 快速搞定 快速排序的原理 如果想正序排序一个序列: 从序列中找到一个 ...
     
    

    O(n)的时间复杂度求中位数

    O(n)中位数问题是指:在O(n)的时间复杂度内找到一个无序序列的中位数。

    在开始O(n)时间复杂度求中位数之前,先手写一下快速排序。

    快速排序的实现

    Reference:
    快速排序|菜鸟教程
    白话经典算法系列之六 快速排序 快速搞定

    快速排序的原理

    如果想正序排序一个序列:

    1. 从序列中找到一个 基准数
    2. 分区:将序列中比基准数大的数字都放到基准数的右边,将序列中比基准数小的数字都放在基准数的左边。
      • 此时,序列被分成了三部分: 左序列 + 基准数 + 右序列
      • 实现2的方法可以是 挖坑法
    3. 对左序列和有序列进行排序即可(递归),直到左/右序列长度为1

    快速排序的复杂度

    1. 时间复杂度:
      • 最好:O(nlogn)
      • 最坏:O(n^2)
      • 平均:O(nlogn)
    2. 空间复杂度:O(nlogn)
    3. 稳定性:不稳定

    快速排序的实现1

    void quick_sort(int a[], int left, int right){
        if (left >= right){
            return;
        }
        int l = left, r = right;
        int x = a[left]; // 选取当前序列最左边的数字为基准数
    
        while (l < r){
            while (l < r && a[r] >= x){
                r --;
            }
            if (l < r){
                a[l] = a[r];
                l ++;
            }
            while (l < r && a[l] < x){
                l ++;
            }
            if (l < r){
                a[r] = a[l];
                r ++;
            }
        }
        a[l] = x;
        quick_sort(a, left, l - 1);
        quick_sort(a, l + 1, right);
    }
    
    • 每一次快排都会确定一个位置,这个位置是l,大小是基准数
    • 如果我们想每一次都知道 快速排序确定的位置 ,那么可以写一个partition函数。(事实上,这是在为O(n)解决中位数问题做铺垫。)

    快速排序的实现2——partition函数

    int partition(int a[], int l, int r){
        int x = a[l];
        while (l < r){
            while (l < r && a[r] >= x){
                r --;
            }
            if (l < r){ 
                a[l] = a[r];
                l ++;
            }
            while (l < r && a[l] < x){
                l ++;
            }
            if (l < r){
                a[r] = a[l];
                r --;
            }
        }
        a[l] = x;
        return l;
    }
    
    void Q_sort(int a[], int l, int r){
        if (l < r){
            int index = partition(a, l, r);
            Q_sort(a, l, index-1);
            Q_sort(a, index+1, r);
        }
    }
    
    • partiton()负责将获得每一次进行步骤2:分区得到的基准数在最终递增序列中的 位置

    • Q_sort()中的index就是该位置。根据该位置将序列分为左右序列。

    有了partition函数,就可以实现O(n)时间复杂度找中位数的工作了。

    基于partition函数的O(n)中位数

    显然,如果没有O(n)的限制,那么一个直白的想法是:将无序序列排序,然后输出序列的 n/2个位置 的元素。

    • n是序列的长度。
    • 其实,对于中位数应该分情况讨论:
      • n 是奇数时,中位数是a[n/2]
      • n 是偶数时,中位数是(a[n/2] + a[n/2 - 1]) / 2.0

    上述算法的时间复杂度是O(nlogn)

    考虑到,对于partition函数,每一个可以确定一个位置! 那么,假设这个位置是index,那么对于中位数的位置pos:

    • 如果index = pos,显然,找到了中位数a[index]
    • 如果index > pos,显然,中位数位于区间[l, index-1]
      • 此时,只需对区间[l, index-1]再次进行partition操作即可。
    • 如果index < pos,显然,中位数位于区间[index+1, r]
      • 同上。

    根据上述思想,编写函数getMidNumber():

    int getMidNumber(int a[], int l, int r, int pos){
        while (true){
            int index = partition(a, l, r); // 获得基准数的位置
            if (index == pos){
                return a[index];
            }else if (index > pos){ // 只需要在[l, index-1]区间内找pos位置即可
                r = index - 1;
            }else { // 只需要在[index, r]区间内找pos位置即可
                l = index + 1;
            }
        }
        return -1; // 一般程序不会到这里
    }
    
    • 其中,pos的含义是中位数的位置:
      • 当序列长度为奇数时,pos = n/2
      • 当序列长度为偶数时,pos = n/2 或 n/2 - 1

    比如,可以编写如下代码测试:

    int main(){
        int a[] = {10, 8, 3, 5, 6, 2, 1, 7, 9, 4};
        int aLen = sizeof(a) / sizeof(int);
    
        if (aLen&1){
            cout << "Mid= " << getMidNumber(a, 0, aLen-1, aLen/2) << endl;
        }else{
            cout << "Mid= " << (getMidNumber(a, 0, aLen-1, aLen/2) + getMidNumber(a, 0, aLen-1, aLen/2-1)) / 2.0 << endl;
        }
    
        return 0;
    }
    
    • aLen是序列a的长度。

    时间复杂度分析

    最坏:O(n^2)

    • 假设一种极端情况,每一次选取的基准数都是序列中最小的那个数字,因此partition函数会依次返回0,1,2...n/2,每一次partition函数都需要O(n)的时间复杂度。因此,最坏的时间复杂度为O(n^2)

    最好: O(n)

    • 假设一种完美情况,第一次得到的基准数就是中位数,那么只需要执行一次partition函数,因此时间复杂度是O(n)

    平均: O(n)
    数学不好,证明不会。据 他们 说该算法的 期望 时间复杂度是O(n)
    这好像是涉及 主定理MasterTheorem。搜了好多网页博客也没看懂。

    Reference:
    主定理 Master Theorem

    拓展:找序列中第K大的数字

    其实找中位数就是找序列中第n/2大的数字。

    因此找需要调用getMidNumber(a, 0, aLen-1, k)即可找到序列中第k大的数字了。

    大佬的一种更简洁的写法

    O(n)求中位数和第k大数


    2020.9.26 14:41 周六

    展开全文
  • Spark如何求解中位数

    万次阅读 2020-05-29 14:36:02
    Python计算中位数 import numpy as np nums = [1.1,2.2,3.3,4.4,5.5,6.6] 均值 np.mean(nums) 中位数 np.median(nums) 在hive中没有直接提供相关的mean函数,但官方提供了两个UDAF,percentile和percentile_...
  • 先理解快速排序。 int partition(int L[],int low,int high) { int i,num=low; for(i=low+1;i<=high;i++) { if(L[i]<L[low]) { swap(&L[i],&L[num+1]); num++; } } swap(&L...
  • 求一个无序数组的中位数

    千次阅读 2017-08-04 23:13:05
    问题描述求一个无序数组的中位数。 如:{2,5,4,9,3,6,8,7,1}的中位数为5,{2,5,4,9,3,6,8,7,1,0}的中位数为4和5。 要求:不能使用排序,时间复杂度尽可能低。 提示:考虑堆或者快排思想解决方法1:堆思路1: 分析...
  • 算法导论—中位数与顺序统计量

    万次阅读 2015-07-07 23:17:29
    天津大学认知计算与应用重点实验室 日期:2015/7/7 一、选择最大值或者最小值的最优算法 对于长度为n的数组,已证找最大值或者最小值比较操作下界就是n-1。所以只需要让第一个值为初始最大值或者初始最小值,用...
  • 说明:这是武汉理工大学计算机学院【算法设计与分析】课程的第一次实验第一题:分治法与中位数问题 >>点击查看WUTer计算机专业实验汇总 谨记:纸上得来终觉浅,绝知此事要躬行。 一、问题描述 输入任意一...
  • 漫画:如何找到两个数组的中位数

    千次阅读 多人点赞 2019-07-29 08:48:00
    如上图所示,对于偶数长度的数组,可以根据中位数分成长度相等的两部分,左半部分最大元素(6),永远小于等于右半部分的最小元素(7)。 对于奇数长度的数组,同样可以根据中位数分成两部分: 如上图所示,对于奇数...
  • 找出一个无序数组的中位数

    万次阅读 热门讨论 2017-08-04 14:01:25
    找出一个无序数组的中位数
  • 数组-中位数-简单

    千次阅读 2018-06-03 18:59:41
    中位数是排序后数组的中间值,如果数组的个数是偶数个,则返回排序后数组的第N/2个数。样例给出数组[4, 5, 1, 2, 3], 返回 3给出数组[7, 9, 4, 5],返回 5挑战时间复杂度为O(n)题目链接分析先排序,再判断数组长度...
  • 之所以,起“快速排序和寻找中位数”这个题目,并不是因为寻找中位数的时候使用了快速排序,而是这两个算法使用了一个同一个预处理结构 —— 划分,然后都是递归解决!中位数的也是根据一个数把原来的数划分一下,...
  • 本博文源于matlab基础,主要讲述常用统计量的计算包括均值、中位数、极差、方差和标准差。
  • 中位数, 就是数值中间的那个数,不是平均数。 例如1,2,99 的中位数是2 而平均数是342 巨大数组,当看到这个时,就不要再简单的用排序法了。 排序确实解决了问题,但其它确实存在大量的多余的计算。对性能的...
  • 或许当你看到一行代码的...)就像进行数据处理的时候,有时会遇到求极值(最大值、最小值)、平均值、中位数和四分位数(25%、 75%)的情况。 这一篇博客就是你的福音,让你绝对0基础使用python 进行数据分析。 ...
  • Python语言的缩进在程序长度统一且强制使用,只要统一即可,不一定是4个空格(尽管这是惯例) IPO模型指:Input Process Output 字符串的正向递增和反向递减序号体系:正向是从左到右,0到n-1,反向是从右到左...
  • 快速计算32位数1的位数 Sailor_forever sailing_9806@163.com 转载请注明http://blog.csdn.net/sailor_8318/archive/2008/10/12/3059935.aspx 一语句实现x是否为2的若干次幂的判断#define is2*n(x) ((x & (x - ...
  • 中位数: np.median(arr) 排序: (1) np.sort(arr, axis, kind, order) 或 arr.sort() :在原数组上进行排序 参数说明: a. 参数axis:默认值为1,即以行为单位从小到大排序 b. 参数kind:...
  • 内存足够:将所有整数加载进内存,类似于快速排序的思路,选取某个整数,将整个数组分为两部分,即此数左边全部小于这个,右边全部大于此数,计算左右两边的数的个数后,重新选择区间然后重复递归,直到找到中位数。...
  • 斐波那契数列介绍及Python五种方法斐波那契数列

    万次阅读 多人点赞 2018-10-31 20:07:28
    # num1用来保存前前一个,初始值为数列的第一个0 self . num1 = 0 # num2用来保存前一个,初始值为数列的第二个1 self . num2 = 1 def __next__ ( self ) : """被next()函数调...
  • 【算法】中位数 median

    千次阅读 2014-04-26 22:23:39
    median 是 STL 内部的算法,用于求三个数的中位数,它将用于 std::sort, std::nth_element 的实现中,快速排序和求第 k 小数算法都用到了划分,选取 pivot 时为“三者取中”,即 *first, *(first + (last - first) /...
  • 算法 求最小值,最大值,中位数
  • 入门学习Linux常用必会60个命令实例详解doc/txt

    千次下载 热门讨论 2011-06-09 00:08:45
    -n:一般而言,mount挂上后会在/etc/mtab写入一笔资料,在系统没有可写入文件系统的情况下,可以用这个选项取消这个动作。 4.应用技巧 在Linux 和Unix系统上,所有文件都是作为一个大型树(以/为根)的一部分...
  • 求无序数组的中位数

    万次阅读 2009-10-15 18:53:00
    中位数即是排过序后的处于数组最中间的元素。 不考虑数组长度为偶数的情况。设集合元素个数为n。 简单的想了下: 思路1) 把无序数组排好序,取出中间的元素  时间复杂度 采用普通的比较排序法 O(N*logN)  ...
  • Python快速编程入门课后程序题答案

    万次阅读 多人点赞 2019-06-19 23:17:45
    本文只是简单的整理了一下课后习题的编程题,具体的填空、选择、判断可以见:Python快速编程入门课后习题答案 第一章 1、编写一个Python程序,输出如下图效果。 ++++++++++ + + ++++++++++ print("+++++++++++...
  • 基本思路:中位数就是排序后下标为数组长度/2的元素  这里,可以采用快速排序的思路(详细快速排序不多介绍,可参考这里)。即将不断地划分为左右两个区域,左边区域内的所有元素都小于某个主元,右边区域内的元素...
  • 中位数计算时,我们要先把需要计算平均数的所有数值排序,然后取出排序处在中间的那个数字,作为这个数据序列的平均数。若数据有偶数个,比如10个,我们找不到排序在中间的数字,那么就取排在中间两位的数字,比如...
  • public static void main(String[] args) { Scanner scan = new Scanner(System.in); System.out.println("请输入一个三位数"); int n = scan.nextInt(); //计算百位 十位 各位 int b100 =n/1...
  • 求多个有序数组的中位数

    万次阅读 2012-09-15 10:57:47
    题目:求解多个有序数组的中位数 题目的意思是如果多个有序数组能在一起排序,则取位置为中间的数字,如果有奇数个数字则中位数只有一个;若为偶数个则有两个,一般取第一个,也称下中位。但不能把数组合在一起...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 266,475
精华内容 106,590
关键字:

怎么快速计算中位数