2. 程式人生 > >Python: 實現bitmap資料結構

Python: 實現bitmap資料結構

阿新 • • 發佈：2018-12-15

這是根據網上看的一篇文章，對程式碼進行了修改。

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並向上取整則可得知需要幾個陣列元素。程式碼如下：

#!/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
 
$ python bitmap.py
需要 3 個元素。

計算索引

確定了陣列大小後，也就可以建立這個陣列了。如果要將一個整數儲存進這個陣列，首先需要知道儲存在這個陣列的第幾個元素之上，然後要知道是在這個元素的第幾位上。因此計算索引分為：

  1. 計算在陣列中的索引

  2. 計算在陣列元素中的位索引

計算在陣列中的索引

計算在陣列中的索引其實是跟之前計算陣列大小是一樣的。只不過之前是對最大數計算，現在換成任一需要儲存的整數。但是有一點不同，計算在陣列中的索引是向下取整，所以需要修改calcElemIndex方法的實現。程式碼改為如下：

#!/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)
 
$ python bitmap.py
陣列需要 3 個元素。
47 應儲存在第 1 個數組元素上。

所以獲取最大整數很重要，否則有可能建立的陣列容納不下某些資料。

計算在陣列元素中的位索引

陣列元素中的位索引可以通過取模運算來得到。令需儲存的整數跟31取模即可得到位索引。程式碼改為如下：

#!/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),)
$ python bitmap.py
陣列需要 3 個元素。
47 應儲存在第 1 個數組元素上。
47 應儲存在第 1 個數組元素的第 16 位上。

別忘了是從第0位算起哦。

置1操作

二進位制位預設是0，將某位置1則表示在此位儲存了資料。程式碼改為如下：

#!/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
$ python bitmap.py
[1, 0, 0]

因為從第0位算起，所以如需要儲存0，則需要把第0位置1。

清0操作

將某位置0，也即丟棄已儲存的資料。程式碼如下：

#!/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
$ python bitmap.py
[1, 8, 0]
[0, 8, 0]
[0, 0, 0]

清0和置1是互反操作。

測試某位是否為1

判斷某位是否為1是為了取出之前所儲存的資料。程式碼如下：

#!/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)
$ python bitmap.py
[1, 0, 0]
True
True
False
False

接下來實現一個不重複陣列的排序。已知一個無序非負整數陣列的最大元素為879，請對其自然排序。程式碼如下：

#!/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
$ 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即可，這點請大家注意。

我對程式碼修改改了兩部分程式碼

如下

class Bitmap(object):
    def __init__(self, max):
        self.size = self.calcElemIndex(max)
        self.array = [0 for _ in range(self.size)]

    def calcElemIndex(self, num):
        """
        加 1 的原因是，0 陣列中也可能包含 0
        所以應該向上取整
        :param num:
        :return:
        """
        # return int((num + 31 - 1) / 31)  # 向上取整
        return (num + 1) // 31 + 1

    def calcBitIndex(self, num):
        return num % 31

    def set(self, num):
        elemIndex = self.calcElemIndex(num) - 1
        byteIndex = self.calcBitIndex(num)
        print(f"self.array is {self.array}, size is {len(self.array)}")
        print(f'eleIndex is {elemIndex}')
        elem = self.array[elemIndex]
        # 為什麼要用 | 這個的知道，
        # 這個可以表示集合的或
        # 還可以表示二進位制的或
        self.array[elemIndex] = elem | (1 << byteIndex)

    def test(self, i):
        eleIndex = self.calcElemIndex(i) - 1
        byteIndex = self.calcBitIndex(i)
        elem = self.array[eleIndex]
        return True if elem & (1 << byteIndex) == (1 << byteIndex) else False


nums = [45, 2, 78, 35, 67, 90, 879, 0, 340, 123, 46]
MAX = 879
bitmap = Bitmap(MAX)
for num in nums:
    bitmap.set(num)

result = []
for i in range(MAX + 1):
    if bitmap.test(i):
        result.append(i)

print(result)

相關推薦

Python: 實現bitmap資料結構

這是根據網上看的一篇文章，對程式碼進行了修改。 bitmap是很常用的資料結構，比如用於Bloom Filter中、用於無重複整數的排序等等。bitmap通常基於陣列來實現，陣列中每個元素可以看成是一系列二進位制數，所有元素組成更大的二進位制集合。對於Python來說，

Python實現Map資料結構

class HashTable: def __init__(self): # 初始化兩個list，一個用來儲存鍵值，一個用來儲存值 self.size = 11 self.slots = [None] * self.size self.data = [Non

Python實現基礎資料結構--單向連結串列

連結串列 *CSDN不支援mermaid語法，所以圖在該網站就看不到了 節點類 連結串列的基礎是節點，先宣告節點類： class Node(object): def __init

python演算法與資料結構013--二叉樹的實現及按先序，後序，中序遍歷的遞迴實現

二叉樹的深度優先遍歷： （可以用遞迴或者堆疊實現） 先序：根節點->左子樹->右子樹 中序: 左子樹->根節點->右子樹 後序：左子樹->右子樹->根節點 二叉樹按廣度優先遍歷：從上到下，從左到右遍歷按層次遍歷（利用佇列實現） cl

python演算法與資料結構002--利用列表實現棧的功能

