Python: 实现bitmap数据结构

最新推荐文章于 2023-06-01 15:03:08 发布
最新推荐文章于 2023-06-01 15:03:08 发布
阅读量8.1k 收藏 5
点赞数 1
分类专栏： python 文章标签： python 数据结构 bitmap


http://my.oschina.net/goal/blog/200347 

bitmap是很常用的数据结构，比如用于Bloom Filter中、用于无重复整数的排序等等。bitmap通常基于数组来实现，数组中每个元素可以看成是一系列二进制数，所有元素组成更大的二进制集合。对于Python来说，整数类型默认是有符号类型，所以一个整数的可用位数为31位。

bitmap实现思路

bitmap是用于对每一位进行操作。举例来说，一个Python数组包含4个32位有符号整型，则总共可用位为4 * 31 = 124位。如果要在第90个二进制位上操作，则要先获取到操作数组的第几个元素，再获取相应的位索引，然后执行操作。

上图所示为一个32位整型，在Python中默认是有符号类型，最高位为符号位，bitmap不能使用它。左边是高位，右边是低位，最低位为第0位。

初始化bitmap

首先需要初始化bitmap。拿90这个整数来说，因为单个整型只能使用31位，所以90除以31并向上取整则可得知需要几个数组元素。代码如下：

?
1
2
3
4
5
6
7
8
9
10
#!/usr/bin/env python
#coding: utf8
 
class  Bitmap( object ):
     def  __init__( self ,  max ):
         self .size  =  int (( max  +  31  -  1 )  /  31 )  #向上取整
 
if  __name__  = =  '__main__' :
     bitmap  =  Bitmap( 90 )
     print  '需要 %d 个元素。'  %  bitmap.size

?
1
2
$ python bitmap.py
需要 3 个元素。

计算索引

确定了数组大小后，也就可以创建这个数组了。如果要将一个整数保存进这个数组，首先需要知道保存在这个数组的第几个元素之上，然后要知道是在这个元素的第几位上。因此计算索引分为：

  1. 计算在数组中的索引

  2. 计算在数组元素中的位索引

计算在数组中的索引

计算在数组中的索引其实是跟之前计算数组大小是一样的。只不过之前是对最大数计算，现在换成任一需要存储的整数。但是有一点不同，计算在数组中的索引是向下取整，所以需要修改calcElemIndex方法的实现。代码改为如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#!/usr/bin/env python
#coding: utf8
 
class  Bitmap( object ):
     def  __init__( self ,  max ):
         self .size   =  self .calcElemIndex( max ,  True )
         self .array  =  [ 0  for  i  in  range ( self .size)]
 
     def  calcElemIndex( self , num, up = False ):
         '''up为True则为向上取整, 否则为向下取整'''
         if  up:
             return  int ((num  +  31  -  1 )  /  31 )  #向上取整
         return  num  /  31
 
if  __name__  = =  '__main__' :
     bitmap  =  Bitmap( 90 )
     print  '数组需要 %d 个元素。'  %  bitmap.size
     print  '47 应存储在第 %d 个数组元素上。'  %  bitmap.calcElemIndex( 47 )

?
1
2
3
$ python bitmap.py
数组需要 3 个元素。
47 应存储在第 1 个数组元素上。

所以获取最大整数很重要，否则有可能创建的数组容纳不下某些数据。

计算在数组元素中的位索引

数组元素中的位索引可以通过取模运算来得到。令需存储的整数跟31取模即可得到位索引。代码改为如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#!/usr/bin/env python
#coding: utf8
 
class  Bitmap( object ):
     def  __init__( self ,  max ):
         self .size   =  self .calcElemIndex( max ,  True )
         self .array  =  [ 0  for  i  in  range ( self .size)]
 
     def  calcElemIndex( self , num, up = False ):
         '''up为True则为向上取整, 否则为向下取整'''
         if  up:
             return  int ((num  +  31  -  1 )  /  31 )  #向上取整
         return  num  /  31
 
     def  calcBitIndex( self , num):
         return  num  %  31
 
