build

build/chapter_stack_and_queue/deque.md

@@ -331,26 +331,26 @@ comments: true
             prev = next = null;
         }
     }
-    
+
     /* 基于双向链表实现的双向队列 */
     class LinkedListDeque {
-    private ListNode front, rear; // 头结点 front ，尾结点 rear
-    private int size = 0;         // 双向队列的长度
-    
+        private ListNode front, rear; // 头结点 front ，尾结点 rear
+        private int size = 0;         // 双向队列的长度
+
         public LinkedListDeque() {
             front = rear = null;
         }
-    
+
         /* 获取双向队列的长度 */
         public int size() {
             return size;
         }
-    
+
         /* 判断双向队列是否为空 */
         public boolean isEmpty() {
             return size() == 0;
         }
-    
+
         /* 入队操作 */
         private void push(int num, boolean isFront) {
             ListNode node = new ListNode(num);
@@ -372,17 +372,17 @@ comments: true
             }
             size++; // 更新队列长度
         }
-    
+
         /* 队首入队 */
         public void pushFirst(int num) {
             push(num, true);
         }
-    
+
         /* 队尾入队 */
         public void pushLast(int num) {
             push(num, false);
         }
-    
+
         /* 出队操作 */
         private Integer poll(boolean isFront) {
             // 若队列为空，直接返回 null
@@ -413,26 +413,41 @@ comments: true
             size--; // 更新队列长度
             return val;
         }
-    
+
         /* 队首出队 */
         public Integer pollFirst() {
             return poll(true);
         }
-    
+
         /* 队尾出队 */
         public Integer pollLast() {
             return poll(false);
         }
-    
+
         /* 访问队首元素 */
         public Integer peekFirst() {
             return isEmpty() ? null : front.val;
         }
-    
+
         /* 访问队尾元素 */
         public Integer peekLast() {
             return isEmpty() ? null : rear.val;
         }
+
+        /* 打印双向队列 */
+        public void print() {
+            if (isEmpty()) {
+                System.out.println("[ ]");
+                return;
+            }
+            List<String> list = new ArrayList<>();
+            ListNode head = front;
+            while (head != null) {
+                list.add(String.valueOf(head.val));
+                head = head.next;
+            }
+            System.out.println("[" + String.join(", ", list) + "]");
+        }
     }
     ```
 

build/chapter_stack_and_queue/queue.md

@@ -288,19 +288,22 @@ comments: true
     class LinkedListQueue {
         private ListNode front, rear;  // 头结点 front ，尾结点 rear 
         private int queSize = 0;
-    
+
         public LinkedListQueue() {
             front = null;
             rear = null;
         }
+
         /* 获取队列的长度 */
         public int size() {
             return queSize;
         }
+
         /* 判断队列是否为空 */
         public boolean isEmpty() {
             return size() == 0;
         }
+
         /* 入队 */
         public void push(int num) {
             // 尾结点后添加 num
@@ -316,6 +319,7 @@ comments: true
             }
             queSize++;
         }
+
         /* 出队 */
         public int poll() {
             int num = peek();
@@ -324,12 +328,24 @@ comments: true
             queSize--;
             return num;
         }
+
         /* 访问队首元素 */
         public int peek() {
             if (size() == 0)
                 throw new EmptyStackException();
             return front.val;
         }
+
+        /* 将链表转化为 Array 并返回 */
+        public int[] toArray() {
+            ListNode node = front;
+            int[] res = new int[size()];
+            for (int i = 0; i < res.length; i++) {
+                res[i] = node.val;
+                node = node.next;
+            }
+            return res;
+        }
     }
     ```
 
@@ -815,6 +831,16 @@ comments: true
                 throw new EmptyStackException();
             return nums[front];
         }
+
+        /* 返回数组 */
+        public int[] toArray() {
+            // 仅转换有效长度范围内的列表元素
+            int[] res = new int[queSize];
+            for (int i = 0, j = front; i < queSize; i++, j++) {
+                res[i] = nums[j % capacity()];
+            }
+            return res;
+        }
     }
     ```
 

build/chapter_stack_and_queue/stack.md

@@ -291,17 +291,21 @@ comments: true
     class LinkedListStack {
         private ListNode stackPeek;  // 将头结点作为栈顶
         private int stkSize = 0;   // 栈的长度
+        
         public LinkedListStack() {
             stackPeek = null;
         }
+
         /* 获取栈的长度 */
         public int size() {
             return stkSize;
         }
+
         /* 判断栈是否为空 */
         public boolean isEmpty() {
             return size() == 0;
         }
+
         /* 入栈 */
         public void push(int num) {
             ListNode node = new ListNode(num);
@@ -309,6 +313,7 @@ comments: true
             stackPeek = node;
             stkSize++;
         }
+
         /* 出栈 */
         public int pop() {
             int num = peek();
@@ -316,12 +321,24 @@ comments: true
             stkSize--;
             return num;
         }
+
         /* 访问栈顶元素 */
         public int peek() {
             if (size() == 0)
                 throw new EmptyStackException();
             return stackPeek.val;
         }
+
+        /* 将 List 转化为 Array 并返回 */
+        public int[] toArray() {
+            ListNode node = stackPeek;
+            int[] res = new int[size()];
+            for (int i = res.length - 1; i >= 0; i--) {
+                res[i] = node.val;
+                node = node.next;
+            }
+            return res;
+        }
     }
     ```
 
@@ -730,30 +747,40 @@ comments: true
             // 初始化列表（动态数组）
             stack = new ArrayList<>();
         }
+
         /* 获取栈的长度 */
         public int size() {
             return stack.size();
         }
+
         /* 判断栈是否为空 */
         public boolean isEmpty() {
             return size() == 0;
         }
+
         /* 入栈 */
         public void push(int num) {
             stack.add(num);
         }
+
         /* 出栈 */
         public int pop() {
             if (isEmpty())
                 throw new EmptyStackException();
             return stack.remove(size() - 1);
         }
+
         /* 访问栈顶元素 */
         public int peek() {
             if (isEmpty())
                 throw new EmptyStackException();
             return stack.get(size() - 1);
         }
+
+        /* 将 List 转化为 Array 并返回 */
+        public Object[] toArray() {
+            return stack.toArray();
+        }
     }
     ```