class Statck(object): """ 棧:後進先出的資料結構 利用列表實現棧的基本功能。 """ def __init__(self): self.items=[] def

python演算法與資料結構-二叉樹的程式碼實現(46)

一、二叉樹回憶 　　上一篇我們對資料結構中常用的樹做了介紹，本篇部落格主要以二叉樹為例，講解一下樹的資料結構和程式碼實現。回顧二叉樹：二叉樹是每個節點最多有兩個子樹的樹結構。通常子樹被稱作“左子樹”（left subtree）和“右子樹”（right subt

python 實現bitmap，排序

false bitmap turn print pen main sel 可用 其余 #python整數類型默認是有符號類型。可用位數是31位。 import mathclass Bitmap(object): def __init__(self, max):

python實現隊列結構

odi utf python3 data 是否為空 出隊 是否 create proc # -*- coding:utf-8 -*- # __author__ :kusy # __content__:文件說明 # __date__:2018/10/8 13:49

高階Python----常用的資料結構與演算法

前言 高階Python系列文章是筆者想要突破自己目前的技術生涯瓶頸而作，不具有普適性。本文主要是介紹Python在資料結構和演算法中常用的函式。這也是資料分析領域必備知識點。 也不是特地為了某些讀者而作，想著提高自己的同時，能方便他人就更好了。懂分享的人，一定會快樂！

【12】python 棧型資料結構模擬、佇列型資料結構模擬

一、壓棧操作模擬 #__author:"吉*佳" #date: 2018/10/21 0021 #function:棧 # 棧：即是先進後出的一種資料結構 # （1）模擬壓棧操作 stack=[] flag=True while flag: temp = input("請輸入壓棧元素[

線性表及其應用C語言實現（資料結構複習最全筆記）

一、順序表的表示與實現 1.線性表的順序結構定義 #define LIST_INIT_SIZE 100 //線性表儲存空間的初始分配量 #define LISTINCREMENT 10 //線性表儲存空間的分配增量 typedef struct { ElemType* el

Python實現分發資料塊到多臺伺服器上

程式碼如下： # coding: utf-8 import paramiko import re import os from time import sleep # 定義一個類，表示一臺遠端linux主機 # 參考https://www.cnblogs.com/haigege/p/55174

自己動手實現java資料結構（一） 向量

1.向量介紹 　　計算機程式主要執行在記憶體中，而記憶體在邏輯上可以被看做是連續的地址。為了充分利用這一特性，在主流的程式語言中都存在一種底層的被稱為陣列(Array)的資料結構與之對應。在使用陣列時需要事先宣告固定的大小以便程式在執行時為其開闢記憶體空間；陣列通過下標值計算出地址偏移量來對內部元素進行訪問

Python基礎【資料結構：列表 | 元組 | 集合 | 字典】

序列 序列是Python中最基本的資料結構。包括字串，列表，元組，Unicode字串，buffer物件，xrange物件。序列中的每個元素都分配一個數字，即它的索引第一個索引是0，第二個索引是1，依此類推。 列表和元組 列表一個方括號內的逗號分隔值列表中可以存放不同的資料型別。

Redis 設計與實現[1] -- 資料結構與物件

1 簡單動態字串 Redis 沒有直接使用 C 語言傳統的字串表示，而是自己構建了一種簡單動態字串（SDS），使用 SDS 作為 REdis 的預設字串表示。 1.1 SDS 定義 struct sdshdr { // 記錄 buf 陣列中已經使用位元組的數量，等於 SDS 所儲

自己動手實現java資料結構（二） 連結串列

1.連結串列介紹 　　前面我們已經介紹了向量，向量是基於陣列進行資料儲存的線性表。今天，要介紹的是線性表的另一種實現方式---連結串列。 　　連結串列和向量都是線性表，從使用者的角度上依然被視為一個線性的列表結構。但是，連結串列內部儲存資料的方式卻和向量大不相同：連結串列的核心是節點。節點儲存"資料"的同

python - 內建資料結構總結

python資料型別： 數值型別 bool布林型別 str字串型別 list列表型別 tuple元組型別 set集合型別 dict字典型別 可變資料型別 不可變資料型別： 1.可變資料型別：list set dict（是否可以增刪改查） 2.不可變資料型別：數值 bool str tup

二、C++實現list資料結構

本文使用c++實現list資料結構，list的介面函式採用高效的實現方式，這樣一方面使我加深對資料結構的理解，另一方便可以讓我再複習複習c++，通過前幾天寫的vector資料結構的底層實現，我確實又進一步地熟悉使用C++進行程式設計，，這次寫list的實現過程中，我幾乎沒有怎麼檢視《c++pri

樹的三種遍歷方法程式碼實現 （資料結構）C語言

樹的三種遍歷方法：前序，中序和後序及其程式碼實現。 在此分別總結先序，中序，後序的結點輸出順序。   先序： 1.訪問根結點 　　　　2.訪問左子樹 　　　　3.訪問右子樹  中序：1.訪問左子樹 　　　  2.訪問

自己動手實現java資料結構（三） 棧

自己動手實現java資料結構（三） 棧 1.棧的介紹 　　在許多演算法設計中都需要一種"先進後出(First Input Last Output)"的資料結構，因而一種被稱為"棧"的資料結構被抽象了出來。 　　棧的結構類似一個罐頭：只有一個開口；先被放進去的東西沉在底下，後放進去的東西被