diff --git a/docs/chapter_stack_and_queue/deque.md b/docs/chapter_stack_and_queue/deque.md
index 7811b4d08..742ffe9a0 100644
--- a/docs/chapter_stack_and_queue/deque.md
+++ b/docs/chapter_stack_and_queue/deque.md
@@ -28,25 +28,25 @@
 
     # 初始化双向队列
     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
     ```
@@ -56,25 +56,25 @@
     ```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();
     ```
@@ -84,25 +84,25 @@
     ```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();
     ```
@@ -113,25 +113,25 @@
     /* 初始化双向队列 */
     // 在 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;
     ```
@@ -142,25 +142,25 @@
     /* 初始化双向队列 */
     // 在 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
     ```
@@ -329,25 +329,25 @@
     ```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()
     ```
@@ -355,7 +355,32 @@
 === "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"
diff --git a/docs/chapter_stack_and_queue/queue.md b/docs/chapter_stack_and_queue/queue.md
index 07340d577..5c695b8dd 100755
--- a/docs/chapter_stack_and_queue/queue.md
+++ b/docs/chapter_stack_and_queue/queue.md
@@ -29,23 +29,23 @@
     # 在 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
     ```
@@ -55,23 +55,23 @@
     ```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();
     ```
@@ -81,23 +81,23 @@
     ```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();
     ```
@@ -107,23 +107,23 @@
     ```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;
     ```
@@ -134,24 +134,24 @@
     /* 初始化队列 */
     // 在 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
     ```
@@ -162,24 +162,24 @@
     /* 初始化队列 */
     // 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
     ```
@@ -190,24 +190,24 @@
     /* 初始化队列 */
     // 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;
     ```
@@ -216,26 +216,26 @@
 
     ```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;
     ```
@@ -307,23 +307,23 @@
     ```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()
     ```
@@ -331,7 +331,29 @@
 === "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"
diff --git a/docs/chapter_stack_and_queue/stack.md b/docs/chapter_stack_and_queue/stack.md
index 18145e24b..e6d651a06 100755
--- a/docs/chapter_stack_and_queue/stack.md
+++ b/docs/chapter_stack_and_queue/stack.md
@@ -26,25 +26,25 @@
 
     ```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
     ```
@@ -54,23 +54,23 @@
     ```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();
     ```
@@ -106,23 +106,23 @@
     ```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;
     ```
@@ -133,24 +133,24 @@
     /* 初始化栈 */
     // 在 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
     ```
@@ -161,23 +161,23 @@
     /* 初始化栈 */
     // 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
     ```
@@ -186,25 +186,25 @@
 
     ```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;
     ```
@@ -213,25 +213,25 @@
 
     ```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;
     ```
@@ -301,23 +301,23 @@
     ```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()
     ```
@@ -325,7 +325,28 @@
 === "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"