【本文链接】

http://www.cnblogs.com/hellogiser/p/bitmap-vs-2bitmap.html

【题目】

在2.5亿个整数找出不重复的整数，内存不足以容纳着2.5亿个整数

【分析】

Bitmap就是用一个bit位来标记某个元素是否存在，而2Bitmap就是用两个bit为来标记某个元素的个数，00，01，10，11（分别表示0，1，2，3，0表示不存在，1表示存在1次，后面依次）。

整数可能是正数也可能是负数，首先只考虑正整数情况，采用2Bitmap方法，用00表示不存在，01表示出现1次，10表示出现2次及以上，此方法总共需要的内存2^31*2bit = 1Gb = 128MB（32位的正整数有2^31个，每个存储需要2bit，所以就是1Gb，换成字节就是128MB），这样内存就应该能够容纳了，最后在处理完所有的数后，只要输出对应位为01的数即可。如果这2.5亿个数里面既有正数又有负数那么就用两个2Bitmap分别存储正数和负数（取绝对值存储），零就随便放，所需要的内存是512MB。

【代码】

 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
  
/*
version: 1.0
author: hellogiser
blog: http://www.cnblogs.com/hellogiser
date: 2014/10/8
*/

#include "stdafx.h"
#include <iostream>
using namespace std;

class BitSet
{
public:
    BitSet (int range)
    {
        // [0,range)
        m_nRange = range;
        m_nLength = m_nRange / ;

bitset = new int[m_nLength];
        // init all with 0
; i < m_nLength; i++)
        {
            bitset[i] = ;
        }
    }

~BitSet()
    {
        delete []bitset;
    }

void Set(int number)
    {
        ;
        ;
        bitset[i] |= ( << j);
    }

int Get(int number)
    {
        ;
        ;
         << j)) >> j;
    }

void Output()
    {
        ; i < m_nRange; i++)
        {
            if (Get(i))
            {
                cout << i << " ";
            }
        }
        cout << endl;
    }
private:
    int *bitset;
    int m_nRange; // range of numbers
    int m_nLength; // len of array
};

class BitSet1
{
public:
    BitSet1 (int range)
    {
        // [0,range)
        //default value
;
        m_nWord =  / m_nBitWidth;

m_nRange = range;
        m_nLength = m_nRange / m_nWord + ;

bitset = new int[m_nLength];
        // init all with 0
; i < m_nLength; i++)
        {
            bitset[i] = ;
        }
    }

~BitSet1()
    {
        delete []bitset;
    }

void Set(int number)
    {
        int i = number / m_nWord;
        int j = number % m_nWord;
        bitset[i] |= ( << j);
    }

void Clear(int number)
    {
        int i = number / m_nWord;
        int j = number % m_nWord;
        bitset[i] &= ~( << j);
    }

int Get(int number)
    {
        // return count of number
        int i = number / m_nWord;
        int j = number % m_nWord;
         << j)) >> j;
    }

void Output()
    {
        ; i < m_nRange; i++)
        {
            if (Get(i))
            {
                cout << i << " ";
            }
        }
        cout << endl;
    }
private:
    int m_nBitWidth;// 1 2 3
    int m_nWord; // word = 32/BitWidth
    /*  1: 0,1
        2: 00,01,10,11
        3: 000,...111
    */

int *bitset;
    int m_nRange; // range of numbers
    int m_nLength; // len of array
};

class BitSet2
{
public:
    BitSet2 (int range)
    {
        // [0,range)
        //default value
;// 1,2,3
 / m_nBitWidth; //32, 16,8
 << m_nBitWidth; //1,3,7

m_nRange = range;
        m_nLength = m_nRange / m_nWord + ;

bitset = new int[m_nLength];
        // init all with 0
; i < m_nLength; i++)
        {
            bitset[i] = ;
        }
    }

~BitSet2()
    {
        delete []bitset;
    }

void Add(int number)
    {
        int count = Get(number);
        __Set(number, count + );
    }

void __Set(int number, int count)
    {
        )
            return;
        //clear first
        Clear(number);

// then set
        int i = number / m_nWord;
        int j = number % m_nWord;
        bitset[i] |= (( * j);
    }

void Clear(int number)
    {
        int i = number / m_nWord;
        int j = number % m_nWord;
        bitset[i] &= ~( * j));
    }

int Get(int number)
    {
        // return count of number
        int i = number / m_nWord;
        int j = number % m_nWord;
         * j);
    }

void Output()
    {
        ; i < m_nRange; i++)
        {
            if (Get(i))
            {
                cout << i << " ";
            }
        }
        cout << endl;
    }
private:
    int m_nBitWidth;// 1 2 3
    int m_nWord; // word = 32/BitWidth
    /*  1: 0,1
        2: 00,01,10,11
        3: 000,...111
    */
    int m_nMaxCount; // 1,11,111===>1,3,7

int *bitset;
    int m_nRange; // range of numbers
    int m_nLength; // len of array
};

void test_default1(int *a, int len, int range)
{
    cout << "===Bitset1===" << endl;
    BitSet1 bs1(range);
    ; i < len; i++)
    {
        bs1.Set(a[i]);
    }

; i < range; i++ )
    {
        cout << i << " count = " << bs1.Get(i) << endl;
    }
}

void test_case1()
{
    };
    ;
    test_default1(a, , range);
}

void test_default2(int *a, int len, int range)
{
    cout << "===Bitset2===" << endl;
    BitSet2 bs2(range);
    ; i < len; i++)
    {
        bs2.Add(a[i]);
    }

; i < range; i++ )
    {
        cout << i << " count = " << bs2.Get(i) << endl;
    }
}

void test_case2()
{
    };
    ;
    test_default2(a, , range);
}

int main()
{
    test_case1();
    test_case2();
    ;
}
/*
===Bitset1===
0 count = 0
1 count = 1
2 count = 1
3 count = 1
4 count = 1
5 count = 1
6 count = 0
7 count = 1
8 count = 1
9 count = 0
===Bitset2===
0 count = 0
1 count = 1
2 count = 2
3 count = 3
4 count = 3
5 count = 1
6 count = 0
7 count = 1
8 count = 1
9 count = 0
*/

【其它题目】

1.给40亿个不重复的unsigned int的整数，没排过序的，然后再给几个数，如何快速判断这几个数是否在那40亿个数当中?

unsigned int 的取值范围是0到2^32-1。我们可以申请连续的2^32/8=512M的内存，用每一个bit对应一个unsigned int数字。首先将512M内存都初始化为0，然后每处理一个数字就将其对应的bit设置为1。当需要查询时，直接找到对应bit，看其值是0还是1即可。

2.有1到10w这10w个数，去除2个并打乱次序，如何找出那两个数？
申请10w个bit的空间，每个bit代表一个数字是否出现过。开始时将这10w个bit都初始化为0，表示所有数字都没有出现过。然后依次读入已经打乱循序的数字，并将对应的bit设为1。当处理完所有数字后，根据为0的bit得出没有出现的数字。

【参考】

http://blog.csdn.net/jirongzi_cs2011/article/details/9331003

http://www.cnblogs.com/pangxiaodong/archive/2011/08/14/2137748.html

http://blog.csdn.net/acceptedxukai/article/details/9025493

http://blog.csdn.net/zhulei632/article/details/6701868

