快捷導(dǎo)航

Golang中Bit數(shù)組的實(shí)現(xiàn)方式

更新時(shí)間：2021年04月30日 08:39:02 作者：天易獨(dú)尊

這篇文章主要介紹了Golang中Bit數(shù)組的實(shí)現(xiàn)方式，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。一起跟隨小編過來看看吧

Go語言里的集合一般會(huì)用map[T]bool這種形式來表示，T代表元素類型。集合用map類型來表示雖然非常靈活，但我們可以以一種更好的形式來表示它。

例如在數(shù)據(jù)流分析領(lǐng)域，集合元素通常是一個(gè)非負(fù)整數(shù)，集合會(huì)包含很多元素，并且集合會(huì)經(jīng)常進(jìn)行并集、交集操作，這種情況下，bit數(shù)組會(huì)比map表現(xiàn)更加理想。

一個(gè)bit數(shù)組通常會(huì)用一個(gè)無符號(hào)數(shù)或者稱之為“字”的slice來表示，每一個(gè)元素的每一位都表示集合里的一個(gè)值。當(dāng)集合的第i位被設(shè)置時(shí)，我們才說這個(gè)集合包含元素i。

下面的這個(gè)程序展示了一個(gè)簡(jiǎn)單的bit數(shù)組類型，并且實(shí)現(xiàn)了三個(gè)函數(shù)來對(duì)這個(gè)bit數(shù)組來進(jìn)行操作：

package main
import (
	"bytes"
	"fmt"
)
// An IntSet is a set of small non-negative integers.
// Its zero value represents the empty set.
type IntSet struct {
	words []uint
}
const (
	bitNum = (32 << (^uint(0) >> 63)) //根據(jù)平臺(tái)自動(dòng)判斷決定是32還是64
)
// Has reports whether the set contains the non-negative value x.
func (s *IntSet) Has(x int) bool {
	word, bit := x/bitNum, uint(x%bitNum)
	return word < len(s.words) && s.words[word]&(1<<bit) != 0
}
// Add adds the non-negative value x to the set.
func (s *IntSet) Add(x int) {
	word, bit := x/bitNum, uint(x%bitNum)
	for word >= len(s.words) {
		s.words = append(s.words, 0)
	}
	s.words[word] |= 1 << bit
}
//A與B的交集，合并A與B
// UnionWith sets s to the union of s and t.
func (s *IntSet) UnionWith(t *IntSet) {
	for i, tword := range t.words {
		if i < len(s.words) {
			s.words[i] |= tword
		} else {
			s.words = append(s.words, tword)
		}
	}
}

因?yàn)槊恳粋€(gè)字都有64個(gè)二進(jìn)制位，所以為了定位x的bit位，我們用了x/64的商作為字的下標(biāo)，并且用x%64得到的值作為這個(gè)字內(nèi)的bit的所在位置。

例如，對(duì)于數(shù)字1，將其加入比特?cái)?shù)組：

func (s *IntSet) Add(x int) {
 word, bit := x/bitNum, uint(x%bitNum) //0, 1 := 1/64, uint(1%64)
 for word >= len(s.words) { // 條件不滿足
  s.words = append(s.words, 0)
 }
 s.words[word] |= 1 << bit // s.words[0] |= 1 << 1
}
// 把1存入后，words數(shù)組變?yōu)榱薣]uint64{2}

同理，假如我們?cè)賹?6加入比特?cái)?shù)組：

func (s *IntSet) Add(x int) {
 word, bit := x/bitNum, uint(x%bitNum) //1, 2 := 66/64, uint(66%64)
 for word >= len(s.words) { // 條件滿足
  s.words = append(s.words, 0) // 此時(shí)s.words = []uint64{2, 0}
 }
 s.words[word] |= 1 << bit // s.words[1] |= 1 << 2
}
// 繼續(xù)把66存入后，words數(shù)組變?yōu)榱薣]uint64{2, 4}

所以，對(duì)于words，每個(gè)元素可存儲(chǔ)的值有64個(gè)，每超過64個(gè)則進(jìn)位，即添加一個(gè)元素。（注意，0也占了一位，所以64才要進(jìn)位，第一個(gè)元素可存儲(chǔ)0-63）。

所以，對(duì)于words中的一個(gè)元素，要轉(zhuǎn)換為具體的值時(shí)：首先取到其位置i，用 64 * i 作為已進(jìn)位數(shù)（類似于每10位要進(jìn)位），然后將這個(gè)元素轉(zhuǎn)換為二進(jìn)制數(shù)，從右往左數(shù)，第多少位為1則表示相應(yīng)的有這個(gè)值，用這個(gè)位數(shù) x+64 *i 即為我們存入的值。

相應(yīng)的，可有如下String()函數(shù)

