diff --git a/codes/cpp/chapter_stack_and_queue/array_queue.cpp b/codes/cpp/chapter_stack_and_queue/array_queue.cpp
index 8bc6a939..14df4abd 100644
--- a/codes/cpp/chapter_stack_and_queue/array_queue.cpp
+++ b/codes/cpp/chapter_stack_and_queue/array_queue.cpp
@@ -59,7 +59,6 @@ public:
 
     /* 访问队首元素 */
     int peek() {
-        // 删除头结点
         if (empty())
             throw out_of_range("队列为空");
         return nums[front];
diff --git a/codes/java/chapter_stack_and_queue/array_queue.java b/codes/java/chapter_stack_and_queue/array_queue.java
index 620ce2db..6ffb546c 100644
--- a/codes/java/chapter_stack_and_queue/array_queue.java
+++ b/codes/java/chapter_stack_and_queue/array_queue.java
@@ -58,7 +58,6 @@ class ArrayQueue {
 
     /* 访问队首元素 */
     public int peek() {
-        // 删除头结点
         if (isEmpty())
             throw new EmptyStackException();
         return nums[front];
diff --git a/codes/javascript/chapter_stack_and_queue/array_queue.js b/codes/javascript/chapter_stack_and_queue/array_queue.js
index 902c7407..d57b7024 100644
--- a/codes/javascript/chapter_stack_and_queue/array_queue.js
+++ b/codes/javascript/chapter_stack_and_queue/array_queue.js
@@ -7,13 +7,12 @@
 
 /* 基于环形数组实现的队列 */
 class ArrayQueue {
-    #queue;           // 用于存储队列元素的数组
-    #front = 0;       // 头指针，指向队首
-    #rear = 0;        // 尾指针，指向队尾 + 1
-    #CAPACITY = 1e3;  // 默认初始容量
+    #queue;       // 用于存储队列元素的数组
+    #front = 0;   // 头指针，指向队首
+    #rear = 0;    // 尾指针，指向队尾 + 1
 
     constructor(capacity) {
-        this.#queue = new Array(capacity ?? this.CAPACITY);
+        this.#queue = new Array(capacity);
     }
 
     /* 获取队列的容量 */
@@ -52,7 +51,6 @@ class ArrayQueue {
 
     /* 访问队首元素 */
     peek() {
-        // 删除头结点
         if (this.empty())
             throw new Error("队列为空");
         return this.#queue[this.#front];
diff --git a/codes/javascript/chapter_stack_and_queue/array_stack.js b/codes/javascript/chapter_stack_and_queue/array_stack.js
index 271210bd..ba620ebd 100644
--- a/codes/javascript/chapter_stack_and_queue/array_stack.js
+++ b/codes/javascript/chapter_stack_and_queue/array_stack.js
@@ -11,6 +11,7 @@ class ArrayStack {
     constructor() {
         this.stack = [];
     }
+    
     /* 获取栈的长度 */
     get size() {
         return this.stack.length;
@@ -28,19 +29,22 @@ class ArrayStack {
 
     /* 出栈 */
     pop() {
-        if (this.empty()) throw "栈为空";
+        if (this.empty())
+            throw new Error("栈为空");
         return this.stack.pop();
     }
 
     /* 访问栈顶元素 */
     top() {
-        if (this.empty()) throw "栈为空";
+        if (this.empty())
+            throw new Error("栈为空");
         return this.stack[this.stack.length - 1];
     }
 
     /* 访问索引 index 处元素 */
     get(index) {
-        if (index >= this.size) throw "索引越界";
+        if (index >= this.size)
+            throw new Error("索引越界");
         return this.stack[index];
     }
 
diff --git a/codes/javascript/chapter_stack_and_queue/linkedlist_queue.js b/codes/javascript/chapter_stack_and_queue/linkedlist_queue.js
index cf1f3b3d..62c2a383 100644
--- a/codes/javascript/chapter_stack_and_queue/linkedlist_queue.js
+++ b/codes/javascript/chapter_stack_and_queue/linkedlist_queue.js
@@ -8,8 +8,8 @@ const ListNode = require("../include/ListNode");
 
 /* 基于链表实现的队列 */
 class LinkedListQueue {
-    #front;
-    #rear;  // 头结点 #front ，尾结点 #rear 
+    #front;  // 头结点 #front
+    #rear;   // 尾结点 #rear
     #queSize = 0;
 
     constructor() {
@@ -46,9 +46,6 @@ class LinkedListQueue {
     /* 出队 */
     poll() {
         const num = this.peek();
-        if (!this.#front) {
-            throw new Error("队列为空")
-        }
         // 删除头结点
         this.#front = this.#front.next;
         this.#queSize--;
@@ -75,6 +72,8 @@ class LinkedListQueue {
 }
 
 
+
+/* Driver Code */
 /* 初始化队列 */
 const queue = new LinkedListQueue();
 
diff --git a/codes/javascript/chapter_stack_and_queue/queue.js b/codes/javascript/chapter_stack_and_queue/queue.js
index 7d4aeeee..a443021c 100644
--- a/codes/javascript/chapter_stack_and_queue/queue.js
+++ b/codes/javascript/chapter_stack_and_queue/queue.js
@@ -7,8 +7,7 @@
 
 /* Driver Code */
 /* 初始化队列 */
-// JavaScript 没有内置的队列，可以把 Array 当作队列来使用 
-// 注意：由于是数组，所以 shift() 的时间复杂度是 O(n)
+// JavaScript 没有内置的队列，可以把 Array 当作队列来使用
 const queue = [];
 
 /* 元素入队 */
@@ -22,7 +21,7 @@ queue.push(4);
 const peek = queue[0];
 
 /* 元素出队 */
-// shift() 方法的时间复杂度为 O(n)
+// 底层是数组，因此 shift() 方法的时间复杂度为 O(n)
 const poll = queue.shift();
 
 /* 获取队列的长度 */
diff --git a/codes/javascript/chapter_stack_and_queue/stack.js b/codes/javascript/chapter_stack_and_queue/stack.js
index 1d494494..1be7980e 100644
--- a/codes/javascript/chapter_stack_and_queue/stack.js
+++ b/codes/javascript/chapter_stack_and_queue/stack.js
@@ -4,6 +4,8 @@
  * Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
  */
 
+
+/* Driver Code */
 /* 初始化栈 */
 // Javascript 没有内置的栈类，可以把 Array 当作栈来使用 
 const stack = [];
diff --git a/codes/python/chapter_stack_and_queue/array_queue.py b/codes/python/chapter_stack_and_queue/array_queue.py
index b848794b..5f3c4f3b 100644
--- a/codes/python/chapter_stack_and_queue/array_queue.py
+++ b/codes/python/chapter_stack_and_queue/array_queue.py
@@ -42,7 +42,6 @@ class ArrayQueue:
 
     """ 出队 """
     def poll(self):
-        # 删除头结点
         num = self.peek()
         # 队头指针向后移动一位，若越过尾部则返回到数组头部
         self.__front = (self.__front + 1) % self.capacity()
@@ -50,7 +49,6 @@ class ArrayQueue:
 
     """ 访问队首元素 """
     def peek(self):
-        # 删除头结点
         if self.is_empty():
             print("队列为空")
             return False
diff --git a/codes/typescript/chapter_stack_and_queue/array_queue.ts b/codes/typescript/chapter_stack_and_queue/array_queue.ts
index 789d2d99..4fb72bbb 100644
--- a/codes/typescript/chapter_stack_and_queue/array_queue.ts
+++ b/codes/typescript/chapter_stack_and_queue/array_queue.ts
@@ -34,10 +34,8 @@ class ArrayQueue {
 
     /* 入队 */
     offer(num: number): void {
-        if (this.size == this.capacity) {
-            console.log("队列已满");
-            return;
-        }
+        if (this.size == this.capacity)
+            throw new Error("队列已满");
         // 尾结点后添加 num
         this.queue[this.rear] = num;
         // 尾指针向后移动一位，越过尾部后返回到数组头部
@@ -54,16 +52,15 @@ class ArrayQueue {
 
     /* 访问队首元素 */
     peek(): number {
-        // 删除头结点
         if (this.empty())
-            throw new Error("The queue is empty!");
+            throw new Error("队列为空");
         return this.queue[this.front];
     }
 
     /* 访问指定索引元素 */
     get(index: number): number {
         if (index >= this.size)
-            throw new Error("Index out of bounds!");
+            throw new Error("索引越界");
         return this.queue[(this.front + index) % this.capacity];
     }
 
diff --git a/codes/typescript/chapter_stack_and_queue/array_stack.ts b/codes/typescript/chapter_stack_and_queue/array_stack.ts
index 93a380f4..ef6419f7 100644
--- a/codes/typescript/chapter_stack_and_queue/array_stack.ts
+++ b/codes/typescript/chapter_stack_and_queue/array_stack.ts
@@ -29,19 +29,22 @@ class ArrayStack {
 
     /* 出栈 */
     pop(): number | undefined {
-        if (this.empty()) throw new Error('栈为空');
+        if (this.empty())
+            throw new Error('栈为空');
         return this.stack.pop();
     }
 
     /* 访问栈顶元素 */
     top(): number | undefined {
-        if (this.empty()) throw new Error('栈为空');
+        if (this.empty())
+            throw new Error('栈为空');
         return this.stack[this.stack.length - 1];
     }
 
     /* 访问索引 index 处元素 */
     get(index: number): number | undefined {
-        if (index >= this.size) throw new Error('索引越界');
+        if (index >= this.size)
+            throw new Error('索引越界');
         return this.stack[index];
     }
 
diff --git a/codes/typescript/chapter_stack_and_queue/linkedlist_queue.ts b/codes/typescript/chapter_stack_and_queue/linkedlist_queue.ts
index 01e93b06..6dabdbc0 100644
--- a/codes/typescript/chapter_stack_and_queue/linkedlist_queue.ts
+++ b/codes/typescript/chapter_stack_and_queue/linkedlist_queue.ts
@@ -8,8 +8,8 @@ import ListNode from "../module/ListNode"
 
 /* 基于链表实现的队列 */
 class LinkedListQueue {
-    private front: ListNode | null;
-    private rear: ListNode | null;  // 头结点 front ，尾结点 rear 
+    private front: ListNode | null; // 头结点 front
+    private rear: ListNode | null;  // 尾结点 rear
     private queSize: number = 0;
 
     constructor() {
@@ -46,9 +46,8 @@ class LinkedListQueue {
     /* 出队 */
     poll(): number {
         const num = this.peek();
-        if (!this.front) {
-            throw new Error("No element in queue!")
-        }
+        if (!this.front)
+            throw new Error("队列为空")
         // 删除头结点
         this.front = this.front.next;
         this.queSize--;
@@ -58,7 +57,7 @@ class LinkedListQueue {
     /* 访问队首元素 */
     peek(): number {
         if (this.size === 0)
-            throw new Error("No element in queue!");
+            throw new Error("队列为空");
         return this.front!.val;
     }
 
diff --git a/codes/typescript/chapter_stack_and_queue/queue.ts b/codes/typescript/chapter_stack_and_queue/queue.ts
index 0701a9af..0b7444f6 100644
--- a/codes/typescript/chapter_stack_and_queue/queue.ts
+++ b/codes/typescript/chapter_stack_and_queue/queue.ts
@@ -6,7 +6,6 @@
 
 /* 初始化队列 */
 // TypeScript 没有内置的队列，可以把 Array 当作队列来使用 
-// 注意：由于是数组，所以 shift() 的时间复杂度是 O(n)
 const queue: number[] = [];
 
 /* 元素入队 */
@@ -20,7 +19,7 @@ queue.push(4);
 const peek = queue[0];
 
 /* 元素出队 */
-// O(n)
+// 底层是数组，因此 shift() 方法的时间复杂度为 O(n)
 const poll = queue.shift();
 
 /* 获取队列的长度 */
diff --git a/docs/chapter_stack_and_queue/queue.md b/docs/chapter_stack_and_queue/queue.md
index 860b45fd..e499a6af 100644
--- a/docs/chapter_stack_and_queue/queue.md
+++ b/docs/chapter_stack_and_queue/queue.md
@@ -144,8 +144,7 @@ comments: true
 
     ```js title="queue.js"
     /* 初始化队列 */
-    // JavaScript 没有内置的队列，可以把 Array 当作队列来使用 
-    // 注意：由于是数组，所以 shift() 的时间复杂度是 O(n)
+    // JavaScript 没有内置的队列，可以把 Array 当作队列来使用
     const queue = [];
 
     /* 元素入队 */
@@ -159,7 +158,7 @@ comments: true
     const peek = queue[0];
 
     /* 元素出队 */
-    // O(n)
+    // 底层是数组，因此 shift() 方法的时间复杂度为 O(n)
     const poll = queue.shift();
 
     /* 获取队列的长度 */
@@ -174,7 +173,6 @@ comments: true
     ```typescript title="queue.ts"
     /* 初始化队列 */
     // TypeScript 没有内置的队列，可以把 Array 当作队列来使用 
-    // 注意：由于是数组，所以 shift() 的时间复杂度是 O(n)
     const queue: number[] = [];
 
     /* 元素入队 */
@@ -188,7 +186,7 @@ comments: true
     const peek = queue[0];
 
     /* 元素出队 */
-    // O(n)
+    // 底层是数组，因此 shift() 方法的时间复杂度为 O(n)
     const poll = queue.shift();
 
     /* 获取队列的长度 */
@@ -382,19 +380,16 @@ comments: true
         // 使用内置包 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() {
@@ -404,7 +399,6 @@ comments: true
         s.data.Remove(e)
         return e.Value
     }
-
     // Peek 访问队首元素
     func (s *LinkedListQueue) Peek() any {
         if s.IsEmpty() {
@@ -413,12 +407,10 @@ 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
@@ -428,26 +420,23 @@ comments: true
 === "JavaScript"
 
     ```js title="linkedlist_queue.js"
+    /* 基于链表实现的队列 */
     class LinkedListQueue {
-        #front;
-        #rear;  // 头结点 #front ，尾结点 #rear 
+        #front;  // 头结点 #front
+        #rear;   // 尾结点 #rear
         #queSize = 0;
-
         constructor() {
             this.#front = null;
             this.#rear = null;
         }
-
         /* 获取队列的长度 */
         get size() {
             return this.#queSize;
         }
-
         /* 判断队列是否为空 */
         isEmpty() {
             return this.size === 0;
         }
-
         /* 入队 */
         offer(num) {
             // 尾结点后添加 num
@@ -463,36 +452,20 @@ comments: true
             }
             this.#queSize++;
         }
-
         /* 出队 */
         poll() {
             const num = this.peek();
-            if (!this.#front) {
-                throw new Error("No element in queue!")
-            }
             // 删除头结点
             this.#front = this.#front.next;
             this.#queSize--;
             return num;
         }
-
         /* 访问队首元素 */
         peek() {
             if (this.size === 0)
-                throw new Error("No element in queue!");
+                throw new Error("队列为空");
             return this.#front.val;
         }
-
-        /* 将链表转化为 Array 并返回 */
-        toArray() {
-            let node = this.#front;
-            const res = new Array(this.size);
-            for (let i = 0; i < res.length; i++) {
-                res[i] = node.val;
-                node = node.next;
-            }
-            return res;
-        }
     }
     ```
 
@@ -501,25 +474,21 @@ comments: true
     ```typescript title="linkedlist_queue.ts"
     /* 基于链表实现的队列 */
     class LinkedListQueue {
-        private front: ListNode | null;
-        private rear: ListNode | null;  // 头结点 front ，尾结点 rear 
+        private front: ListNode | null; // 头结点 front
+        private rear: ListNode | null;  // 尾结点 rear
         private queSize: number = 0;
-
         constructor() {
             this.front = null;
             this.rear = null;
         }
-
         /* 获取队列的长度 */
         get size(): number {
             return this.queSize;
         }
-
         /* 判断队列是否为空 */
         isEmpty(): boolean {
             return this.size === 0;
         }
-
         /* 入队 */
         offer(num: number): void {
             // 尾结点后添加 num
@@ -535,36 +504,22 @@ comments: true
             }
             this.queSize++;
         }
-
         /* 出队 */
         poll(): number {
             const num = this.peek();
-            if (!this.front) {
-                throw new Error("No element in queue!")
-            }
+            if (!this.front)
+                throw new Error("队列为空")
             // 删除头结点
             this.front = this.front.next;
             this.queSize--;
             return num;
         }
-
         /* 访问队首元素 */
         peek(): number {
             if (this.size === 0)
-                throw new Error("No element in queue!");
+                throw new Error("队列为空");
             return this.front!.val;
         }
-
-        /* 将链表转化为 Array 并返回 */
-        toArray(): number[] {
-            let node = this.front;
-            const res = new Array<number>(this.size);
-            for (let i = 0; i < res.length; i++) {
-                res[i] = node!.val;
-                node = node!.next;
-            }
-            return res;
-        }
     }
     ```
 
@@ -637,7 +592,6 @@ comments: true
         }
         /* 访问队首元素 */
         public int peek() {
-            // 删除头结点
             if (isEmpty())
                 throw new EmptyStackException();
             return nums[front];
@@ -701,7 +655,6 @@ comments: true
         }
         /* 访问队首元素 */
         int peek() {
-            // 删除头结点
             if (empty())
                 throw out_of_range("队列为空");
             return nums[front];
@@ -750,7 +703,6 @@ comments: true
 
         """ 出队 """
         def poll(self):
-            # 删除头结点
             num = self.peek()
             # 队头指针向后移动一位，若越过尾部则返回到数组头部
             self.__front = (self.__front + 1) % self.capacity()
@@ -758,7 +710,6 @@ comments: true
 
         """ 访问队首元素 """
         def peek(self):
-            # 删除头结点
             if self.is_empty():
                 print("队列为空")
                 return False
@@ -791,7 +742,6 @@ comments: true
         front    int   // 头指针，指向队首
         rear     int   // 尾指针，指向队尾 + 1
     }
-
     // NewArrayQueue 基于环形数组实现的队列
     func NewArrayQueue(capacity int) *ArrayQueue {
         return &ArrayQueue{
@@ -801,18 +751,15 @@ comments: true
             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 表示队列已满
@@ -824,7 +771,6 @@ comments: true
         // 尾指针向后移动一位，越过尾部后返回到数组头部
         q.rear = (q.rear + 1) % q.capacity
     }
-
     // Poll 出队
     func (q *ArrayQueue) Poll() any {
         if q.IsEmpty() {
@@ -835,7 +781,6 @@ comments: true
         q.front = (q.front + 1) % q.capacity
         return v
     }
-
     // Peek 访问队首元素
     func (q *ArrayQueue) Peek() any {
         if q.IsEmpty() {
@@ -851,76 +796,52 @@ comments: true
     ```js title="array_queue.js"
     /* 基于环形数组实现的队列 */
     class ArrayQueue {
-        queue;     // 用于存储队列元素的数组
-        front = 0;  // 头指针，指向队首
-        rear = 0;   // 尾指针，指向队尾 + 1
-        CAPACITY = 1e5;
-
+        #queue;       // 用于存储队列元素的数组
+        #front = 0;   // 头指针，指向队首
+        #rear = 0;    // 尾指针，指向队尾 + 1
         constructor(capacity) {
-            this.queue = new Array(capacity ?? this.CAPACITY);
+            this.#queue = new Array(capacity);
         }
-
         /* 获取队列的容量 */
         get capacity() {
-            return this.queue.length;
+            return this.#queue.length;
         }
-
         /* 获取队列的长度 */
         get size() {
             // 由于将数组看作为环形，可能 rear < front ，因此需要取余数
-            return (this.capacity + this.rear - this.front) % this.capacity;
+            return (this.capacity + this.#rear - this.#front) % this.capacity;
         }
-
         /* 判断队列是否为空 */
         empty() {
-            return this.rear - this.front == 0;
+            return this.#rear - this.#front == 0;
         }
-
         /* 入队 */
         offer(num) {
-            if (this.size == this.capacity) {
-                console.log("队列已满");
-                return;
-            }
+            if (this.size == this.capacity)
+                throw new Error("队列已满");
             // 尾结点后添加 num
-            this.queue[this.rear] = num;
+            this.#queue[this.#rear] = num;
             // 尾指针向后移动一位，越过尾部后返回到数组头部
-            this.rear = (this.rear + 1) % this.capacity;
+            this.#rear = (this.#rear + 1) % this.capacity;
         }
-
         /* 出队 */
         poll() {
             const num = this.peek();
             // 队头指针向后移动一位，若越过尾部则返回到数组头部
-            this.front = (this.front + 1) % this.capacity;
+            this.#front = (this.#front + 1) % this.capacity;
             return num;
         }
-
         /* 访问队首元素 */
         peek() {
-            // 删除头结点
             if (this.empty())
-                throw new Error("The queue is empty!");
-            return this.queue[this.front];
+                throw new Error("队列为空");
+            return this.#queue[this.#front];
         }
-
         /* 访问指定索引元素 */
         get(index) {
             if (index >= this.size)
-                throw new Error("Index out of bounds!");
-            return this.queue[(this.front + index) % this.capacity];
-        }
-
-        /* 返回 Array */
-        toArray() {
-            const siz = this.size;
-            const cap = this.capacity;
-            // 仅转换有效长度范围内的列表元素
-            const arr = new Array(siz);
-            for (let i = 0, j = this.front; i < siz; i++, j++) {
-                arr[i] = this.queue[j % cap];
-            }
-            return arr;
+                throw new Error("索引越界");
+            return this.#queue[(this.#front + index) % this.capacity];
         }
     }
     ```
@@ -928,46 +849,37 @@ comments: true
 === "TypeScript"
 
     ```typescript title="array_queue.ts"
-
     /* 基于环形数组实现的队列 */
     class ArrayQueue {
         private queue: number[];     // 用于存储队列元素的数组
         private front: number = 0;  // 头指针，指向队首
         private rear: number = 0;   // 尾指针，指向队尾 + 1
         private CAPACITY: number = 1e5;
-
         constructor(capacity?: number) {
             this.queue = new Array<number>(capacity ?? this.CAPACITY);
         }
-
         /* 获取队列的容量 */
         get capacity(): number {
             return this.queue.length;
         }
-
         /* 获取队列的长度 */
         get size(): number {
             // 由于将数组看作为环形，可能 rear < front ，因此需要取余数
             return (this.capacity + this.rear - this.front) % this.capacity;
         }
-
         /* 判断队列是否为空 */
         empty(): boolean {
             return this.rear - this.front == 0;
         }
-
         /* 入队 */
         offer(num: number): void {
-            if (this.size == this.capacity) {
-                console.log("队列已满");
-                return;
-            }
+            if (this.size == this.capacity)
+                throw new Error("队列已满");
             // 尾结点后添加 num
             this.queue[this.rear] = num;
             // 尾指针向后移动一位，越过尾部后返回到数组头部
             this.rear = (this.rear + 1) % this.capacity;
         }
-
         /* 出队 */
         poll(): number {
             const num = this.peek();
@@ -975,33 +887,18 @@ comments: true
             this.front = (this.front + 1) % this.capacity;
             return num;
         }
-
         /* 访问队首元素 */
         peek(): number {
-            // 删除头结点
             if (this.empty())
-                throw new Error("The queue is empty!");
+                throw new Error("队列为空");
             return this.queue[this.front];
         }
-
         /* 访问指定索引元素 */
         get(index: number): number {
             if (index >= this.size)
-                throw new Error("Index out of bounds!");
+                throw new Error("索引越界");
             return this.queue[(this.front + index) % this.capacity];
         }
-
-        /* 返回 Array */
-        toArray(): number[] {
-            const siz = this.size;
-            const cap = this.capacity;
-            // 仅转换有效长度范围内的列表元素
-            const arr = new Array(siz);
-            for (let i = 0, j = this.front; i < siz; i++, j++) {
-                arr[i] = this.queue[j % cap];
-            }
-            return arr;
-        }
     }
     ```
 
diff --git a/docs/chapter_stack_and_queue/stack.md b/docs/chapter_stack_and_queue/stack.md
index b78d7932..63d7353e 100644
--- a/docs/chapter_stack_and_queue/stack.md
+++ b/docs/chapter_stack_and_queue/stack.md
@@ -350,19 +350,16 @@ 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() {
@@ -372,7 +369,6 @@ comments: true
         s.data.Remove(e)
         return e.Value
     }
-
     // Peek 访问栈顶元素
     func (s *LinkedListStack) Peek() any {
         if s.IsEmpty() {
@@ -381,12 +377,10 @@ 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
@@ -613,17 +607,20 @@ comments: true
         }
         /* 出栈 */
         pop() {
-            if (this.empty()) throw "栈为空";
+            if (this.empty())
+                throw new Error("栈为空");
             return this.stack.pop();
         }
         /* 访问栈顶元素 */
         top() {
-            if (this.empty()) throw "栈为空";
+            if (this.empty())
+                throw new Error("栈为空");
             return this.stack[this.stack.length - 1];
         }
         /* 访问索引 index 处元素 */
         get(index) {
-            if (index >= this.size) throw "索引越界";
+            if (index >= this.size)
+                throw new Error("索引越界");
             return this.stack[index];
         }
     };
@@ -652,17 +649,20 @@ comments: true
         }
         /* 出栈 */
         pop(): number | undefined {
-            if (empty()) throw new Error('栈为空');
+            if (this.empty())
+                throw new Error('栈为空');
             return this.stack.pop();
         }
         /* 访问栈顶元素 */
         top(): number | undefined {
-            if (empty()) throw new Error('栈为空');
+            if (this.empty())
+                throw new Error('栈为空');
             return this.stack[this.stack.length - 1];
         }
         /* 访问索引 index 处元素 */
         get(index: number): number | undefined {
-            if (index >= size()) throw new Error('索引越界');
+            if (index >= this.size)
+                throw new Error('索引越界');
             return this.stack[index];
         }
     };