build

docs/chapter_stack_and_queue/deque.md

@@ -38,25 +38,25 @@ comments: true
 
     # 初始化双向队列
     deque: deque[int] = deque()
-    
+
     # 元素入队
     deque.append(2)      # 添加至队尾
     deque.append(5)
     deque.append(4)
     deque.appendleft(3)  # 添加至队首
     deque.appendleft(1)
-    
+
     # 访问元素
     front: int = deque[0]  # 队首元素
     rear: int = deque[-1]  # 队尾元素
-    
+
     # 元素出队
     pop_front: int = deque.popleft()  # 队首元素出队
     pop_rear: int = deque.pop()       # 队尾元素出队
-    
+
     # 获取双向队列的长度
     size: int = len(deque)
-    
+
     # 判断双向队列是否为空
     is_empty: bool = len(deque) == 0
     ```
@@ -66,25 +66,25 @@ comments: true
     ```cpp title="deque.cpp"
     /* 初始化双向队列 */
     deque<int> deque;
-    
+
     /* 元素入队 */
     deque.push_back(2);   // 添加至队尾
     deque.push_back(5);
     deque.push_back(4);
     deque.push_front(3);  // 添加至队首
     deque.push_front(1);
-    
+
     /* 访问元素 */
     int front = deque.front(); // 队首元素
     int back = deque.back();   // 队尾元素
-    
+
     /* 元素出队 */
     deque.pop_front();  // 队首元素出队
     deque.pop_back();   // 队尾元素出队
-    
+
     /* 获取双向队列的长度 */
     int size = deque.size();
-    
+
     /* 判断双向队列是否为空 */
     bool empty = deque.empty();
     ```
@@ -94,25 +94,25 @@ comments: true
     ```java title="deque.java"
     /* 初始化双向队列 */
     Deque<Integer> deque = new LinkedList<>();
-    
+
     /* 元素入队 */
     deque.offerLast(2);   // 添加至队尾
     deque.offerLast(5);
     deque.offerLast(4);
     deque.offerFirst(3);  // 添加至队首
     deque.offerFirst(1);
-    
+
     /* 访问元素 */
     int peekFirst = deque.peekFirst();  // 队首元素
     int peekLast = deque.peekLast();    // 队尾元素
-    
+
     /* 元素出队 */
     int popFirst = deque.pollFirst();  // 队首元素出队
     int popLast = deque.pollLast();    // 队尾元素出队
-    
+
     /* 获取双向队列的长度 */
     int size = deque.size();
-    
+
     /* 判断双向队列是否为空 */
     boolean isEmpty = deque.isEmpty();
     ```
@@ -123,25 +123,25 @@ comments: true
     /* 初始化双向队列 */
     // 在 C# 中，将链表 LinkedList 看作双向队列来使用
     LinkedList<int> deque = new();
-    
+
     /* 元素入队 */
     deque.AddLast(2);   // 添加至队尾
     deque.AddLast(5);
     deque.AddLast(4);
     deque.AddFirst(3);  // 添加至队首
     deque.AddFirst(1);
-    
+
     /* 访问元素 */
     int peekFirst = deque.First.Value;  // 队首元素
     int peekLast = deque.Last.Value;    // 队尾元素
-    
+
     /* 元素出队 */
     deque.RemoveFirst();  // 队首元素出队
     deque.RemoveLast();   // 队尾元素出队
-    
+
     /* 获取双向队列的长度 */
     int size = deque.Count;
-    
+
     /* 判断双向队列是否为空 */
     bool isEmpty = deque.Count == 0;
     ```
@@ -152,25 +152,25 @@ comments: true
     /* 初始化双向队列 */
     // 在 Go 中，将 list 作为双向队列使用
     deque := list.New()
-    
+
     /* 元素入队 */
     deque.PushBack(2)      // 添加至队尾
     deque.PushBack(5)
     deque.PushBack(4)
     deque.PushFront(3)     // 添加至队首
     deque.PushFront(1)
-    
+
     /* 访问元素 */
     front := deque.Front() // 队首元素
     rear := deque.Back()   // 队尾元素
-    
+
     /* 元素出队 */
     deque.Remove(front)    // 队首元素出队
     deque.Remove(rear)     // 队尾元素出队
-    
+
     /* 获取双向队列的长度 */
     size := deque.Len()
-    
+
     /* 判断双向队列是否为空 */
     isEmpty := deque.Len() == 0
     ```
@@ -339,25 +339,25 @@ comments: true
     ```kotlin title="deque.kt"
     /* 初始化双向队列 */
     val deque = LinkedList<Int>()
-    
+
     /* 元素入队 */
     deque.offerLast(2)  // 添加至队尾
     deque.offerLast(5)
     deque.offerLast(4)
     deque.offerFirst(3) // 添加至队首
     deque.offerFirst(1)
