Add Go codes to docs, including

the chapter of stack and queue, the chapter of tree.

docs/chapter_stack_and_queue/queue.md

@@ -115,7 +115,29 @@ comments: true
 === "Go"
 
     ```go title="queue.go"
+    /* 初始化队列 */
+    // 在 Go 中，将 list 作为队列来使用
+    queue := list.New()
 
+    /* 元素入队 */
+    queue.PushBack(1)
+    queue.PushBack(3)
+    queue.PushBack(2)
+    queue.PushBack(5)
+    queue.PushBack(4)
+
+    /* 访问队首元素 */
+    peek := queue.Front()
+
+    /* 元素出队 */
+    poll := queue.Front()
+    queue.Remove(poll)
+
+    /* 获取队列的长度 */
+    size := queue.Len()
+
+    /* 判断队列是否为空 */
+    isEmpty := queue.Len() == 0
     ```
 
 === "JavaScript"
@@ -309,7 +331,52 @@ comments: true
 === "Go"
 
     ```go title="linkedlist_queue.go"
+    /* 基于链表实现的队列 */
+    type LinkedListQueue struct {
+        // 使用内置包 list 来实现队列
+        data *list.List
+    }
 
+    // NewLinkedListQueue 初始化链表
+    func NewLinkedListQueue() *LinkedListQueue {
+        return &LinkedListQueue{
+            data: list.New(),
+        }
+    }
+
+    // Offer 入队
+    func (s *LinkedListQueue) Offer(value any) {
+        s.data.PushBack(value)
+    }
+
+    // Poll 出队
+    func (s *LinkedListQueue) Poll() any {
+        if s.IsEmpty() {
+            return nil
+        }
+        e := s.data.Front()
+        s.data.Remove(e)
+        return e.Value
+    }
+
+    // Peek 访问队首元素
+    func (s *LinkedListQueue) Peek() any {
+        if s.IsEmpty() {
+            return nil
+        }
+        e := s.data.Front()
+        return e.Value
+    }
+
+    // Size 获取队列的长度
+    func (s *LinkedListQueue) Size() int {
+        return s.data.Len()
+    }
+
+    // IsEmpty 判断队列是否为空
+    func (s *LinkedListQueue) IsEmpty() bool {
+        return s.data.Len() == 0
+    }
     ```
 
 === "JavaScript"
@@ -540,7 +607,66 @@ comments: true
 === "Go"
 
     ```go title="array_queue.go"
+    /* 基于环形数组实现的队列 */
+    type ArrayQueue struct {
+        data     []int // 用于存储队列元素的数组
+        capacity int   // 队列容量（即最多容量的元素个数）
+        front    int   // 头指针，指向队首
+        rear     int   // 尾指针，指向队尾 + 1
+    }
 
+    // NewArrayQueue 基于环形数组实现的队列
+    func NewArrayQueue(capacity int) *ArrayQueue {
+        return &ArrayQueue{
+            data:     make([]int, capacity),
+            capacity: capacity,
+            front:    0,
+            rear:     0,
+        }
+    }
+
+    // Size 获取队列的长度
+    func (q *ArrayQueue) Size() int {
+        size := (q.capacity + q.rear - q.front) % q.capacity
+        return size
+    }
+
+    // IsEmpty 判断队列是否为空
+    func (q *ArrayQueue) IsEmpty() bool {
+        return q.rear-q.front == 0
+    }
+
+    // Offer 入队
+    func (q *ArrayQueue) Offer(v int) {
+        // 当 rear == capacity 表示队列已满
+        if q.Size() == q.capacity {
+            return
+        }
+        // 尾结点后添加
+        q.data[q.rear] = v
+        // 尾指针向后移动一位，越过尾部后返回到数组头部
+        q.rear = (q.rear + 1) % q.capacity
+    }
+
+    // Poll 出队
+    func (q *ArrayQueue) Poll() any {
+        if q.IsEmpty() {
+            return nil
+        }
+        v := q.data[q.front]
+        // 队头指针向后移动一位，若越过尾部则返回到数组头部
+        q.front = (q.front + 1) % q.capacity
+        return v
+    }
+
+    // Peek 访问队首元素
+    func (q *ArrayQueue) Peek() any {
+        if q.IsEmpty() {
+            return nil
+        }
+        v := q.data[q.front]
+        return v
+    }
     ```
 
 === "JavaScript"