内存只能容纳100W个数,
现在有1亿数,混序,
然后求这一亿个数的中位数,
中位数(就是一个有序数组的中间数字,数组长度为偶数就是两个,奇数则只有一个)
/*****************************************************************************/
/* this program should find out the median(s) in N(logN)/(logB) no matter there
/* is duplicated data or not.
/*
/* with memory limitation: 4MB memory available.
/* I would like to express the idea with code.
/* here is just the pseudocode with out any optimization for easy understanding.
/*
/* maybe, there is no need to check sum == N/2 or N/2+1, but this will get the
/* median(s) as soon as possible with out more recursive invoking.
/*
/* sorry for any logical problem. please let me know if you found any.
/*****************************************************************************/
int N = 100000000;// total data number is N
int B = 1000000; // number of buckets.
int min, max;
scan data from 0 to N-1 get min and max; // O(N);
void find_median(int num=0, int min, int max)
{
if(min == max) {
if(N%2) {
print medians are min and max;
}
else print median is min; // show you the result
return; // exit
}
/* count all the data in O(N)*/
int m = max-min > B ? (max-min) / B : 1;
int cnt[B] = {0}; // count the data read.
while(!EOF) {
int data = read_data()-min;
if(data >= min && data <= max) cnt[data/m]++;
}
int sum = num, median_1, median_2, i = 0;
while(sum < N/2) sum += cnt[i++];
i--; // median is in the range of [i*m, (i+1)*m-1]
/* get median(s) when sum is N/2 */
if(sum == N/2) {
if(N%2) { // N is even and there are two medians.
median_1 = (i+2)*m-1;
median_2 = i*m;
while(!EOF) {
int data = read_data()-min;
if(data/m == i) {
median_2 = (data > median_2 ? data : median_2);
}
if(data/m == i+1) {
median_1 = (data < median_1 ? data : median_1);
}
}
pintf medians are median_1 and median_2;
return;
}
}
else { // N is an odd number and there is one median.
median_1 = (i+2)*m-1;
while(!EOF) {
int data = read_data();
if(data/m == i+1) median_1 = (data < median_1 ? data : median_1);
}
print median is median_1;
return;
}
/* get median(s) when sum is N/2+1 */
if(sum == N/2+1) {
if(N%2) { // N is even and there are two medians.
median_1 = i*m;
median_2 = i*m;
while(!EOF) {
int data = read_data();
if(data/m == i) {
median_1 = max;
median_2 = (data > median_2 ? data : median_2);
}
}
pintf medians are median_1 and median_2;
return;
}
}
else {
median_2 = i*m; // get (N/2+1)th data.
while(!EOF) {
int data = read_data();
if(data/m == i) median_2 = (data > median_2 ? data : median_2);
}
print median is median_2;
return;
}
/* recursively to find out the median(s) */
min = (i+1)*m-1;
max = i*m;
// get min and max for next processing
while(!EOF)
{
int data = read_data()-min;
if(data/m == i)
{
min = (data < min ? data : min);
max = (data > max ? data : max);
}
}
find(min, max);
}
找<em>中位数</em>最容易想到的方法就是，先对序列进行排序，取<em>中位数</em>，然而5亿<em>个数</em>要想全部读入内存需要将近2GB空间。 一种想法是采用外部排序的方法，在排序的过程中记录数据<em>个数</em>，找到<em>中位数</em>。首先采用hash() % 100,把数据分到100个文件中，然后对每个文件分别在内存中进行快速排序，再将100个小文件进行合并，并在合并过程中寻找<em>中位数</em>，时间复杂度是O(nlogn) 另外一种方法是，将数据按照数据空间...
一、选择法排序、冒泡排序、插入法排序 二、快速排序、分治法排序、堆排序 三、计数排序、基数排序、桶排序 gtest介绍及测试用例如下：测试框架之GTest MIT《<em>算法</em>导论》下载：hereorhttp://download.csdn.net/detail/ceofit/4212385 源码下载：here orhttp://download.csdn.net/detail/ceofit/4
n个无序整数，<em>求</em>第K大或者前K大的数（不要<em>求</em>排序输出，找到就行），时间复杂度为O（n），各位有什么好的想法吗？ 进一步如果要<em>求</em>排序输出的话，最好的时间复杂性是多少？
bfprt<em>算法</em>及其相关 找到无序数组中最小的K<em>个数</em> 【题目】 给定一个无序的整型数组arr，找到其中最小的k<em>个数</em>。 【要<em>求</em>】 如果数组arr的长度为N，排序之后自然可以得到最小的k<em>个数</em>，此时时间复杂度为排序的时间复杂度即O(N*logN)。本题要<em>求</em>读者实现时间复杂度O(N*logK)和O(N)的方法。 利用堆： public int[] getMinKNumsByHeap
类似于快速排序那种，只不过另加处理一番。 附上代码： #include&lt;bits/stdc++.h&gt; using namespace std; const int maxn=1e2+5; int n,a[maxn]; double select_middle(int beg,int end) { if(n==1)return a[0]; int i=beg; ...
时间复杂度为O(n)的找<em>中位数</em><em>算法</em>源代码
题目：在一个文件中有 10G 个整数，乱序排列，要<em>求</em>找出<em>中位数</em>。内存限制为 2G。只写出思路即可（内存限制为 2G的意思就是，可以使用2G的空间来运行程序，而不考虑这台机器上的其他软件的占用内存）。 分析： 既然要找<em>中位数</em>，很简单就是排序的想法。那么基于字节的桶排序是一个可行的方法 （请见《桶排序 》）： 思想：将整形的每1byte作为一个关键字，也就是说一个整形...
线行查找<em>算法</em>原理、步骤和Java实现
部分背包问题： 一个窃贼去一家商店偷窃，有n件商品： 第i件物品值Vi元，重wi榜（vi, wi都是整数），他的背包最多只能装下W榜物品， 每件商品他可以选择一部分带走，而不是像0-1背包问题。问他最多能带走多贵的物品？ 分析： 由于部分背包问题允许仅拿走物品的一部分，物件更像是金粉，可证明其具有贪心的性质。 <em>算法</em>1： 贪心 按照每榜的价值进行排序，然后由价值的大小依次往包里装，
/** * 堆结构实时<em>求</em><em>中位数</em> */ public class Test02ByMedian { @Test public void test(){ int [] arr={9,75,6,4,3}; System.out.println(go(arr)); } public int go(int []arr){ ...
一：背景介绍在一大堆数中<em>求</em>其前k大或前k小的问题，简称TOP-K问题。而目前解决TOP-K问题最有效的<em>算法</em>即是BFPRT<em>算法</em>，其又称为<em>中位数</em>的<em>中位数</em><em>算法</em>，该<em>算法</em>由Blum、Floyd、Pratt、Rivest、Tarjan提出，最坏时间复杂度为O(n)。在首次接触TOP-K问题时，我们的第一反应就是可以先对所有数据进行一次排序，然后取其前k即可，但是这么做有两个问题： （1）：快速排序的平均复杂度...
通常，我们需要在一大堆数中<em>求</em>前K大的数，或者<em>求</em>前K小的。比如在搜索引擎中<em>求</em>当天用户点击次数排名 前10000的热词；在文本特征选择中<em>求</em>IF-IDF值按从大到小排名前K个的等等问题，都涉及到一个核心问 题，即TOP-K问题。 通常来说，TOP-K问题可以先对所有数进行快速排序，然后取前K大的即可。但是这样做有两个问题。 （1）快速排序的平均复杂度为，但最坏
目录 步骤 BFPRT<em>算法</em>的作者是5位真正的大牛（Blum 、 Floyd 、 Pratt 、 Rivest 、 Tarjan）。 BFPRT解决的问题十分经典，即从某n个元素的序列中选出第k大(第k小)的元素，通过巧妙的分析，BFPRT可以保证在最坏情况下仍为线性时间复杂度。 回到顶部 步骤 将n个元素每 5 个一组，分成n/5(上界)组。 取出每一组的<em>中位数</em>，任意排序方法，比如插入排序。 递归...
原文连接：http://noalgo.info/466.htmlBFPRT<em>算法</em>，又称为<em>中位数</em>的<em>中位数</em><em>算法</em>，由5位大牛（Blum 、 Floyd 、 Pratt 、 Rivest 、 Tarjan）提出，并以他们的名字命名。参考维基上的介绍Median of medians。<em>算法</em>的思想是修改快速选择<em>算法</em>的主元选取方法，提高<em>算法</em>在最坏情况下的时间复杂度。其主要步骤为：首先把数组按5<em>个数</em>为一组进行分组，最
vs.net->新建项目->C#->数据库项目->新建一个聚合函数 using System; using System.Data; using System.Data.SqlClient; usin
<em>中位数</em>（Median） 1、定义：一组数据按从小到大（或从大到小）的顺序依次排列，处在中间位置的一<em>个数</em>（或最中间两<em>个数</em>据的平均数，注意：和众数不同，<em>中位数</em>不一定在这组数据中）。 注：当<em>个数</em>为基数时，取最中间位置的数；当<em>个数</em>为偶数时，取最中间两<em>个数</em>的平均数。 2、从小到大排序，可以先用冒泡排序，然后取<em>中位数</em>，那么先看下冒泡排序<em>算法</em>，代码如下： ? pu
题目 题目来源：Link 代码 1、方法一 package com.graph; import java.util.*; public class Solution{ PriorityQueue minHeap = new PriorityQueue(Collections.reverseOrder()); PriorityQueue maxHeap = new P
<em>算法</em> <em>求</em>n<em>个数</em>的<em>中位数</em> C
原帖链接 一、以期望线性时间做选择 一般来说，<em>中位数</em>的查找<em>算法</em>都是基于先排序，后找中间位置的数字的<em>算法</em>，但是因为线性时间排序所收到的限制比较大，而如果使用基于比较的排序，时间复杂度将至少为O(nlogn)，如何以线性时间完成<em>中位数</em>或者数组中第N大元素的查找呢？ 快速排序<em>算法</em>在每一次局部递归后都保证某个元素左侧的元素都比他小，右侧的元素都比她大，因此，可以利用这个思路快速找
序列中的<em>中位数</em>
此题在leetcode中评级为hard，目的是在O(log(m+n))的时间复杂度情况下解决问题。用常规O(m+n)的<em>算法</em>很容易<em>求</em>得结果，但 显然不符合时间复杂度的要<em>求</em>。因此，这道题的解题分析主要还是利用分治<em>算法</em>去考虑，这也是本题的难点所在。 一、原题叙述 There are two sorted arrays nums1 and nums2 of size m and n respec
如今博主在上<em>算法</em>设计与分析这门课，前两天刚讲到了分治法。 下面照搬一下教材《<em>算法</em>设计与分析》（第2版，王红梅、胡明 编著）分治法的设计思想概述。 分治者，分而治之也。 分治法（divide and conquer method）将一个难以直接解决的发问题划分成一些规模较小的子问题，分别<em>求</em>解各个子问题，再合并子问题的解得到原问题的解。一般来说，分治法的<em>求</em>解过程由以下三个阶段组成： 划分：把规模为
设计一<em>个数</em>据结构，可动态地维护一组数据，且支持如下操作： （1）添加元素：void addNum(int num) （2）返回这组数据中的<em>中位数</em> double findMedian() 【思考】如何获取一组元素的<em>中位数</em> （1）首先，我们马上想到的方法，最直观的方法就是：添加元素的同时进行排序操作（直插sort）addNum的复杂度是O(n)，findMedian的复杂度则是O(1)； （...
BFPRT<em>算法</em>解决的问题十分经典，即从某n个元素的序列中选出第k大（第k小）的元素，通过巧妙的分析，BFPRT可以保证在最坏情况下仍为线性时间复杂度。该<em>算法</em>的思想与快速排序思想相似，当然，为使得<em>算法</em>在最坏情况下，依然能达到o(n)的时间复杂度，五位<em>算法</em>作者做了精妙的处理。 <em>算法</em>步骤： 1.将n个元素每5个一组，分成n/5(上界)组。 2.取出每一组的<em>中位数</em>，任意排序方法，比...
Top K <em>算法</em>详解 应用场景： 搜索引擎会通过日志文件把用户每次检索使用的所有检索串都记录下来，每个查询串的长度为1-255字节。 假设目前有一千万个记录（这些查询串的重复度比较高，虽然总数是1千万，但如果除去重复后，不超过3百万个。一个查询串的重复度越高，说明查询它的用户越多，也就是越热门。），请你统计最热门的10个查询串，要<em>求</em>使用的内存不能超过1G。
<em>算法</em>一：快速排序<em>算法</em> 快速排序是由东尼·霍尔所发展的一种排序<em>算法</em>。在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) <em>算法</em>更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。 快速排序使用分治法（Divide and conquer）策略来把一
有客户号USER_ID，客户名称USER_NAME，合同号CONTRACT_NO，和更新时间UPDATE_DATE字段。 如果客户号，客户名称，合同号三者相同则视为同一条信息。 查询要<em>求</em>得到不同信息的
现在从Ultiums的表里面查询一些流程数据，现在只要筛选不同的步骤。所以只需要筛选STEPID不同的项目， 表的结构如下 尝试过 WHERE EXISTS 的方法 不过效率比较低，大概存储10w的数
问题我发在这里了，没找到满意的答案。
例如 数据为 表 a id name 1 张三 1 李四 2 张三 2 李四 这里id不唯一 <em>求</em>查出 结果为 id name 1 张三 2 李四 我有个查询是 select id,max(name)a
我的SQL是这样写的 String sql = "select * from article where title like '%?%' order by id desc"; 然后运行就抛出空指针异
BFPRT(线性查找<em>算法</em>)
线性查找<em>算法</em> 定义 BFPRT <em>算法</em>解决的问题十分经典，即从某n个元素的序列中选出第k大（第k小）的元素，通过巧妙的分析，BFPRT 可以保证在最坏情况下仍为线性时间复杂度。该<em>算法</em>的思想与快速排序思想相似，当然，为使得<em>算法</em>在最坏情况下，依然能达到o(n)的时间复杂度，五位<em>算法</em>作者做了精妙的处理。 步骤 1.将n个元素每 5 个一组，分成n/5(上界)组。
BFPRT<em>算法</em>的Python实现
top-K 问题是一类经典的问题，它能解决许多海量数据处理相关的问题，例如在1亿个ip中找出访问次数前1000的ip，在海量搜索字符串中找出搜索频率排在前十的搜索字符串等等。下面我们由浅入深对其进行分析。 我们可以将这类问题分为三个方向考虑： 1.将输入内容（假设用数组存放）进行完全排序，从中选出排在前K的元素即为所<em>求</em>。有了这个思路，我们可以选择相应的排序<em>算法</em>进行处理，目前来看
线性查找<em>算法</em>，即从某n个元素中选取第k大（或者第k小）的元素，BFPRT<em>算法</em>可以保证在最坏的情况下仍然为线性时间复杂度O(n)，该<em>算法</em>与快速排序及其相似， 在BFPTR<em>算法</em>中，仅仅是改变了快速排序Partion中的pivot值的选取，在快速排序中，我们始终选择第一个元 素或者最后一个元素作为pivot，而在BFPTR<em>算法</em>中，每次选择五分<em>中位数</em>的<em>中位数</em>作为pivot，这样做的目的 就是使得划分
之前刚刚实现了快速排序<em>算法</em>。现在还有一个要<em>求</em>就是找到一个序列中第K大的数。我们当然可以用先排序再取值的方法来做，这样的时间复杂度为O(NlogN)。或者使用heap_sort，或者优先队列，则复杂度是O(NlogK)。那么有没有一种更加高效的方式呢？答案是肯定的。可以使用快速排序的一个变种quick_select，则平均复杂度为O(N)，最坏复杂度为O(N^2)。<em>算法</em>思想通过一趟快排过后，序列将被分
BFPRT<em>算法</em>的作者是5位真正的大牛（Blum 、 Floyd 、 Pratt 、 Rivest 、 Tarjan），该<em>算法</em>入选了在StackExchange上进行的当今世界十大经典<em>算法</em>，而<em>算法</em>的简单和巧妙颇有我们需要借鉴学习之处。 BFPRT解决的问题十分经典，即从某n个元素的序列中选出第k大（第k小）的元素，通过巧妙的分析，BFPRT可以保证在最坏情况下仍为线性时间复杂度。 当我们面对
在文章开头先了解随机快速排序，随机排序之前博文中有，在此增加快速排序中partition函数，参照http://www.cnblogs.com/sdlwlxf/p/5131793.html Master公式：用于算复杂度 此公式只适用于每次递归量相同的情况，可以简化理解为一下过程： a表示递归的次数，b表示递归规程中每次递归缩小是的数据量，n^d为递归后续行为的复
最近学习了左神BFPRT<em>算法</em>，给大家先讲个段子。 左神说他每次去美国面试，他都会拿BFPRT<em>算法</em>吹一吹。美国5个大佬在一个美丽的地方研究出来这个<em>算法</em>，他说自己热爱<em>算法</em>，他会BFPRT，每次去美国都会怀着朝圣的姿态去在那个地方转转。面试官一听：哇,这么厉害，过！！！！！！！ 好了，下来说说这个<em>算法</em>。 BFPRT<em>算法</em>是在进行大量数据排序<em>求</em>topk(前k个最大或最小的数）时最优<em>算法</em>。 为...
这个问题其实是由下面这个问题引入的： 从20亿<em>个数</em>字的文本中，找出最大的前100个。 这个问题的比较好的解决方法就是，维护 k 个元素的小根堆，用容量为 k 的最小堆存储最先遍历到的 k <em>个数</em>，并假设它们即是最大的 k <em>个数</em>，建堆费时O（k）后，假如 k1 为根，那么有 k1 就是这 k 个元素中最小的元素）。继续遍历数列，每次遍历一个元素x，与堆顶元素比较，x>k1，更新堆（用时logk），否
1、在一个无序数组找出第k小的数，经典<em>算法</em>：
1) 5<em>个数</em>一组2) 每组排序3) 新建数组存放每组的<em>中位数</em>4) 递归<em>求</em>new_array的<em>中位数</em>p5) 用p来进行partition划分6) 若命中, 返回; 若未命中, 按左部分或右部分递归计算.如下图 : 25<em>个数</em>分5组, <em>中位数</em>p 至少大于 十分之三N的数...
转载地址： https://mp.weixin.qq.com/s/U70cJ0fKpcjiDOe0ZeBS2w BFPRT<em>算法</em>解决的问题十分经典，即从某n个元素的序列中选出第k大（第k小）的元素，通过巧妙的分 析，BFPRT可以保证在最坏情况下仍为线性时间复杂度。该<em>算法</em>的思想与快速排序思想相似，当然，为使得<em>算法</em>在最坏情况下，依然能达到o(n)的时间复杂 度，五位<em>算法</em>作者做了精妙的处理。 ...
BFPRT<em>算法</em>O(n)解决第k小的数 我们通常会简单地进行一个快速排序后，得到第k个位置上的数字即可。 我们都知道的是快速排序是个不稳定的排序，它的排序过程简单的理解主要是两个概念Partion,pivot(基准数) 一趟快速排序的过程如下 先从序列中选取一<em>个数</em>作为基准数 将比这<em>个数</em>大的数全部放到它的右边，把小于或者等于它的数全部放到它的左边 一趟快速排序也叫做Partion...
第一章 数据库管理 2 1.1 数据库管理概述 2 1.2 数据库日常管理说明 3 1.3 高级管理方法 3 1.3.1 为数据库分配硬盘空间和卷组 4 1.3.2 创建用户组和用户 4 1.3.2.1 创建用户组 5 1.3.2.2 创建用户 5 1.3.3 配置服务端口 6 1.3.4 创建实例 6 1.3.5 空间管理 7 1.3.5.1 系统空间管理 7 1.3.5.2 创建表空间 8 1.3.6 建库 8 1.3.6.1 建立基本数据库 8 1.3.6.2 建立表和索引 8 1.3.6.3 建立约束及触发器 10 1.3.6.4 建立视图 11 1.3.6.5 删除数据库 11 1. 相关下载链接：[url=//download.csdn.net/download/waterlz/2132658?utm_source=bbsseo]//download.csdn.net/download/waterlz/2132658?utm_source=bbsseo[/url]
简单又快捷。 简单又快捷。 简单又快捷。 简单又快捷。 相关下载链接：[url=//download.csdn.net/download/ml244897340/4313158?utm_source=bbsseo]//download.csdn.net/download/ml244897340/4313158?utm_source=bbsseo[/url]
c语言编译器全部源码贡献，为学习编译或是提高编程能力都有极大的帮助 相关下载链接：[url=//download.csdn.net/download/gavlin/1243608?utm_source=bbsseo]//download.csdn.net/download/gavlin/1243608?utm_source=bbsseo[/url]