-    
+
     /* 访问元素 */
     val peekFirst = deque.peekFirst() // 队首元素
     val peekLast = deque.peekLast()   // 队尾元素
-    
+
     /* 元素出队 */
     val popFirst = deque.pollFirst() // 队首元素出队
     val popLast = deque.pollLast()   // 队尾元素出队
-    
+
     /* 获取双向队列的长度 */
     val size = deque.size
-    
+
     /* 判断双向队列是否为空 */
     val isEmpty = deque.isEmpty()
     ```
@@ -365,7 +365,32 @@ comments: true
 === "Ruby"
 
     ```ruby title="deque.rb"
+    # 初始化双向队列
+    # Ruby 没有内直的双端队列，只能把 Array 当作双端队列来使用
+    deque = []
 
+    # 元素如队
+    deque << 2
+    deque << 5
+    deque << 4
+    # 请注意，由于是数组，Array#unshift 方法的时间复杂度为 O(n)
+    deque.unshift(3)
+    deque.unshift(1)
+
+    # 访问元素
+    peek_first = deque.first
+    peek_last = deque.last
+
+    # 元素出队
+    # 请注意，由于是数组， Array#shift 方法的时间复杂度为 O(n)
+    pop_front = deque.shift
+    pop_back = deque.pop
+
+    # 获取双向队列的长度
+    size = deque.length
+
+    # 判断双向队列是否为空
+    is_empty = size.zero?
     ```
 
 === "Zig"
@@ -1874,7 +1899,7 @@ comments: true
 
     ```kotlin title="linkedlist_deque.kt"
     /* 双向链表节点 */