// String returns the set as a string of the form "{1 2 3}".
func (s *IntSet) String() string {
 var buf bytes.Buffer
 buf.WriteByte('{')
 for i, word := range s.words {
  if word == 0 {
   continue
  }
  for j := 0; j < bitNum; j++ {
   if word&(1<<uint(j)) != 0 {
    if buf.Len() > len("{") {
     buf.WriteByte(' ')
    }
    fmt.Fprintf(&buf, "%d", bitNum*i+j)
   }
  }
 }
 buf.WriteByte('}')
 return buf.String()
}

例如，前面存入了1和66后，轉(zhuǎn)換過程為：

// []uint64{2 4}
// 對(duì)于2: 1 << 1 = 2; 所以 x = 0 * 64 + 1 
// 對(duì)于4: 1 << 2 = 4; 所以 x = 1 * 64 + 2
// 所以轉(zhuǎn)換為String為{1 66}

實(shí)現(xiàn)比特?cái)?shù)組的其他方法函數(shù)

func (s *IntSet) Len() int {
	var len int
	for _, word := range s.words {
		for j := 0; j < bitNum; j++ {
			if word&(1<<uint(j)) != 0 {
				len++
			}
		}
	}
	return len
}
func (s *IntSet) Remove(x int) {
	word, bit := x/bitNum, uint(x%bitNum)
	if s.Has(x) {
		s.words[word] ^= 1 << bit
	}
}
func (s *IntSet) Clear() {
	s.words = append([]uint{})
}
func (s *IntSet) Copy() *IntSet {
	intSet := &IntSet{
		words: []uint{},
	}
	for _, value := range s.words {
		intSet.words = append(intSet.words, value)
	}
	return intSet
}
func (s *IntSet) AddAll(args ...int) {
	for _, x := range args {
		s.Add(x)
	}
}
//A與B的并集，A與B中均出現(xiàn)
func (s *IntSet) IntersectWith(t *IntSet) {
	for i, tword := range t.words {
		if i >= len(s.words) {
			continue
		}
		s.words[i] &= tword
	}
}
//A與B的差集，元素出現(xiàn)在A未出現(xiàn)在B
func (s *IntSet) DifferenceWith(t *IntSet) {
	t1 := t.Copy() //為了不改變傳參t，拷貝一份
	t1.IntersectWith(s)
	for i, tword := range t1.words {
		if i < len(s.words) {
			s.words[i] ^= tword
		}
	}
}
//A與B的并差集，元素出現(xiàn)在A沒有出現(xiàn)在B，或出現(xiàn)在B沒有出現(xiàn)在A
func (s *IntSet) SymmetricDifference(t *IntSet) {
	for i, tword := range t.words {
		if i < len(s.words) {
			s.words[i] ^= tword
		} else {
			s.words = append(s.words, tword)
		}
	}
}
//獲取比特?cái)?shù)組中的所有元素的slice集合
func (s *IntSet) Elems() []int {
	var elems []int
	for i, word := range s.words {
		for j := 0; j < bitNum; j++ {
			if word&(1<<uint(j)) != 0 {
				elems = append(elems, bitNum*i+j)
			}
		}
	}
	return elems
}

至此，比特?cái)?shù)組的常用方法函數(shù)都已實(shí)現(xiàn)，現(xiàn)在可以來使用它。

func main() {
	var x, y IntSet
	x.Add(1)
	x.Add(144)
	x.Add(9)
	fmt.Println("x:", x.String()) // "{1 9 144}"
	y.Add(9)
	y.Add(42)
	fmt.Println("y:", y.String()) // "{9 42}"
	x.UnionWith(&y)
	fmt.Println("x unionWith y:", x.String())         // "{1 9 42 144}"
	fmt.Println("x has 9,123:", x.Has(9), x.Has(123)) // "true false"
	fmt.Println("x len:", x.Len())                    //4
	fmt.Println("y len:", y.Len())                    //2
	x.Remove(42)
	fmt.Println("x after Remove 42:", x.String()) //{1 9 144}
	z := x.Copy()
	fmt.Println("z copy from x:", z.String()) //{1 9 144}
	x.Clear()
	fmt.Println("clear x:", x.String()) //{}
	x.AddAll(1, 2, 9)
	fmt.Println("x addAll 1,2,9:", x.String()) //{1 2 9}
	x.IntersectWith(&y)
	fmt.Println("x intersectWith y:", x.String()) //{9}
	x.AddAll(1, 2)
	fmt.Println("x addAll 1,2:", x.String()) //{1 2 9}
	x.DifferenceWith(&y)
	fmt.Println("x differenceWith y:", x.String()) //{1 2}
	x.AddAll(9, 144)
	fmt.Println("x addAll 9,144:", x.String()) //{1 2 9 144}
	x.SymmetricDifference(&y)
	fmt.Println("x symmetricDifference y:", x.String()) //{1 2 42 144}
	for _, value := range x.Elems() {
		fmt.Print(value, " ") //1 2 42 144
	}
}

以上為個(gè)人經(jīng)驗(yàn)，希望能給大家一個(gè)參考，也希望大家多多支持腳本之家。如有錯(cuò)誤或未考慮完全的地方，望不吝賜教。

您可能感興趣的文章: