用go實現常見的資料結構

x1aoda1發表於2021-03-03
Go資料結構

目錄

1 golang常見資料結構實現

1.1 連結串列

舉單連結串列的例子，雙向連結串列同理只是多了pre指標。

定義單連結串列結構：

type LinkNode struct {
	Data     int64
	NextNode *LinkNode
}

構造連結串列及列印連結串列：

func main() {

	node := new(LinkNode)
	node.Data = 1

	node1 := new(LinkNode)
	node1.Data = 2
	node.NextNode = node1 // node1 連結到 node 節點上

	node2 := new(LinkNode)
	node2.Data = 3
	node1.NextNode = node2 // node2 連結到 node1 節點上

	// 順序列印。把原連結串列頭結點賦值到新的NowNode上
	// 這樣仍然保留了原連結串列頭結點node不變
	nowNode := node
	for nowNode != nil {
		fmt.Println(nowNode.Data)
		// 獲取下一個節點。連結串列向下滑動
		nowNode = nowNode.NextNode
	}
}

1.2 可變陣列

可變陣列在各種語言中都非常常用，在golang中，可變陣列語言本身已經實現，就是我們的切片slice。

1.3 棧和佇列

1.3.1 原生切片實現棧和佇列

棧：先進後出，後進先出，類似彈夾

佇列：先進先出

golang中，實現併發不安全的棧和佇列，非常簡單，我們直接使用原生切片即可。

1.3.1.1 切片原生棧實現

func main() {
	// 用切片製作一個棧
	var stack []int
	// 元素1 入棧
	stack = append(stack, 1, 5, 7, 2)
	// 棧取出最近新增的資料。例如[1,5,7,2] ，len = 4
	x := stack[len(stack)-1] // 2
	// 切掉最近新增的資料，上一步和這一步模仿棧的pop。
	stack = stack[:len(stack)-1] // [1,5,7]
	fmt.Printf("%d", x)
}

1.3.1.2 切片原生佇列實現

func main() {

	// 用切片模仿佇列
	var queue []int
	// 進佇列
	queue = append(queue, 1, 5, 7, 2)
	// 隊頭彈出，再把隊頭切掉，模仿佇列的poll操作
	cur := queue[0]
	queue = queue[1:]

	fmt.Printf("%d", cur)
}

1.3.2 *併發安全的棧和佇列

1.3.2.1 切片實現併發安全的棧

  • 併發安全的棧
// 陣列棧，後進先出
type Mystack struct {
    array []string   // 底層切片
    size  int        // 棧的元素數量
    lock  sync.Mutex // 為了併發安全使用的鎖
}
  • 入棧
// 入棧
func (stack *Mytack) Push(v string) {
    stack.lock.Lock()
    defer stack.lock.Unlock()

    // 放入切片中，後進的元素放在陣列最後面
    stack.array = append(stack.array, v)

    // 棧中元素數量+1
    stack.size = stack.size + 1
}
  • 出棧

1、如果切片偏移量向前移動 stack.array[0 : stack.size-1]，表明最後的元素已經不屬於該陣列了，陣列變相的縮容了。此時，切片被縮容的部分並不會被回收，仍然佔用著空間，所以空間複雜度較高，但操作的時間複雜度為：O(1)。

2、如果我們建立新的陣列 newArray，然後把老陣列的元素複製到新陣列，就不會佔用多餘的空間，但移動次數過多，時間複雜度為：O(n)。

func (stack *Mystack) Pop() string {
    stack.lock.Lock()
    defer stack.lock.Unlock()

    // 棧中元素已空
    if stack.size == 0 {
        panic("empty")
    }

    // 棧頂元素
    v := stack.array[stack.size-1]

    // 切片收縮，但可能佔用空間越來越大
    //stack.array = stack.array[0 : stack.size-1]

    // 建立新的陣列，空間佔用不會越來越大，但可能移動元素次數過多
    newArray := make([]string, stack.size-1, stack.size-1)
    for i := 0; i < stack.size-1; i++ {
        newArray[i] = stack.array[i]
    }
    stack.array = newArray

    // 棧中元素數量-1
    stack.size = stack.size - 1
    return v
}
  • 獲取棧頂元素