if  __name__  = =  '__main__' :
     bitmap  =  Bitmap( 90 )
     print  '数组需要 %d 个元素。'  %  bitmap.size
     print  '47 应存储在第 %d 个数组元素上。'  %  bitmap.calcElemIndex( 47 )
     print  '47 应存储在第 %d 个数组元素的第 %d 位上。'  %  (bitmap.calcElemIndex( 47 ), bitmap.calcBitIndex( 47 ),)

?
1
2
3
4
$ python bitmap.py
数组需要 3 个元素。
47 应存储在第 1 个数组元素上。
47 应存储在第 1 个数组元素的第 16 位上。

别忘了是从第0位算起哦。

置1操作

二进制位默认是0，将某位置1则表示在此位存储了数据。代码改为如下：

?
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
#!/usr/bin/env python
#coding: utf8
 
class  Bitmap( object ):
     def  __init__( self ,  max ):
         self .size   =  self .calcElemIndex( max ,  True )
         self .array  =  [ 0  for  i  in  range ( self .size)]
 
     def  calcElemIndex( self , num, up = False ):
         '''up为True则为向上取整, 否则为向下取整'''
         if  up:
             return  int ((num  +  31  -  1 )  /  31 )  #向上取整
         return  num  /  31
 
     def  calcBitIndex( self , num):
         return  num  %  31
 
     def  set ( self , num):
         elemIndex  =  self .calcElemIndex(num)
         byteIndex  =  self .calcBitIndex(num)
         elem       =  self .array[elemIndex]
         self .array[elemIndex]  =  elem | ( 1  << byteIndex)
 
if  __name__  = =  '__main__' :
     bitmap  =  Bitmap( 90 )
     bitmap. set ( 0 )
     print  bitmap.array

?
1
2
$ python bitmap.py
[1, 0, 0]

因为从第0位算起，所以如需要存储0，则需要把第0位置1。

清0操作

将某位置0，也即丢弃已存储的数据。代码如下：

?
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
#!/usr/bin/env python
#coding: utf8
 
class  Bitmap( object ):
     def  __init__( self ,  max ):
         self .size   =  self .calcElemIndex( max ,  True )
         self .array  =  [ 0  for  i  in  range ( self .size)]
 
     def  calcElemIndex( self , num, up = False ):
         '''up为True则为向上取整, 否则为向下取整'''
         if  up:
             return  int ((num  +  31  -  1 )  /  31 )  #向上取整
         return  num  /  31
 
     def  calcBitIndex( self , num):
         return  num  %  31
 
     def  set ( self , num):
         elemIndex  =  self .calcElemIndex(num)
         byteIndex  =  self .calcBitIndex(num)
         elem       =  self .array[elemIndex]
         self .array[elemIndex]  =  elem | ( 1  << byteIndex)
 
     def  clean( self , i):
         elemIndex  =  self .calcElemIndex(i)
         byteIndex  =  self .calcBitIndex(i)
         elem       =  self .array[elemIndex]
         self .array[elemIndex]  =  elem & (~( 1  << byteIndex))
 
if  __name__  = =  '__main__' :
     bitmap  =  Bitmap( 87 )
     bitmap. set ( 0 )
     bitmap. set ( 34 )
     print  bitmap.array
     bitmap.clean( 0 )
     print  bitmap.array
     bitmap.clean( 34 )
     print  bitmap.array

?
1
2
3
4
$ python bitmap.py
[1, 8, 0]
[0, 8, 0]
[0, 0, 0]

清0和置1是互反操作。

测试某位是否为1

判断某位是否为1是为了取出之前所存储的数据。代码如下：

?
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
#!/usr/bin/env python
#coding: utf8
 
