[TOC] # 1 golang常見資料結構實現 ## 1.1 連結串列 舉單鏈表的例子，雙向連結串列同理只是多了pre指標。 定義單鏈表結構： ```golang type LinkNode struct { Data int64 NextNode *LinkNode } ``` 構造連結串列及列印連結串列： ```golang 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 切片原生棧實現 ```golang 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 切片原生佇列實現 ```golang 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 切片實現併發安全的棧 - 併發安全的棧 ```golang // 陣列棧，後進先出 type Mystack struct { array []string // 底層切片 size int // 棧的元素數量 lock sync.Mutex // 為了併發安全使用的鎖 } ``` - 入棧 ```golang // 入棧 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)。 ```golang 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 } ``` - 獲取棧頂元素 ```golang // 獲取棧頂元素 func (stack *Mystack) Peek() string { // 棧中元素已空 if stack.size == 0 { panic("empty") } // 棧頂元素值 v := stack.array[stack.size-1] return v } ``` - 獲取棧大小和判定是否為空 ```golang // 棧大小 func (stack *Mystack) Size() int { return stack.size } // 棧是否為空 func (stack *Mystack) IsEmpty() bool { return stack.size == 0 } ``` #### 1.3.2.2 切片實現併發安全的佇列 - 佇列結構 ```golang // 陣列佇列，先進先出 type Myqueue struct { array []string // 底層切片 size int // 佇列的元素數量 lock sync.Mutex // 為了併發安全使用的鎖 } ``` - 入隊 ```golang // 入隊 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、建立新的陣列，將老陣列中除第一個元素以外的元素移動到新陣列。 ```golang // 出隊 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{} ```golang // 集合結構體 type Set struct { m map[int]struct{} // 用字典來實現，因為欄位鍵不能重複 len int // 集合的大小 sync.RWMutex // 鎖，實現併發安全 } ``` - 初始化Set ```golang // 新建一個空集合 func NewSet(cap int64) *Set { temp := make(map[int]struct{}, cap) return &Set{ m: temp, } } ``` - 往set中新增一個元素 ```golang // 增加一個元素 func (s *Set) Add(item int) { s.Lock() defer s.Unlock() s.m[item] = struct{}{} // 實際往字典新增這個鍵 s.len = len(s.m) // 重新計算元素數量 } ``` - 刪除一個元素 ```golang // 移除一個元素 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中 ```golang // 檢視是否存在元素 func (s *Set) Has(item int) bool { s.RLock() defer s.RUnlock() _, ok := s.m[item] return ok } ``` - 檢視集合大小 ```golang // 檢視集合大小 func (s *Set) Len() int { return s.len } ``` - 檢視集合是否為空 ```golang // 集合是夠為空 func (s *Set) IsEmpty() bool { if s.Len() == 0 { return true } return false } ``` - 清除集合所有元素 ```golang // 清除集合所有元素 func (s *Set) Clear() { s.Lock() defer s.Unlock() s.m = map[int]struct{}{} // 字典重新賦值 s.len = 0 // 大小歸零 } ``` - 將集合轉化為切片 ```golang 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 層所有的節點都連續集中在最左邊。 - 二叉樹結構定義 ```golang // 二叉樹 type TreeNode struct { Data string // 節點用來存放資料 Left *TreeNode // 左子樹 Right *TreeNode // 右字樹 } ``` - 樹的遍歷 1、先序遍歷：先訪問根節點，再訪問左子樹，最後訪問右子樹。 2、後序遍歷：先訪問左子樹，再訪問右子樹，最後訪問根節點。 3、中序遍歷：先訪問左子樹，再訪問根節點，最後訪問右子樹。 4、層次遍歷：每一層從左到右訪問每一個節點。 ```golang // 先序遍歷 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, " ") } ``` 按層遍歷： ```golang 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) }