// 獲取棧頂元素
func (stack *Mystack) Peek() string {
    // 棧中元素已空
    if stack.size == 0 {
        panic("empty")
    }

    // 棧頂元素值
    v := stack.array[stack.size-1]
    return v
}
  • 獲取棧大小和判定是否為空
// 棧大小
func (stack *Mystack) Size() int {
    return stack.size
}

// 棧是否為空
func (stack *Mystack) IsEmpty() bool {
    return stack.size == 0
}

1.3.2.2 切片實現併發安全的佇列

  • 佇列結構
// 陣列佇列，先進先出
type Myqueue struct {
    array []string   // 底層切片
    size  int        // 佇列的元素數量
    lock  sync.Mutex // 為了併發安全使用的鎖
}
  • 入隊
// 入隊
func (queue *Myqueue) Add(v string) {
    queue.lock.Lock()
    defer queue.lock.Unlock()

    // 放入切片中，後進的元素放在陣列最後面
    queue.array = append(queue.array, v)

    // 隊中元素數量+1
    queue.size = queue.size + 1
}
  • 出隊

1、原地挪位，依次補位 queue.array[i-1] = queue.array[i]，然後陣列縮容：queue.array = queue.array[0 : queue.size-1]，但是這樣切片縮容的那部分記憶體空間不會釋放。

2、建立新的陣列，將老陣列中除第一個元素以外的元素移動到新陣列。

// 出隊
func (queue *Myqueue) Remove() string {
    queue.lock.Lock()
    defer queue.lock.Unlock()

    // 隊中元素已空
    if queue.size == 0 {
        panic("empty")
    }

    // 佇列最前面元素
    v := queue.array[0]

    /*    直接原位移動，但縮容後繼的空間不會被釋放
        for i := 1; i < queue.size; i++ {
            // 從第一位開始進行資料移動
            queue.array[i-1] = queue.array[i]
        }
        // 原陣列縮容
        queue.array = queue.array[0 : queue.size-1]
    */

    // 建立新的陣列，移動次數過多
    newArray := make([]string, queue.size-1, queue.size-1)
    for i := 1; i < queue.size; i++ {
        // 從老陣列的第一位開始進行資料移動
        newArray[i-1] = queue.array[i]
    }
    queue.array = newArray

    // 隊中元素數量-1
    queue.size = queue.size - 1
    return v
}

1.4 字典Map和集合Set

1.4.1 Map

字典也是程式語言經常使用的結構，golang中的字典是其自身實現的map結構。具體操作可以檢視語言api

併發安全的map，可以定義結構，結構中有一個map成員和一個鎖變數成員，參考併發安全的棧和佇列的實現。go語言也實現了一個併發安全的map,具體參考sync.map的api

1.4.2 Set

我們可以藉助map的特性，實現一個Set結構。

  • Set結構

map的值我們不適用，定義為空的結構體struct{}

// 集合結構體
type Set struct {
    m            map[int]struct{} // 用字典來實現，因為欄位鍵不能重複
    len          int          // 集合的大小
    sync.RWMutex              // 鎖，實現併發安全
}
  • 初始化Set
// 新建一個空集合
func NewSet(cap int64) *Set {
    temp := make(map[int]struct{}, cap)
    return &Set{
        m: temp,
    }
}
  • 往set中新增一個元素
// 增加一個元素
func (s *Set) Add(item int) {
    s.Lock()
    defer s.Unlock()
    s.m[item] = struct{}{} // 實際往字典新增這個鍵
    s.len = len(s.m)       // 重新計算元素數量
}
  • 刪除一個元素