Bitmap vs 2Bitmap的实现的更多相关文章

  1. Android canvas.save()与canvas.restore()的使用总结

    含义canvas.save(); 画布将当前的状态保存canvas.restore(); 画布取出原来所保存的状态使用 canvas.save();与canvas.restore();一般结合使用,. ...

  2. 大数据处理-bitmap是个神马东西

    1. Bit Map算法简介 所谓的Bit-map就是用一个bit位来标记某个元素对应的Value, 而Key即是该元素.由于采用了Bit为单位来存储数据,因此在存储空间方面,可以大大节省. 2. B ...

  3. 海量数据处理算法—Bit-Map

    原文:http://blog.csdn.net/hguisu/article/details/7880288 1. Bit Map算法简介 来自于<编程珠玑>.所谓的Bit-map就是用一 ...

  4. 3.bit-map

    适用范围:可进行数据的快速查找,判重,删除,一般来说数据范围是int的10倍以下 基本原理及要点:使用bit数组来表示某些元素是否存在,比如8位电话号码 扩展:bloom filter可以看做是对bi ...

  5. BitMap位图与海量数据的理解

    1. Bit Map算法简介 来自于<编程珠玑>.所谓的Bit-map就是用一个bit位来标记某个元素对应的Value, 而Key即是该元素.由于采用了Bit为单位来存储数据,因此在存储空 ...

  6. 海量数据处理之BitMap

    有这样一种场景:一台普通PC,2G内存,要求处理一个包含40亿个不重复并且没有排过序的无符号的int整数,给出一个整数,问如果快速地判断这个整数是否在文件40亿个数据当中? 问题思考: 40亿个int ...

  7. 位图法bitmap

    1.概念 1)所谓bitmap,就是用每一位(bit)来标记某个元素对应的value, 而key即是该元素,通常bitmap是一个int数组,用每一个int数的每一个bit来映射某个数据 2)由于采用 ...

  8. BitMap位图与海量数据的理解与应用

    1. Bit Map算法简介 来自于<编程珠玑>.所谓的Bit-map就是用一个bit位来标记某个元素对应的Value, 而Key即是该元素.由于采用了Bit为单位来存储数据,因此在存储空 ...

  9. Bitmap用来做大数据处理

    MapReduce是一种编程模型,用于大规模数据集(大于1TB)的并行运算.概念"Map(映射)"和"Reduce(归约)" Bit-map空间压缩和快速排序去 ...

随机推荐

  1. CO-类的本质、description方法

    类的本质 1. 类也是个对象 其实类也是一个对象,是Class类型的对象,简称“类对象” Class类型的定义 typedef struct objc_class  *Class; 类名就代表着类对象 ...

  2. ASP.NET MVC使用Bootstrap系列（5）——创建ASP.NET MVC Bootstrap Helpers

    阅读目录 序言 内置的HTML Helpers 创建自定义的Helpers 使用静态方法创建Helpers 使用扩展方法创建Helpers 创建Fluent Helpers 创建自动闭合的Helper ...

  3. 关于centos7的网络配置

    1.DNS DNS是域名系统 (Domain Name System) 的缩写,它是由解析器和域名服务器组成的.域名服务器是指保存有该网络中所有主机的域名和对应IP地址,并具有将域名转换为IP地址功能 ...

  4. gradle providedCompile 与compile区别

    Gradle compile: 如果你的jar包/依赖代码 在编译的时候需要依赖,在运行的时候也需要,那么就用compile例如 : compile 'org.springframework.boot ...

  5. Android Studio-设置快速修复错误提示代码

    File-Settings-keyMap-show intention actions.

  6. django学习<一>：安装

    这两天打算摸索下和python相关的东西,然后正好小伙伴有个关于网站的任务,就怀着好奇的心态了解了下,然后就很自然地开始涉及django的问题. 首先就是django安装的问题,想不到第一步就出问题了 ...

  7. 【转载】Unity 优雅地管理资源，减少占用内存，优化游戏

    转自:星辰的<Unity3D占用内存太大的解决方法> 最近网友通过网站搜索Unity3D在手机及其他平台下占用内存太大. 这里写下关于Unity3D对于内存的管理与优化. Unity3D  ...

  8. 15个关于Chrome的开发必备小技巧

    一.快速查找文件 如果你使用过Sublime,那么你会知道’Go to anything’的强大.没错,Chrome现在也有了这一功能. 操作如下: 1.F12打开你的Chrome调试器: 2.按下C ...

  9. SQL补充

    TOP 子句TOP 子句用于规定要返回的记录的数目.对于拥有数千条记录的大型表来说,TOP 子句是非常有用的.注释:并非所有的数据库系统都支持 TOP 子句.SELECT TOP 2 * FROM P ...

  10. 【转】MySQL数据类型和常用字段属性总结

    来源:http://www.jb51.net/article/55853.htm 这里先总结数据类型.MySQL中的数据类型大的方面来分,可以分为:日期和时间.数值,以及字符串.下面就分开来进行总结. ...