From e4784ba9394060d89144f4709cae9e2d640a5647 Mon Sep 17 00:00:00 2001 From: khoaxuantu <68913255+khoaxuantu@users.noreply.github.com> Date: Sun, 7 Apr 2024 17:58:56 +0700 Subject: [PATCH] feat: add ruby code blocks - chapter stack and queue (#1234) --- docs/chapter_stack_and_queue/deque.md | 85 ++++++++++++------- docs/chapter_stack_and_queue/queue.md | 114 +++++++++++++++----------- docs/chapter_stack_and_queue/stack.md | 107 ++++++++++++++---------- 3 files changed, 187 insertions(+), 119 deletions(-) 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 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 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 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() - + /* 元素入队 */ 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 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 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 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() - + /* 元素入队 */ 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 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 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() - + /* 元素入栈 */ 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"