build

docs/chapter_stack_and_queue/deque.md

@@ -1417,8 +1417,8 @@ comments: true
       }
 
       /* 入队操作 */
-      void push(int num, bool isFront) {
-        final ListNode node = ListNode(num);
+      void push(int _num, bool isFront) {
+        final ListNode node = ListNode(_num);
         if (isEmpty()) {
           // 若链表为空，则令 _front 和 _rear 都指向 node
           _front = _rear = node;
@@ -1439,13 +1439,13 @@ comments: true
       }
 
       /* 队首入队 */
-      void pushFirst(int num) {
-        push(num, true);
+      void pushFirst(int _num) {
+        push(_num, true);
       }
 
       /* 队尾入队 */
-      void pushLast(int num) {
-        push(num, false);
+      void pushLast(int _num) {
+        push(_num, false);
       }
 
       /* 出队操作 */
@@ -1831,7 +1831,7 @@ comments: true
 
     /* 打印队列 */
     void printLinkedListDeque(LinkedListDeque *deque) {
-        int arr[deque->queSize];
+        int *arr = malloc(sizeof(int) * deque->queSize);
         // 拷贝链表中的数据到数组
         int i;
         DoublyListNode *node;
@@ -1840,6 +1840,7 @@ comments: true
             node = node->next;
         }
         printArray(arr, deque->queSize);
+        free(arr);
     }
     ```
 
@@ -2927,44 +2928,44 @@ comments: true
       }
 
       /* 队首入队 */
-      void pushFirst(int num) {
+      void pushFirst(int _num) {
         if (_queSize == capacity()) {
           throw Exception("双向队列已满");
         }
         // 队首指针向左移动一位
         // 通过取余操作，实现 _front 越过数组头部后回到尾部
         _front = index(_front - 1);
-        // 将 num 添加至队首
-        _nums[_front] = num;
+        // 将 _num 添加至队首
+        _nums[_front] = _num;
         _queSize++;
       }
 
       /* 队尾入队 */
-      void pushLast(int num) {
+      void pushLast(int _num) {
         if (_queSize == capacity()) {
           throw Exception("双向队列已满");
         }
         // 计算尾指针，指向队尾索引 + 1
         int rear = index(_front + _queSize);
-        // 将 num 添加至队尾
-        _nums[rear] = num;
+        // 将 _num 添加至队尾
+        _nums[rear] = _num;
         _queSize++;
       }
 
       /* 队首出队 */
       int popFirst() {
-        int num = peekFirst();
+        int _num = peekFirst();
         // 队首指针向右移动一位
         _front = index(_front + 1);
         _queSize--;
-        return num;
+        return _num;
       }
 
       /* 队尾出队 */
       int popLast() {
-        int num = peekLast();
+        int _num = peekLast();
         _queSize--;
-        return num;
+        return _num;
       }
 
       /* 访问队首元素 */
@@ -3218,16 +3219,6 @@ comments: true
         deque->queSize--;
         return num;
     }
-
-    /* 打印队列 */
-    void printArrayDeque(ArrayDeque *deque) {
-        int arr[deque->queSize];
-        // 拷贝
-        for (int i = 0, j = deque->front; i < deque->queSize; i++, j++) {
-            arr[i] = deque->nums[j % deque->queCapacity];
-        }
-        printArray(arr, deque->queSize);
-    }
     ```
 
 === "Zig"

docs/chapter_stack_and_queue/queue.md

@@ -900,9 +900,9 @@ comments: true
       }
 
       /* 入队 */
-      void push(int num) {
-        // 尾节点后添加 num
-        final node = ListNode(num);
+      void push(int _num) {
+        // 尾节点后添加 _num
+        final node = ListNode(_num);
         // 如果队列为空，则令头、尾节点都指向该节点
         if (_front == null) {
           _front = node;
@@ -917,11 +917,11 @@ comments: true
 
       /* 出队 */
       int pop() {
-        final int num = peek();
+        final int _num = peek();
         // 删除头节点
         _front = _front!.next;
         _queSize--;
-        return num;
+        return _num;
       }
 
       /* 访问队首元素 */
@@ -1101,7 +1101,7 @@ comments: true
 
     /* 打印队列 */
     void printLinkedListQueue(LinkedListQueue *queue) {
-        int arr[queue->queSize];
+        int *arr = malloc(sizeof(int) * queue->queSize);
         // 拷贝链表中的数据到数组
         int i;
         ListNode *node;
@@ -1110,6 +1110,7 @@ comments: true
             node = node->next;
         }
         printArray(arr, queue->queSize);
+        free(arr);
     }
     ```
 
@@ -1825,25 +1826,25 @@ comments: true
       }
 
       /* 入队 */
-      void push(int num) {
+      void push(int _num) {
         if (_queSize == capaCity()) {
           throw Exception("队列已满");
         }
         // 计算尾指针，指向队尾索引 + 1
         // 通过取余操作，实现 rear 越过数组尾部后回到头部
         int rear = (_front + _queSize) % capaCity();
-        // 将 num 添加至队尾
-        _nums[rear] = num;
+        // 将 _num 添加至队尾
+        _nums[rear] = _num;
         _queSize++;
       }
 
       /* 出队 */
       int pop() {
-        int num = peek();
+        int _num = peek();
         // 队首指针向后移动一位，若越过尾部则返回到数组头部
         _front = (_front + 1) % capaCity();
         _queSize--;
-        return num;
+        return _num;
       }
 
       /* 访问队首元素 */
@@ -2017,16 +2018,6 @@ comments: true
         queue->front = (queue->front + 1) % queue->queCapacity;
         queue->queSize--;
     }
-
-    /* 打印队列 */
-    void printArrayQueue(ArrayQueue *queue) {
-        int arr[queue->queSize];
-        // 拷贝
-        for (int i = 0, j = queue->front; i < queue->queSize; i++, j++) {
-            arr[i] = queue->nums[j % queue->queCapacity];
-        }
-        printArray(arr, queue->queSize);
-    }
     ```
 
 === "Zig"

docs/chapter_stack_and_queue/stack.md

@@ -827,8 +827,8 @@ comments: true
       }
 
       /* 入栈 */
-      void push(int num) {
-        final ListNode node = ListNode(num);
+      void push(int _num) {
+        final ListNode node = ListNode(_num);
         node.next = _stackPeek;
         _stackPeek = node;
         _stkSize++;
@@ -836,10 +836,10 @@ comments: true
 
       /* 出栈 */
       int pop() {
-        final int num = peek();
+        final int _num = peek();
         _stackPeek = _stackPeek!.next;
         _stkSize--;
-        return num;
+        return _num;
       }
 
       /* 访问栈顶元素 */
@@ -1495,8 +1495,8 @@ comments: true
       }
 
       /* 入栈 */
-      void push(int num) {
-        _stack.add(num);
+      void push(int _num) {
+        _stack.add(_num);
       }
 
       /* 出栈 */