class  Bitmap( object ):
     def  __init__( self ,  max ):
         self .size   =  self .calcElemIndex( max ,  True )
         self .array  =  [ 0  for  i  in  range ( self .size)]
 
     def  calcElemIndex( self , num, up = False ):
         '''up为True则为向上取整, 否则为向下取整'''
         if  up:
             return  int ((num  +  31  -  1 )  /  31 )  #向上取整
         return  num  /  31
 
     def  calcBitIndex( self , num):
         return  num  %  31
 
     def  set ( self , num):
         elemIndex  =  self .calcElemIndex(num)
         byteIndex  =  self .calcBitIndex(num)
         elem       =  self .array[elemIndex]
         self .array[elemIndex]  =  elem | ( 1  << byteIndex)
 
     def  clean( self , i):
         elemIndex  =  self .calcElemIndex(i)
         byteIndex  =  self .calcBitIndex(i)
         elem       =  self .array[elemIndex]
         self .array[elemIndex]  =  elem & (~( 1  << byteIndex))
 
     def  test( self , i):
         elemIndex  =  self .calcElemIndex(i)
         byteIndex  =  self .calcBitIndex(i)
         if  self .array[elemIndex] & ( 1  << byteIndex):
             return  True
         return  False
 
if  __name__  = =  '__main__' :
     bitmap  =  Bitmap( 90 )
     bitmap. set ( 0 )
     print  bitmap.array
     print  bitmap.test( 0 )
     bitmap. set ( 1 )
     print  bitmap.test( 1 )
     print  bitmap.test( 2 )
     bitmap.clean( 1 )
     print  bitmap.test( 1 )

?
1
2
3
4
5
6
$ python bitmap.py
[1, 0, 0]
True
True
False
False

接下来实现一个不重复数组的排序。已知一个无序非负整数数组的最大元素为879，请对其自然排序。代码如下：

?
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
#!/usr/bin/env python
#coding: utf8
 
class  Bitmap( object ):
     def  __init__( self ,  max ):
         self .size   =  self .calcElemIndex( max ,  True )
         self .array  =  [ 0  for  i  in  range ( self .size)]
 
     def  calcElemIndex( self , num, up = False ):
         '''up为True则为向上取整, 否则为向下取整'''
         if  up:
             return  int ((num  +  31  -  1 )  /  31 )  #向上取整
         return  num  /  31
 
     def  calcBitIndex( self , num):
         return  num  %  31
 
     def  set ( self , num):
         elemIndex  =  self .calcElemIndex(num)
         byteIndex  =  self .calcBitIndex(num)
         elem       =  self .array[elemIndex]
         self .array[elemIndex]  =  elem | ( 1  << byteIndex)
 
     def  clean( self , i):
         elemIndex  =  self .calcElemIndex(i)
         byteIndex  =  self .calcBitIndex(i)
         elem       =  self .array[elemIndex]
         self .array[elemIndex]  =  elem & (~( 1  << byteIndex))
 
     def  test( self , i):
         elemIndex  =  self .calcElemIndex(i)
         byteIndex  =  self .calcBitIndex(i)
         if  self .array[elemIndex] & ( 1  << byteIndex):
             return  True
         return  False
 
if  __name__  = =  '__main__' :
     MAX  =  879
     suffle_array  =  [ 45 ,  2 ,  78 ,  35 ,  67 ,  90 ,  879 ,  0 ,  340 ,  123 ,  46 ]
     result        =  []
     bitmap  =  Bitmap( MAX )
     for  num  in  suffle_array:
         bitmap. set (num)
     
     for  i  in  range ( MAX  +  1 ):
         if  bitmap.test(i):
             result.append(i)
 
     print  '原始数组为:    %s'  %  suffle_array
     print  '排序后的数组为: %s'  %  result

?
1
2
3
$ python bitmap.py
原始数组为：   [45, 2, 78, 35, 67, 90, 879, 0, 340, 123, 46]
排序后的数组为：[0, 2, 35, 45, 46, 67, 78, 90, 123, 340, 879]

结束语

bitmap实现了，则利用其进行排序就非常简单了。其它语言也同样可以实现bitmap，但对于静态类型语言来说，比如C/Golang这样的语言，因为可以直接声明无符号整型，所以可用位就变成32位，只需将上述代码中的31改成32即可，这点请大家注意。