-    class ListNode(var value: Int) {
+    class ListNode(var _val: Int) {
         // 节点值
         var next: ListNode? = null // 后继节点引用
         var prev: ListNode? = null // 前驱节点引用
@@ -1882,9 +1907,9 @@ comments: true
 
     /* 基于双向链表实现的双向队列 */
     class LinkedListDeque {
-        private var front: ListNode? = null // 头节点 front ，尾节点 rear
-        private var rear: ListNode? = null
-        private var queSize = 0 // 双向队列的长度
+        private var front: ListNode? = null // 头节点 front
+        private var rear: ListNode? = null // 尾节点 rear
+        private var queSize: Int = 0 // 双向队列的长度
 
         /* 获取双向队列的长度 */
         fun size(): Int {
@@ -1931,12 +1956,12 @@ comments: true
 
         /* 出队操作 */
         fun pop(isFront: Boolean): Int {
-            if (isEmpty()) throw IndexOutOfBoundsException()
-
+            if (isEmpty()) 
+                throw IndexOutOfBoundsException()
             val value: Int
             // 队首出队操作
             if (isFront) {
-                value = front!!.value // 暂存头节点值
+                value = front!!._val // 暂存头节点值
                 // 删除头节点
                 val fNext = front!!.next
                 if (fNext != null) {
@@ -1946,7 +1971,7 @@ comments: true
                 front = fNext // 更新头节点
                 // 队尾出队操作
             } else {
-                value = rear!!.value // 暂存尾节点值
+                value = rear!!._val // 暂存尾节点值
                 // 删除尾节点
                 val rPrev = rear!!.prev
                 if (rPrev != null) {
@@ -1971,17 +1996,14 @@ comments: true
 
         /* 访问队首元素 */
         fun peekFirst(): Int {
-            if (isEmpty()) {
-                throw IndexOutOfBoundsException()
-
-            }
-            return front!!.value
+            if (isEmpty()) throw IndexOutOfBoundsException()
+            return front!!._val
         }
 
         /* 访问队尾元素 */
         fun peekLast(): Int {
             if (isEmpty()) throw IndexOutOfBoundsException()
-            return rear!!.value
+            return rear!!._val
         }
 
         /* 返回数组用于打印 */
@@ -1989,7 +2011,7 @@ comments: true
             var node = front
             val res = IntArray(size())
             for (i in res.indices) {
-                res[i] = node!!.value
+                res[i] = node!!._val
                 node = node.next
             }
             return res
@@ -2000,9 +2022,138 @@ comments: true
 === "Ruby"
 
     ```ruby title="linkedlist_deque.rb"
-    [class]{ListNode}-[func]{}
+    =begin
+    File: linkedlist_deque.rb
+    Created Time: 2024-04-06
+    Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+    =end
 
-    [class]{LinkedListDeque}-[func]{}
+    ### 双向链表节点
+    class ListNode
+      attr_accessor :val
+      attr_accessor :next # 后继节点引用
+      attr_accessor :prev # 前躯节点引用
+
+      ### 构造方法 ###
+      def initialize(val)
+        @val = val
+      end
+    end
+
+    ### 基于双向链表实现的双向队列 ###
+    class LinkedListDeque
+      ### 获取双向队列的长度 ###
+      attr_reader :size
+
+      ### 构造方法 ###
+      def initialize
+        @front = nil  # 头节点 front
+        @rear = nil   # 尾节点 rear
+        @size = 0     # 双向队列的长度
+      end
+
+      ### 判断双向队列是否为空 ###
+      def is_empty?
+        size.zero?
+      end
+
+      ### 入队操作 ###
+      def push(num, is_front)
+        node = ListNode.new(num)
+        # 若链表为空， 则令 front 和 rear 都指向 node
+        if is_empty?
+          @front = @rear = node
+        # 队首入队操作
+        elsif is_front
+          # 将 node 添加至链表头部
+          @front.prev = node
+          node.next = @front
+          @front = node # 更新头节点
+        # 队尾入队操作
+        else
+          # 将 node 添加至链表尾部
+          @rear.next = node
+          node.prev = @rear
+          @rear = node # 更新尾节点
+        end
+        @size += 1 # 更新队列长度
+      end
+
+      ### 队首入队 ###
+      def push_first(num)
+        push(num, true)
+      end
+
+      ### 队尾入队 ###
+      def push_last(num)
+        push(num, false)
+      end
+
+      ### 出队操作 ###
+      def pop(is_front)
+        raise IndexError, '双向队列为空' if is_empty?
+
+        # 队首出队操作
+        if is_front
+          val = @front.val # 暂存头节点值
+          # 删除头节点
+          fnext = @front.next
+          unless fnext.nil?
+            fnext.prev = nil
+            @front.next = nil
+          end
+          @front = fnext # 更新头节点
+        # 队尾出队操作
+        else
+          val = @rear.val # 暂存尾节点值
+          # 删除尾节点
+          rprev = @rear.prev
+          unless rprev.nil?
+            rprev.next = nil
+            @rear.prev = nil
+          end
+          @rear = rprev # 更新尾节点
+        end
+        @size -= 1 # 更新队列长度
+
+        val
+      end
+
+      ### 队首出队 ###
+      def pop_first
+        pop(true)
+      end
+
+      ### 队首出队 ###
+      def pop_last
+        pop(false)
+      end
+
+      ### 访问队首元素 ###
+      def peek_first
+        raise IndexError, '双向队列为空' if is_empty?
+
+        @front.val
+      end
+
+      ### 访问队尾元素 ###
+      def peek_last
+        raise IndexError, '双向队列为空' if is_empty?
+
+        @rear.val
+      end
+
+      ### 返回数组用于打印 ###
+      def to_array
+        node = @front
+        res = Array.new(size, 0)
+        for i in 0...size
+          res[i] = node.val
+          node = node.next
+        end
+        res
+      end
+    end
     ```
 
 === "Zig"
@@ -3385,11 +3536,11 @@ comments: true
 === "Kotlin"
 
     ```kotlin title="array_deque.kt"
-    /* 基于环形数组实现的双向队列 */
+    /* 构造方法 */
     class ArrayDeque(capacity: Int) {
-        private var nums = IntArray(capacity) // 用于存储双向队列元素的数组
-        private var front = 0 // 队首指针，指向队首元素
-        private var queSize = 0 // 双向队列长度
+        private var nums: IntArray = IntArray(capacity) // 用于存储双向队列元素的数组
+        private var front: Int = 0 // 队首指针，指向队首元素
+        private var queSize: Int = 0 // 双向队列长度
 
         /* 获取双向队列的容量 */
         fun capacity(): Int {
@@ -3450,7 +3601,7 @@ comments: true
             return num
         }
 
-        /* 访问队尾元素 */
+        /* 队尾出队 */
         fun popLast(): Int {
             val num = peekLast()
             queSize--
@@ -3490,7 +3641,109 @@ comments: true
 === "Ruby"
 
     ```ruby title="array_deque.rb"
-    [class]{ArrayDeque}-[func]{}
+    ### 基于环形数组实现的双向队列 ###
+    class ArrayDeque
+      ### 获取双向队列的长度 ###
+      attr_reader :size
+
+      ### 构造方法 ###
+      def initialize(capacity)
+        @nums = Array.new(capacity, 0)
+        @front = 0
+        @size = 0
+      end
+
+      ### 获取双向队列的容量 ###
+      def capacity
+        @nums.length
+      end
+
+      ### 判断双向队列是否为空 ###
+      def is_empty?
+        size.zero?
+      end
+
+      ### 队首入队 ###
+      def push_first(num)
+        if size == capacity
+          puts '双向队列已满'
+          return
+        end
+
+        # 队首指针向左移动一位
+        # 通过取余操作实现 front 越过数组头部后回到尾部
+        @front = index(@front - 1)
+        # 将 num 添加至队首
+        @nums[@front] = num
+        @size += 1
+      end
+
+      ### 队尾入队 ###
+      def push_last(num)
+        if size == capacity
+          puts '双向队列已满'
+          return
+        end
+
+        # 计算队尾指针，指向队尾索引 + 1
+        rear = index(@front + size)
+        # 将 num 添加至队尾
+        @nums[rear] = num
+        @size += 1
+      end
+
+      ### 队首出队 ###
+      def pop_first
+        num = peek_first
+        # 队首指针向后移动一位
+        @front = index(@front + 1)
+        @size -= 1
+        num
+      end
+
+      ### 队尾出队 ###
+      def pop_last
+        num = peek_last
+        @size -= 1
+        num
+      end
+
+      ### 访问队首元素 ###
+      def peek_first
+        raise IndexError, '双向队列为空' if is_empty?
+
+        @nums[@front]
+      end
+
+      ### 访问队尾元素 ###
+      def peek_last
+        raise IndexError, '双向队列为空' if is_empty?
+
+        # 计算尾元素索引
+        last = index(@front + size - 1)
+        @nums[last]
+      end
+
+      ### 返回数组用于打印 ###
+      def to_array
+        # 仅转换有效长度范围内的列表元素
+        res = []
+        for i in 0...size
+          res << @nums[index(@front + i)]
+        end
+        res
+      end
+
+      private
+
+      ### 计算环形数组索引 ###
+      def index(i)
+        # 通过取余操作实现数组首尾相连
+        # 当 i 越过数组尾部后，回到头部
+        # 当 i 越过数组头部后，回到尾部
+        (i + capacity) % capacity
+      end
+    end
     ```
 
 === "Zig"

docs/chapter_stack_and_queue/queue.md

@@ -39,23 +39,23 @@ comments: true
     # 在 Python 中，我们一般将双向队列类 deque 当作队列使用
     # 虽然 queue.Queue() 是纯正的队列类，但不太好用，因此不推荐
     que: deque[int] = deque()
-    
+
     # 元素入队
     que.append(1)
     que.append(3)
     que.append(2)
     que.append(5)
     que.append(4)
-    
+
     # 访问队首元素
     front: int = que[0]
-    
+
     # 元素出队
     pop: int = que.popleft()
-    
+
     # 获取队列的长度
     size: int = len(que)
-    
+
     # 判断队列是否为空
     is_empty: bool = len(que) == 0
     ```
@@ -65,23 +65,23 @@ comments: true
     ```cpp title="queue.cpp"
     /* 初始化队列 */
     queue<int> queue;
-    
+
     /* 元素入队 */
     queue.push(1);
     queue.push(3);
     queue.push(2);
     queue.push(5);
     queue.push(4);
-    
+
     /* 访问队首元素 */
     int front = queue.front();
-    
+
     /* 元素出队 */
     queue.pop();
-    
+
     /* 获取队列的长度 */
     int size = queue.size();
-    
+
     /* 判断队列是否为空 */
     bool empty = queue.empty();
     ```
@@ -91,23 +91,23 @@ comments: true
     ```java title="queue.java"
     /* 初始化队列 */
     Queue<Integer> queue = new LinkedList<>();
-    
+
     /* 元素入队 */
     queue.offer(1);
     queue.offer(3);
     queue.offer(2);
     queue.offer(5);
     queue.offer(4);
-    
+
     /* 访问队首元素 */
     int peek = queue.peek();
-    
+
     /* 元素出队 */
     int pop = queue.poll();
-    
+
     /* 获取队列的长度 */
     int size = queue.size();
-    
+
     /* 判断队列是否为空 */
     boolean isEmpty = queue.isEmpty();
     ```
@@ -117,23 +117,23 @@ comments: true
     ```csharp title="queue.cs"
     /* 初始化队列 */
     Queue<int> queue = new();
-    
+
     /* 元素入队 */
     queue.Enqueue(1);
     queue.Enqueue(3);
     queue.Enqueue(2);
     queue.Enqueue(5);
     queue.Enqueue(4);
-    
+
     /* 访问队首元素 */
     int peek = queue.Peek();
-    
+
     /* 元素出队 */
     int pop = queue.Dequeue();
-    
+
     /* 获取队列的长度 */
     int size = queue.Count;
-    
+
     /* 判断队列是否为空 */
     bool isEmpty = queue.Count == 0;
     ```
@@ -144,24 +144,24 @@ comments: true
     /* 初始化队列 */
     // 在 Go 中，将 list 作为队列来使用
     queue := list.New()
-    
+
     /* 元素入队 */
     queue.PushBack(1)
     queue.PushBack(3)
     queue.PushBack(2)
     queue.PushBack(5)
     queue.PushBack(4)
-    
+
     /* 访问队首元素 */
     peek := queue.Front()
-    
+
     /* 元素出队 */
     pop := queue.Front()
     queue.Remove(pop)
-    
+
     /* 获取队列的长度 */
     size := queue.Len()
-    
+
     /* 判断队列是否为空 */
     isEmpty := queue.Len() == 0
     ```
@@ -172,24 +172,24 @@ comments: true
     /* 初始化队列 */
     // Swift 没有内置的队列类，可以把 Array 当作队列来使用
     var queue: [Int] = []
-    
+
     /* 元素入队 */
     queue.append(1)
     queue.append(3)
     queue.append(2)
     queue.append(5)
     queue.append(4)
-    
+
     /* 访问队首元素 */
     let peek = queue.first!
-    
+
     /* 元素出队 */
     // 由于是数组，因此 removeFirst 的复杂度为 O(n)
     let pool = queue.removeFirst()
-    
+
     /* 获取队列的长度 */
     let size = queue.count
-    
+
     /* 判断队列是否为空 */
     let isEmpty = queue.isEmpty
     ```
@@ -200,24 +200,24 @@ comments: true
     /* 初始化队列 */
     // JavaScript 没有内置的队列，可以把 Array 当作队列来使用
     const queue = [];
-    
+
     /* 元素入队 */
     queue.push(1);
     queue.push(3);
     queue.push(2);
     queue.push(5);
     queue.push(4);
-    
+
     /* 访问队首元素 */
     const peek = queue[0];
-    
+
     /* 元素出队 */
     // 底层是数组，因此 shift() 方法的时间复杂度为 O(n)
     const pop = queue.shift();
-    
+
     /* 获取队列的长度 */
     const size = queue.length;
-    
+
     /* 判断队列是否为空 */
     const empty = queue.length === 0;
     ```
@@ -226,26 +226,26 @@ comments: true
 
     ```typescript title="queue.ts"
     /* 初始化队列 */
-    // TypeScript 没有内置的队列，可以把 Array 当作队列来使用 
+    // TypeScript 没有内置的队列，可以把 Array 当作队列来使用
     const queue: number[] = [];
-    
+
     /* 元素入队 */
     queue.push(1);
     queue.push(3);
     queue.push(2);
     queue.push(5);
     queue.push(4);
-    
+
     /* 访问队首元素 */
     const peek = queue[0];
-    
+
     /* 元素出队 */
     // 底层是数组，因此 shift() 方法的时间复杂度为 O(n)
     const pop = queue.shift();
-    
+
     /* 获取队列的长度 */
     const size = queue.length;
-    
+
     /* 判断队列是否为空 */
     const empty = queue.length === 0;
     ```
@@ -317,23 +317,23 @@ comments: true
     ```kotlin title="queue.kt"
     /* 初始化队列 */
     val queue = LinkedList<Int>()
-    
+
     /* 元素入队 */
     queue.offer(1)
     queue.offer(3)
     queue.offer(2)
     queue.offer(5)
     queue.offer(4)
-    
+
     /* 访问队首元素 */
     val peek = queue.peek()
-    
+
     /* 元素出队 */
     val pop = queue.poll()
-    
+
     /* 获取队列的长度 */
     val size = queue.size
-    
+
     /* 判断队列是否为空 */
     val isEmpty = queue.isEmpty()
     ```
@@ -341,7 +341,29 @@ comments: true
 === "Ruby"
 
     ```ruby title="queue.rb"
+    # 初始化队列
+    # Ruby 内置的队列（Thread::Queue) 没有 peek 和遍历方法，可以把 Array 当作队列来使用
+    queue = []
 
+    # 元素入队
+    queue.push(1)
+    queue.push(3)
+    queue.push(2)
+    queue.push(5)
+    queue.push(4)
+
+    # 访问队列元素
+    peek = queue.first
+
+    # 元素出队
+    # 清注意，由于是数组，Array#shift 方法时间复杂度为 O(n)
+    pop = queue.shift
+
+    # 获取队列的长度
+    size = queue.length
+
+    # 判断队列是否为空
+    is_empty = queue.empty?
     ```
 
 === "Zig"
@@ -1206,7 +1228,7 @@ comments: true
         /* 访问队首元素 */
         fun peek(): Int {
             if (isEmpty()) throw IndexOutOfBoundsException()
-            return front!!.value
+            return front!!._val
         }
 
         /* 将链表转化为 Array 并返回 */
@@ -1214,7 +1236,7 @@ comments: true
             var node = front
             val res = IntArray(size())
             for (i in res.indices) {
-                res[i] = node!!.value
+                res[i] = node!!._val
                 node = node.next
             }
             return res
@@ -1225,7 +1247,68 @@ comments: true
 === "Ruby"
 
     ```ruby title="linkedlist_queue.rb"
-    [class]{LinkedListQueue}-[func]{}
+    ### 基于链表头现的队列 ###
+    class LinkedListQueue
+      ### 获取队列的长度 ###
+      attr_reader :size
+
+      ### 构造方法 ###
+      def initialize
+        @front = nil  # 头节点 front
+        @rear = nil   # 尾节点 rear
+        @size = 0
+      end
+
+      ### 判断队列是否为空 ###
+      def is_empty?
+        @front.nil?
+      end
+
+      ### 入队 ###
+      def push(num)
+        # 在尾节点后添加 num
+        node = ListNode.new(num)
+
+        # 如果队列为空，则令头，尾节点都指向该节点
+        if @front.nil?
+          @front = node
+          @rear = node
+        # 如果队列不为空，则令该节点添加到尾节点后
+        else
+          @rear.next = node
+          @rear = node
+        end
+
+        @size += 1
+      end
+
+      ### 出队 ###
+      def pop
+        num = peek
+        # 删除头节点
+        @front = @front.next
+        @size -= 1
+        num
+      end
+
+      ### 访问队首元素 ###
+      def peek
+        raise IndexError, '队列为空' if is_empty?
+
+        @front.val
+      end
+
+      ### 将链表为 Array 并返回 ###
+      def to_array
+        queue = []
+        temp = @front
+        while temp
+          queue << temp.val
+          temp = temp.next
+        end
+        queue
+      end
+    end
     ```
 
 === "Zig"
@@ -2144,9 +2227,9 @@ comments: true
     ```kotlin title="array_queue.kt"
     /* 基于环形数组实现的队列 */
     class ArrayQueue(capacity: Int) {
-        private val nums = IntArray(capacity) // 用于存储队列元素的数组
-        private var front = 0 // 队首指针，指向队首元素
-        private var queSize = 0 // 队列长度
+        private val nums: IntArray = IntArray(capacity) // 用于存储队列元素的数组
+        private var front: Int = 0 // 队首指针，指向队首元素
+        private var queSize: Int = 0 // 队列长度
 
         /* 获取队列的容量 */
         fun capacity(): Int {
@@ -2211,7 +2294,69 @@ comments: true
 === "Ruby"
 
     ```ruby title="array_queue.rb"
-    [class]{ArrayQueue}-[func]{}
+    ### 基于环形数组实现的队列 ###
+    class ArrayQueue
+      ### 获取队列的长度 ###
+      attr_reader :size
+
+      ### 构造方法 ###
+      def initialize(size)
+        @nums = Array.new(size, 0) # 用于存储队列元素的数组
+        @front = 0 # 队首指针，指向队首元素
+        @size = 0 # 队列长度
+      end
+
+      ### 获取队列的容量 ###
+      def capacity
+        @nums.length
+      end
+
+      ### 判断队列是否为空 ###
+      def is_empty?
+        size.zero?
+      end
+
+      ### 入队 ###
+      def push(num)
+        raise IndexError, '队列已满' if size == capacity
+
+        # 计算队尾指针，指向队尾索引 + 1
+        # 通过取余操作实现 rear 越过数组尾部后回到头部
+        rear = (@front + size) % capacity
+        # 将 num 添加至队尾
+        @nums[rear] = num
+        @size += 1
+      end
+
+      ### 出队 ###
+      def pop
+        num = peek
+        # 队首指针向后移动一位，若越过尾部，则返回到数组头部
+        @front = (@front + 1) % capacity
+        @size -= 1
+        num
+      end
+
+      ### 访问队首元素 ###
+      def peek
+        raise IndexError, '队列为空' if is_empty?
+
+        @nums[@front]
+      end
+
+      ### 返回列表用于打印 ###
+      def to_array
+        res = Array.new(size, 0)
+        j = @front
+
+        for i in 0...size
+          res[i] = @nums[j % capacity]
+          j += 1
+        end
+
+        res
+      end
+    end
     ```
 
 === "Zig"

docs/chapter_stack_and_queue/stack.md

@@ -36,25 +36,25 @@ comments: true
 
     ```python title="stack.py"
     # 初始化栈
-    # Python 没有内置的栈类，可以把 list 当作栈来使用 
+    # Python 没有内置的栈类，可以把 list 当作栈来使用
     stack: list[int] = []
-    
+
     # 元素入栈
     stack.append(1)
     stack.append(3)
     stack.append(2)
     stack.append(5)
     stack.append(4)
-    
+
     # 访问栈顶元素
     peek: int = stack[-1]
-    
+
     # 元素出栈
     pop: int = stack.pop()
-    
+
     # 获取栈的长度
     size: int = len(stack)
-    
+
     # 判断是否为空
     is_empty: bool = len(stack) == 0
     ```
@@ -64,23 +64,23 @@ comments: true
     ```cpp title="stack.cpp"
     /* 初始化栈 */
     stack<int> stack;
-    
+
     /* 元素入栈 */
     stack.push(1);
     stack.push(3);
     stack.push(2);
     stack.push(5);
     stack.push(4);
-    
+
     /* 访问栈顶元素 */
     int top = stack.top();
-    
+
     /* 元素出栈 */
     stack.pop(); // 无返回值
-    
+
     /* 获取栈的长度 */
     int size = stack.size();
-    
+
     /* 判断是否为空 */
     bool empty = stack.empty();
     ```
@@ -116,23 +116,23 @@ comments: true
     ```csharp title="stack.cs"
     /* 初始化栈 */
     Stack<int> stack = new();
-    
+
     /* 元素入栈 */
     stack.Push(1);
     stack.Push(3);
     stack.Push(2);
     stack.Push(5);
     stack.Push(4);
-    
+
     /* 访问栈顶元素 */
     int peek = stack.Peek();
-    
+
     /* 元素出栈 */
     int pop = stack.Pop();
-    
+
     /* 获取栈的长度 */
     int size = stack.Count;
-    
+
     /* 判断是否为空 */
     bool isEmpty = stack.Count == 0;
     ```
@@ -143,24 +143,24 @@ comments: true
     /* 初始化栈 */
     // 在 Go 中，推荐将 Slice 当作栈来使用
     var stack []int
-    
+
     /* 元素入栈 */
     stack = append(stack, 1)
     stack = append(stack, 3)
     stack = append(stack, 2)
     stack = append(stack, 5)
     stack = append(stack, 4)
-    
+
     /* 访问栈顶元素 */
     peek := stack[len(stack)-1]
-    
+
     /* 元素出栈 */
     pop := stack[len(stack)-1]
     stack = stack[:len(stack)-1]
-    
+
     /* 获取栈的长度 */
     size := len(stack)
-    
+
     /* 判断是否为空 */
     isEmpty := len(stack) == 0
     ```
@@ -171,23 +171,23 @@ comments: true
     /* 初始化栈 */
     // Swift 没有内置的栈类，可以把 Array 当作栈来使用
     var stack: [Int] = []
-    
+
     /* 元素入栈 */
     stack.append(1)
     stack.append(3)
     stack.append(2)
     stack.append(5)
     stack.append(4)
-    
+
     /* 访问栈顶元素 */
     let peek = stack.last!
-    
+
     /* 元素出栈 */
     let pop = stack.removeLast()
-    
+
     /* 获取栈的长度 */
     let size = stack.count
-    
+
     /* 判断是否为空 */
     let isEmpty = stack.isEmpty
     ```
@@ -196,25 +196,25 @@ comments: true
 
     ```javascript title="stack.js"
     /* 初始化栈 */
-    // JavaScript 没有内置的栈类，可以把 Array 当作栈来使用 
+    // JavaScript 没有内置的栈类，可以把 Array 当作栈来使用
     const stack = [];
-    
+
     /* 元素入栈 */
     stack.push(1);
     stack.push(3);
     stack.push(2);
     stack.push(5);
     stack.push(4);
-    
+
     /* 访问栈顶元素 */
     const peek = stack[stack.length-1];
-    
+
     /* 元素出栈 */
     const pop = stack.pop();
-    
+
     /* 获取栈的长度 */
     const size = stack.length;
-    
+
     /* 判断是否为空 */
     const is_empty = stack.length === 0;
     ```
@@ -223,25 +223,25 @@ comments: true
 
     ```typescript title="stack.ts"
     /* 初始化栈 */
-    // TypeScript 没有内置的栈类，可以把 Array 当作栈来使用 
+    // TypeScript 没有内置的栈类，可以把 Array 当作栈来使用
     const stack: number[] = [];
-    
+
     /* 元素入栈 */
     stack.push(1);
     stack.push(3);
     stack.push(2);
     stack.push(5);
     stack.push(4);
-    
+
     /* 访问栈顶元素 */
     const peek = stack[stack.length - 1];
-    
+
     /* 元素出栈 */
     const pop = stack.pop();
-    
+
     /* 获取栈的长度 */
     const size = stack.length;
-    
+
     /* 判断是否为空 */
     const is_empty = stack.length === 0;
     ```
@@ -311,23 +311,23 @@ comments: true
     ```kotlin title="stack.kt"
     /* 初始化栈 */
     val stack = Stack<Int>()
-    
+
     /* 元素入栈 */
     stack.push(1)
     stack.push(3)
     stack.push(2)
     stack.push(5)
     stack.push(4)
-    
+
     /* 访问栈顶元素 */
     val peek = stack.peek()
-    
+
     /* 元素出栈 */
     val pop = stack.pop()
-    
+
     /* 获取栈的长度 */
     val size = stack.size
-    
+
     /* 判断是否为空 */
     val isEmpty = stack.isEmpty()
     ```
@@ -335,7 +335,28 @@ comments: true
 === "Ruby"
 
     ```ruby title="stack.rb"
+    # 初始化栈
+    # Ruby 没有内置的栈类，可以把 Array 当作栈来使用
+    stack = []
 
+    # 元素入栈
+    stack << 1
+    stack << 3
+    stack << 2
+    stack << 5
+    stack << 4
+
+    # 访问栈顶元素
+    peek = stack.last
+
+    # 元素出栈
+    pop = stack.pop
+
+    # 获取栈的长度
+    size = stack.length
+
+    # 判断是否为空
+    is_empty = stack.empty?
     ```
 
 === "Zig"
@@ -1078,7 +1099,7 @@ comments: true
         /* 访问栈顶元素 */
         fun peek(): Int? {
             if (isEmpty()) throw IndexOutOfBoundsException()
-            return stackPeek?.value
+            return stackPeek?._val
         }
 
         /* 将 List 转化为 Array 并返回 */
@@ -1086,7 +1107,7 @@ comments: true
             var node = stackPeek
             val res = IntArray(size())
             for (i in res.size - 1 downTo 0) {
-                res[i] = node?.value!!
+                res[i] = node?._val!!
                 node = node.next
             }
             return res
@@ -1097,7 +1118,54 @@ comments: true
 === "Ruby"
 
     ```ruby title="linkedlist_stack.rb"
-    [class]{LinkedListStack}-[func]{}
+    ### 基于链表实现的栈 ###
+    class LinkedListStack
+      attr_reader :size
+
+      ### 构造方法 ###
+      def initialize
+        @size = 0
+      end
+
+      ### 判断栈是否为空 ###
+      def is_empty?
+        @peek.nil?
+      end
+
+      ### 入栈 ###
+      def push(val)
+        node = ListNode.new(val)
+        node.next = @peek
+        @peek = node
+        @size += 1
+      end
+
+      ### 出栈 ###
+      def pop
+        num = peek
+        @peek = @peek.next
+        @size -= 1
+        num
+      end
+
+      ### 访问栈顶元素 ###
+      def peek
+        raise IndexError, '栈为空' if is_empty?
+
+        @peek.val
+      end
+
+      ### 将链表转化为 Array 并反回 ###
+      def to_array
+        arr = []
+        node = @peek
+        while node
+          arr << node.val
+          node = node.next
+        end
+        arr.reverse
+      end
+    end
     ```
 
 === "Zig"
@@ -1738,7 +1806,7 @@ comments: true
     /* 基于数组实现的栈 */
     class ArrayStack {
         // 初始化列表（动态数组）
-        private val stack = ArrayList<Int>()
+        private val stack = mutableListOf<Int>()
 
         /* 获取栈的长度 */
         fun size(): Int {
@@ -1769,7 +1837,7 @@ comments: true
 
         /* 将 List 转化为 Array 并返回 */
         fun toArray(): Array<Any> {
-            return stack.toArray()
+            return stack.toTypedArray()
         }
     }
     ```
@@ -1777,7 +1845,47 @@ comments: true
 === "Ruby"
 
     ```ruby title="array_stack.rb"
-    [class]{ArrayStack}-[func]{}
+    ### 基于数组实现的栈 ###
+    class ArrayStack
+      ### 构造方法 ###
+      def initialize
+        @stack = []
+      end
+
+      ### 获取栈的长度 ###
+      def size
+        @stack.length
+      end
+
+      ### 判断栈是否为空 ###
+      def is_empty?
+        @stack.empty?
+      end
+
+      ### 入栈 ###
+      def push(item)
+        @stack << item
+      end
+
+      ### 出栈 ###
+      def pop
+        raise IndexError, '栈为空' if is_empty?
+
+        @stack.pop
+      end
+
+      ### 访问栈顶元素 ###
+      def peek
+        raise IndexError, '栈为空' if is_empty?
+
+        @stack.last
+      end
+
+      ### 返回列表用于打印 ###
+      def to_array
+        @stack
+      end
+    end
     ```
 
 === "Zig"