// 移除一個元素
func (s *Set) Remove(item int) {
    s.Lock()
    s.Unlock()

    // 集合沒元素直接返回
    if s.len == 0 {
        return
    }

    delete(s.m, item) // 實際從字典刪除這個鍵
    s.len = len(s.m)  // 重新計算元素數量
}
  • 檢視元素是否在集合set中
// 檢視是否存在元素
func (s *Set) Has(item int) bool {
    s.RLock()
    defer s.RUnlock()
    _, ok := s.m[item]
    return ok
}
  • 檢視集合大小
// 檢視集合大小
func (s *Set) Len() int {
    return s.len
}
  • 檢視集合是否為空
// 集合是夠為空
func (s *Set) IsEmpty() bool {
    if s.Len() == 0 {
        return true
    }
    return false
}
  • 清除集合所有元素
// 清除集合所有元素
func (s *Set) Clear() {
    s.Lock()
    defer s.Unlock()
    s.m = map[int]struct{}{} // 字典重新賦值
    s.len = 0                // 大小歸零
}
  • 將集合轉化為切片
func (s *Set) List() []int {
    s.RLock()
    defer s.RUnlock()
    list := make([]int, 0, s.len)
    for item := range s.m {
        list = append(list, item)
    }
    return list
}

1.5 二叉樹

二叉樹：每個節點最多隻有兩個兒子節點的樹。

滿二叉樹：葉子節點與葉子節點之間的高度差為 0 的二叉樹，即整棵樹是滿的，樹呈滿三角形結構。在國外的定義，非葉子節點兒子都是滿的樹就是滿二叉樹。我們以國內為準。

完全二叉樹：完全二叉樹是由滿二叉樹而引出來的，設二叉樹的深度為 k，除第 k 層外，其他各層的節點數都達到最大值，且第 k 層所有的節點都連續集中在最左邊。

  • 二叉樹結構定義
// 二叉樹
type TreeNode struct {
    Data  string    // 節點用來存放資料
    Left  *TreeNode // 左子樹
    Right *TreeNode // 右字樹
}
  • 樹的遍歷

1、先序遍歷：先訪問根節點，再訪問左子樹，最後訪問右子樹。

2、後序遍歷：先訪問左子樹，再訪問右子樹，最後訪問根節點。

3、中序遍歷：先訪問左子樹，再訪問根節點，最後訪問右子樹。

4、層次遍歷：每一層從左到右訪問每一個節點。

// 先序遍歷
func PreOrder(tree *TreeNode) {
    if tree == nil {
        return
    }

    // 先列印根節點
    fmt.Print(tree.Data, " ")
    // 再列印左子樹
    PreOrder(tree.Left)
    // 再列印右字樹
    PreOrder(tree.Right)
}

// 中序遍歷
func MidOrder(tree *TreeNode) {
    if tree == nil {
        return
    }

    // 先列印左子樹
    MidOrder(tree.Left)
    // 再列印根節點
    fmt.Print(tree.Data, " ")
    // 再列印右字樹
    MidOrder(tree.Right)
}

// 後序遍歷
func PostOrder(tree *TreeNode) {
    if tree == nil {
        return
    }

    // 先列印左子樹
    MidOrder(tree.Left)
    // 再列印右字樹
    MidOrder(tree.Right)
    // 再列印根節點
    fmt.Print(tree.Data, " ")
}

按層遍歷：

func Level(head *TreeNode) {

	if head == nil {
		return
	}

	// 用切片模仿佇列
	var queue []*TreeNode
	queue = append(queue, head)

	for len(queue) != 0 {
		// 隊頭彈出，再把隊頭切掉，模仿佇列的poll操作
		cur := queue[0]
		queue = queue[1:]

		fmt.Printf("%d", (*cur).Data)

		// 當前節點有左孩子，加入左孩子進佇列
		if cur.Left != nil {
			queue = append(queue, cur.Left)
		}

		// 當前節點有右孩子，加入右孩子進佇列
		if cur.Right != nil {
			queue = append(queue, cur.Right)
		}
	}

}

相關文章