build

chapter_stack_and_queue/queue.md

@@ -493,20 +493,20 @@ comments: true
         // 使用内置包 list 来实现队列
         data *list.List
     }
-    
-    // newLinkedListQueue 初始化链表
+
+    /* 初始化队列 */
     func newLinkedListQueue() *linkedListQueue {
         return &linkedListQueue{
             data: list.New(),
         }
     }
-    
-    // push 入队
+
+    /* 入队 */
     func (s *linkedListQueue) push(value any) {
         s.data.PushBack(value)
     }
-    
-    // poll 出队
+
+    /* 出队 */
     func (s *linkedListQueue) poll() any {
         if s.isEmpty() {
             return nil
@@ -515,8 +515,8 @@ comments: true
         s.data.Remove(e)
         return e.Value
     }
-    
-    // peek 访问队首元素
+
+    /* 访问队首元素 */
     func (s *linkedListQueue) peek() any {
         if s.isEmpty() {
             return nil
@@ -524,16 +524,21 @@ comments: true
         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
     }
+
+    /* 获取 List 用于打印 */
+    func (s *linkedListQueue) toList() *list.List {
+        return s.data
+    }
     ```
 
 === "JavaScript"
@@ -1073,7 +1078,7 @@ comments: true
         queCapacity int   // 队列容量（即最大容纳元素数量）
     }
 
-    // newArrayQueue 基于环形数组实现的队列
+    /* 初始化队列 */
     func newArrayQueue(queCapacity int) *arrayQueue {
         return &arrayQueue{
             nums:        make([]int, queCapacity),
@@ -1083,17 +1088,17 @@ comments: true
         }
     }
 
-    // size 获取队列的长度
+    /* 获取队列的长度 */
     func (q *arrayQueue) size() int {
         return q.queSize
     }
 
-    // isEmpty 判断队列是否为空
+    /* 判断队列是否为空 */
     func (q *arrayQueue) isEmpty() bool {
         return q.queSize == 0
     }
 
-    // push 入队
+    /* 入队 */
     func (q *arrayQueue) push(num int) {
         // 当 rear == queCapacity 表示队列已满
         if q.queSize == q.queCapacity {
@@ -1107,7 +1112,7 @@ comments: true
         q.queSize++
     }
 
-    // poll 出队
+    /* 出队 */
     func (q *arrayQueue) poll() any {
         num := q.peek()
         // 队首指针向后移动一位，若越过尾部则返回到数组头部
@@ -1116,7 +1121,7 @@ comments: true
         return num
     }
 
-    // peek 访问队首元素
+    /* 访问队首元素 */
     func (q *arrayQueue) peek() any {
         if q.isEmpty() {
             return nil
@@ -1124,7 +1129,7 @@ comments: true
         return q.nums[q.front]
     }
 
-    // 获取 Slice 用于打印
+    /* 获取 Slice 用于打印 */
     func (q *arrayQueue) toSlice() []int {
         rear := (q.front + q.queSize)
         if rear >= q.queCapacity {

chapter_stack_and_queue/stack.md

@@ -465,20 +465,20 @@ comments: true
         // 使用内置包 list 来实现栈
         data *list.List
     }
-    
-    // newLinkedListStack 初始化链表
+
+    /* 初始化栈 */
     func newLinkedListStack() *linkedListStack {
         return &linkedListStack{
             data: list.New(),
         }
     }
-    
-    // push 入栈
+
+    /* 入栈 */
     func (s *linkedListStack) push(value int) {
         s.data.PushBack(value)
     }
-    
-    // pop 出栈
+
+    /* 出栈 */
     func (s *linkedListStack) pop() any {
         if s.isEmpty() {
             return nil
@@ -487,8 +487,8 @@ comments: true
         s.data.Remove(e)
         return e.Value
     }
-    
-    // peek 访问栈顶元素
+
+    /* 访问栈顶元素 */
     func (s *linkedListStack) peek() any {
         if s.isEmpty() {
             return nil
@@ -496,16 +496,21 @@ comments: true
         e := s.data.Back()
         return e.Value
     }
-    
-    // size 获取栈的长度
+
+    /* 获取栈的长度 */
     func (s *linkedListStack) size() int {
         return s.data.Len()
     }
-    
-    // isEmpty 判断栈是否为空
+
+    /* 判断栈是否为空 */
     func (s *linkedListStack) isEmpty() bool {
         return s.data.Len() == 0
     }
+
+    /* 获取 List 用于打印 */
+    func (s *linkedListStack) toList() *list.List {
+        return s.data
+    }
     ```
 
 === "JavaScript"
@@ -917,42 +922,39 @@ comments: true
     type arrayStack struct {
         data []int // 数据
     }
-    
+
+    /* 初始化栈 */
     func newArrayStack() *arrayStack {
         return &arrayStack{
             // 设置栈的长度为 0，容量为 16
             data: make([]int, 0, 16),
         }
     }
-    
-    // size 栈的长度
+
+    /* 栈的长度 */
     func (s *arrayStack) size() int {
         return len(s.data)
     }
-    
-    // isEmpty 栈是否为空
+
+    /* 栈是否为空 */
     func (s *arrayStack) isEmpty() bool {
         return s.size() == 0
     }
-    
-    // push 入栈
+
+    /* 入栈 */
     func (s *arrayStack) push(v int) {
         // 切片会自动扩容
         s.data = append(s.data, v)
     }
-    
-    // pop 出栈
+
+    /* 出栈 */
     func (s *arrayStack) pop() any {
-        // 弹出栈前，先判断是否为空
-        if s.isEmpty() {
-            return nil
-        }
         val := s.peek()
         s.data = s.data[:len(s.data)-1]
         return val
     }
-    
-    // peek 获取栈顶元素
+
+    /* 获取栈顶元素 */
     func (s *arrayStack) peek() any {
         if s.isEmpty() {
             return nil
@@ -960,6 +962,11 @@ comments: true
         val := s.data[len(s.data)-1]
         return val
     }
+
+    /* 获取 Slice 用于打印 */
+    func (s *arrayStack) toSlice() []int {
+        return s.data
+    }
     ```
 
 === "JavaScript"