scdxmoe
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之位图（bitmap）详解
12-25
1.  概述 位图（bitmap）是一种非常常用的结构，在索引，数据压缩等方面有广泛应用。本文介绍了位图的实现方法及其应用场景。 2. 位图实现 （1）自己实现 在位图中，每个元素为“0”或“1”，表示其对应的元素不存在或者存在。 代码如下: #define INT_BITS sizeof(int)   #define SHIFT 5 // 2^5=32   #define MASK 0x1f // 2^5=32   #define MAX 1024*1024*1024 //max number   int bitmap[MAX / INT_BITS];   /*   * 设置第i位  
【位图（Bitmap）】数据结构：高效存储与处理大量数据
最新发布
StuLearn-LJC的博客
03-01 1199
位图是一种数据结构，是用每一位来存放某种状态，适用于海量数据，整数，数据无重复的场景。通常是用来判断某个数据存不存在的。数据是否在给定的整形数据中，结果是在或者不在，刚好是两种状态，那么可以使用一个二进制比特位来代表数据是否存在的信息，如果二进制比特位为1，代表存在，为0代表不存在。
bitmap之py实现
yahuuuwjl的博客
08-28 264
数据结构中很特别的bitmap，bitmap原理：python3中一个带符号的整数是8位，第一位是符号位，剩下63位可以按位操作。 用于不重复整数的排序，排序原理是：从文件读取数组，按照数字大小在对应bit位置操作置1，时间复杂度是O(n)。遍历对应位置，为1就证明有数，以此排序。 参考原文，但是python2和3的有符号整数都是8字节。所以略有修改。 如有错误，欢迎留言指导。 #!/home/w...
【数据结构】BitMap
热门推荐
小确幸的博客
04-09 2万+
<beans> <!-- 开启Annotation注解注入配置 --> <context:annotation-config /> <!-- 扫描包 --> <context:component-scan base-package="com.iflytek.jtcn" use-default-filters="false"> <context:include-filter type="annotation" expression.
数据结构之Bitmap
Tyler93
07-31 4851
随着大数据技术日趋成熟，去重分析在企业日常分析中的使用频率愈来愈高，如何在大数据场景下快速地进行去重分析一直是一大难点，说到去重那么 Bitmap 一定会被提到，本文主要先介绍bitmap的原理，后续在其他章节中会继续介绍其在企业中是如何使用的。 .
python实现bitmap数据结构详解
12-23
bitmap是很常用的数据结构，比如用于Bloom Filter中；用于无重复整数的排序等等。bitmap通常基于数组来实现，数组中每个元素可以看成是一系列二进制数，所有元素组成更大的二进制集合。对于Python来说，整数类型默认...
python 常用数据结构实例
04-14
python实现常用数据结构示例。树，栈，队列，bitamap.
海量数据处理系列之:用C++实现Bitmap算法
01-01
bitmap是一个十分有用的结构。所谓的Bit-map就是用一个bit位来标记某个元素对应的Value， 而Key即是该元素。由于采用了Bit为单位来存储数据，因此在存储空间方面，可以大大节省。 适用范围：可进行数据的快速查找，...
BitMap数据结构
西凉的悲伤博客
06-01 1836
Bit-map的基本思想就是用一个bit位来标记某个元素对应的Value，而Key即是该元素。由于采用了Bit为单位来存储数据，因此在存储空间方面，可以大大节省。（PS：划重点 节省存储空间）假设有这样一个需求：在20亿个随机整数中找出某个数m是否存在其中，并假设32位操作系统，4G内存在Java中，int占4字节，1字节=8位（1 byte = 8 bit）如果每个数字用int存储，那就是20亿个int，因而占用的空间约为 (2000000000*4/1024/1024/1024)≈7.45G。
算法与数据结构——位图BitMap
DreamsArchitects的博客
02-14 3691
数据结构与算法_位图BitMap: 1.什么是位图？ 2.位图的实现
BitMap数据结构梳理总结及代码实现
u014614478的博客
12-11 2006
BitMap(位图) BitMap定义 位图（BitMap），即位（Bit）的集合，是一个离散的数组结构，用一个bit位来标记某个元素对应的Value，而Key即是该元素;最基本的情况，使用一个bit表示一个关键字的状态（可标示两种状态0-不存在，1-存在），也可以使用2bit（表示4种状态），3bit（表示8种状态）需要根据业务场景实现。 BitMap 数据结构 数据结构：byte[]，一个byte 8 bit,使用bit为单位来存储数据，可以在空间和时间双重维度提高效率。 注：也可以是 int
python 32bit数据结构_python实现bitmap数据结构详解
weixin_42650811的博客
12-24 267
bitmap是很常见的算法设计，例如用以Bloom Filter中；用以无反复整数金额的排列这些。bitmap一般根据数组来完成，数组中每一个原素能够当做是一系列二进制数，全部元素组成更高的二进制结合。针对Python而言，整数金额种类默认设置是有标记种类，因此 一个整数金额的能用十位数为31位。bitmap完成构思bitmap是用以对每一位开展实际操作。举例来说，一个Python数组包括4个32...
Python bitmap数据结构算法具体实现
s15885823584的博客
12-08 796
bitmap数据结构的原理、适用场景以及优缺点等在下链接中有详细说明，在此不再赘述。 https://blog.csdn.net/pipisorry/article/details/62443757?utm_source=itdadao&amp;utm_medium=referral 最近在学python时，学到bitmap算法，于是搜了相关资料，看大家都在说原理及适用场景等，代码给的比较简略...
数据结构--位图 BitMap
Michael是个半路程序员
08-06 2420
文章目录1. 位图2. 代码 1. 位图 我们有1千万个整数，整数的范围在1到1亿之间。如何快速查找某个整数是否在这1千万个整数中呢？ 当然，这个问题可以用散列表来解决。可以使用一种特殊的散列表，那就是位图。 申请一个大小为1亿、布尔类型（true或者false）的数组。将这1千万个整数作为数组下标，将对应的数组值设置成true。比如，整数5对应下标为5的数组值设置为true，也就是array[...
必须了解的数据结构 BitMap 基础 应用 与 C语言实现
一起加油
10-29 1345
数据结构 Bitmap 的核心思想就是 用 连续的``bit``来标志一个 可连续 ``数据`` 的有无 。因为他只需要存储数据的有无(布尔值)而不是数据，所以可以大大的降低存储空间。也可以大大加快查询的速度。
【算法&数据结构初阶篇】：位图bitMap
studyday1的博客
01-17 1000
定义数组长度，需要先给需要存储的数集的最大值表示需要多少个，如 max是63 那个得 1 只需一个元素，如果是64 得 2，就需要2个元素 因为一个Long64位 存放0-63的数值， 接着是64-127num>>6 表示先将目标数值除以64 得到该数值是位于bits数组的第几个，比如63 / 64 = 0 在bit[0] 64/64=1 bit[1]num & 63 表示num % 64 , 即看在该元素的第几位。
bitmap的原理及使用python实现最基础的bitmap
keepaware的博客
01-01 4070
前段时间读公众号老看到bitmap或者hash值来解决大批量数据的排序或者去重的工作，当然这里的数据绝对不是平常所使用的小数据，而是可能纯文本数据大小都达到了上T的。正是因为自己多看了几眼，因此本文主要对bitmap进行python实现，并对其进行一定解释。 bitmap原理 实际上bitmap的原理很简单，就是用位的方法来储存数值，也正是因此如果不是数值的话就不能用bitmap（当然通过什么方法来转化为数值也不是不行）。用位如何储存数值呢？我们知道，当我们随意向计算机输入一个数字，这个数字绝对不是以其本身
如何用定义Gdiplus::Bitmap* bitmap类型
06-09
要定义一个 Gdiplus::Bitmap* 的变量，可以使用以下语法： ```cpp Gdiplus::Bitmap* bitmap; ``` 这将声明一个指向 Gdiplus::Bitmap 类型的指针变量 bitmap。但是，需要注意的是，这只是声明了一个指针变量，它并不指向任何有效的对象。如果要使用它，需要在程序中分配一个新的 Gdiplus::Bitmap 对象，并将其地址存储在 bitmap 变量中。例如： ```cpp bitmap = new Gdiplus::Bitmap(width, height, pixelFormat); ``` 其中，width 和 height 是位图的宽度和高度，pixelFormat 是位图的像素格式。这将创建一个新的 Gdiplus::Bitmap 对象，并将其地址存储在 bitmap 变量中。记得在程序结束前释放 bitmap 指向的内存，以避免内存泄漏。可以使用 delete 运算符来释放内存： ```cpp delete bitmap; ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值