fuhouyin/hello-algo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: add ruby code blocks - chapter stack and queue (#1234)

Browse Source
This commit is contained in:
khoaxuantu 2024-04-07 17:58:56 +07:00 committed by GitHub
parent 5725b8a0f1
commit e4784ba939
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
3 changed files with 187 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

85
docs/chapter_stack_and_queue/deque.md
View File

@ -28,25 +28,25 @@
# 初始化双向队列 # 初始化双向队列
deque: deque[int] = deque() deque: deque[int] = deque()
# 元素入队 # 元素入队
deque.append(2) # 添加至队尾 deque.append(2) # 添加至队尾
deque.append(5) deque.append(5)
deque.append(4) deque.append(4)
deque.appendleft(3) # 添加至队首 deque.appendleft(3) # 添加至队首
deque.appendleft(1) deque.appendleft(1)
# 访问元素 # 访问元素
front: int = deque[0] # 队首元素 front: int = deque[0] # 队首元素
rear: int = deque[-1] # 队尾元素 rear: int = deque[-1] # 队尾元素
# 元素出队 # 元素出队
pop_front: int = deque.popleft() # 队首元素出队 pop_front: int = deque.popleft() # 队首元素出队
pop_rear: int = deque.pop() # 队尾元素出队 pop_rear: int = deque.pop() # 队尾元素出队
# 获取双向队列的长度 # 获取双向队列的长度
size: int = len(deque) size: int = len(deque)
# 判断双向队列是否为空 # 判断双向队列是否为空
is_empty: bool = len(deque) == 0 is_empty: bool = len(deque) == 0
``` ```
@ -56,25 +56,25 @@
```cpp title="deque.cpp" ```cpp title="deque.cpp"
/* 初始化双向队列 */ /* 初始化双向队列 */
deque<int> deque; deque<int> deque;
/* 元素入队 */ /* 元素入队 */
deque.push_back(2); // 添加至队尾 deque.push_back(2); // 添加至队尾
deque.push_back(5); deque.push_back(5);
deque.push_back(4); deque.push_back(4);
deque.push_front(3); // 添加至队首 deque.push_front(3); // 添加至队首
deque.push_front(1); deque.push_front(1);
/* 访问元素 */ /* 访问元素 */
int front = deque.front(); // 队首元素 int front = deque.front(); // 队首元素
int back = deque.back(); // 队尾元素 int back = deque.back(); // 队尾元素
/* 元素出队 */ /* 元素出队 */
deque.pop_front(); // 队首元素出队 deque.pop_front(); // 队首元素出队
deque.pop_back(); // 队尾元素出队 deque.pop_back(); // 队尾元素出队
/* 获取双向队列的长度 */ /* 获取双向队列的长度 */
int size = deque.size(); int size = deque.size();
/* 判断双向队列是否为空 */ /* 判断双向队列是否为空 */
bool empty = deque.empty(); bool empty = deque.empty();
``` ```
@ -84,25 +84,25 @@
```java title="deque.java" ```java title="deque.java"
/* 初始化双向队列 */ /* 初始化双向队列 */
Deque<Integer> deque = new LinkedList<>(); Deque<Integer> deque = new LinkedList<>();
/* 元素入队 */ /* 元素入队 */
deque.offerLast(2); // 添加至队尾 deque.offerLast(2); // 添加至队尾
deque.offerLast(5); deque.offerLast(5);
deque.offerLast(4); deque.offerLast(4);
deque.offerFirst(3); // 添加至队首 deque.offerFirst(3); // 添加至队首
deque.offerFirst(1); deque.offerFirst(1);
/* 访问元素 */ /* 访问元素 */
int peekFirst = deque.peekFirst(); // 队首元素 int peekFirst = deque.peekFirst(); // 队首元素
int peekLast = deque.peekLast(); // 队尾元素 int peekLast = deque.peekLast(); // 队尾元素
/* 元素出队 */ /* 元素出队 */
int popFirst = deque.pollFirst(); // 队首元素出队 int popFirst = deque.pollFirst(); // 队首元素出队
int popLast = deque.pollLast(); // 队尾元素出队 int popLast = deque.pollLast(); // 队尾元素出队
/* 获取双向队列的长度 */ /* 获取双向队列的长度 */
int size = deque.size(); int size = deque.size();
/* 判断双向队列是否为空 */ /* 判断双向队列是否为空 */
boolean isEmpty = deque.isEmpty(); boolean isEmpty = deque.isEmpty();
``` ```
@ -113,25 +113,25 @@
/* 初始化双向队列 */ /* 初始化双向队列 */
// 在 C# 中，将链表 LinkedList 看作双向队列来使用 // 在 C# 中，将链表 LinkedList 看作双向队列来使用
LinkedList<int> deque = new(); LinkedList<int> deque = new();
/* 元素入队 */ /* 元素入队 */
deque.AddLast(2); // 添加至队尾 deque.AddLast(2); // 添加至队尾
deque.AddLast(5); deque.AddLast(5);
deque.AddLast(4); deque.AddLast(4);
deque.AddFirst(3); // 添加至队首 deque.AddFirst(3); // 添加至队首
deque.AddFirst(1); deque.AddFirst(1);
/* 访问元素 */ /* 访问元素 */
int peekFirst = deque.First.Value; // 队首元素 int peekFirst = deque.First.Value; // 队首元素
int peekLast = deque.Last.Value; // 队尾元素 int peekLast = deque.Last.Value; // 队尾元素
/* 元素出队 */ /* 元素出队 */
deque.RemoveFirst(); // 队首元素出队 deque.RemoveFirst(); // 队首元素出队
deque.RemoveLast(); // 队尾元素出队 deque.RemoveLast(); // 队尾元素出队
/* 获取双向队列的长度 */ /* 获取双向队列的长度 */
int size = deque.Count; int size = deque.Count;
/* 判断双向队列是否为空 */ /* 判断双向队列是否为空 */
bool isEmpty = deque.Count == 0; bool isEmpty = deque.Count == 0;
``` ```
@ -142,25 +142,25 @@
/* 初始化双向队列 */ /* 初始化双向队列 */
// 在 Go 中，将 list 作为双向队列使用 // 在 Go 中，将 list 作为双向队列使用
deque := list.New() deque := list.New()
/* 元素入队 */ /* 元素入队 */
deque.PushBack(2) // 添加至队尾 deque.PushBack(2) // 添加至队尾
deque.PushBack(5) deque.PushBack(5)
deque.PushBack(4) deque.PushBack(4)
deque.PushFront(3) // 添加至队首 deque.PushFront(3) // 添加至队首
deque.PushFront(1) deque.PushFront(1)
/* 访问元素 */ /* 访问元素 */
front := deque.Front() // 队首元素 front := deque.Front() // 队首元素
rear := deque.Back() // 队尾元素 rear := deque.Back() // 队尾元素
/* 元素出队 */ /* 元素出队 */
deque.Remove(front) // 队首元素出队 deque.Remove(front) // 队首元素出队
deque.Remove(rear) // 队尾元素出队 deque.Remove(rear) // 队尾元素出队
/* 获取双向队列的长度 */ /* 获取双向队列的长度 */
size := deque.Len() size := deque.Len()
/* 判断双向队列是否为空 */ /* 判断双向队列是否为空 */
isEmpty := deque.Len() == 0 isEmpty := deque.Len() == 0
``` ```
@ -329,25 +329,25 @@
```kotlin title="deque.kt" ```kotlin title="deque.kt"
/* 初始化双向队列 */ /* 初始化双向队列 */
val deque = LinkedList<Int>() val deque = LinkedList<Int>()
/* 元素入队 */ /* 元素入队 */
deque.offerLast(2) // 添加至队尾 deque.offerLast(2) // 添加至队尾
deque.offerLast(5) deque.offerLast(5)
deque.offerLast(4) deque.offerLast(4)
deque.offerFirst(3) // 添加至队首 deque.offerFirst(3) // 添加至队首
deque.offerFirst(1) deque.offerFirst(1)
/* 访问元素 */ /* 访问元素 */
val peekFirst = deque.peekFirst() // 队首元素 val peekFirst = deque.peekFirst() // 队首元素
val peekLast = deque.peekLast() // 队尾元素 val peekLast = deque.peekLast() // 队尾元素
/* 元素出队 */ /* 元素出队 */
val popFirst = deque.pollFirst() // 队首元素出队 val popFirst = deque.pollFirst() // 队首元素出队
val popLast = deque.pollLast() // 队尾元素出队 val popLast = deque.pollLast() // 队尾元素出队
/* 获取双向队列的长度 */ /* 获取双向队列的长度 */
val size = deque.size val size = deque.size
/* 判断双向队列是否为空 */ /* 判断双向队列是否为空 */
val isEmpty = deque.isEmpty() val isEmpty = deque.isEmpty()
``` ```
@ -355,7 +355,32 @@
=== "Ruby" === "Ruby"
```ruby title="deque.rb" ```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" === "Zig"

114
docs/chapter_stack_and_queue/queue.md
View File

@ -29,23 +29,23 @@
# 在 Python 中，我们一般将双向队列类 deque 当作队列使用 # 在 Python 中，我们一般将双向队列类 deque 当作队列使用
# 虽然 queue.Queue() 是纯正的队列类，但不太好用，因此不推荐 # 虽然 queue.Queue() 是纯正的队列类，但不太好用，因此不推荐
que: deque[int] = deque() que: deque[int] = deque()
# 元素入队 # 元素入队
que.append(1) que.append(1)
que.append(3) que.append(3)
que.append(2) que.append(2)
que.append(5) que.append(5)
que.append(4) que.append(4)
# 访问队首元素 # 访问队首元素
front: int = que[0] front: int = que[0]
# 元素出队 # 元素出队
pop: int = que.popleft() pop: int = que.popleft()
# 获取队列的长度 # 获取队列的长度
size: int = len(que) size: int = len(que)
# 判断队列是否为空 # 判断队列是否为空
is_empty: bool = len(que) == 0 is_empty: bool = len(que) == 0
``` ```
@ -55,23 +55,23 @@
```cpp title="queue.cpp" ```cpp title="queue.cpp"
/* 初始化队列 */ /* 初始化队列 */
queue<int> queue; queue<int> queue;
/* 元素入队 */ /* 元素入队 */
queue.push(1); queue.push(1);
queue.push(3); queue.push(3);
queue.push(2); queue.push(2);
queue.push(5); queue.push(5);
queue.push(4); queue.push(4);
/* 访问队首元素 */ /* 访问队首元素 */
int front = queue.front(); int front = queue.front();
/* 元素出队 */ /* 元素出队 */
queue.pop(); queue.pop();
/* 获取队列的长度 */ /* 获取队列的长度 */
int size = queue.size(); int size = queue.size();
/* 判断队列是否为空 */ /* 判断队列是否为空 */
bool empty = queue.empty(); bool empty = queue.empty();
``` ```
@ -81,23 +81,23 @@
```java title="queue.java" ```java title="queue.java"
/* 初始化队列 */ /* 初始化队列 */
Queue<Integer> queue = new LinkedList<>(); Queue<Integer> queue = new LinkedList<>();
/* 元素入队 */ /* 元素入队 */
queue.offer(1); queue.offer(1);
queue.offer(3); queue.offer(3);
queue.offer(2); queue.offer(2);
queue.offer(5); queue.offer(5);
queue.offer(4); queue.offer(4);
/* 访问队首元素 */ /* 访问队首元素 */
int peek = queue.peek(); int peek = queue.peek();
/* 元素出队 */ /* 元素出队 */
int pop = queue.poll(); int pop = queue.poll();
/* 获取队列的长度 */ /* 获取队列的长度 */
int size = queue.size(); int size = queue.size();
/* 判断队列是否为空 */ /* 判断队列是否为空 */
boolean isEmpty = queue.isEmpty(); boolean isEmpty = queue.isEmpty();
``` ```
@ -107,23 +107,23 @@
```csharp title="queue.cs" ```csharp title="queue.cs"
/* 初始化队列 */ /* 初始化队列 */
Queue<int> queue = new(); Queue<int> queue = new();
/* 元素入队 */ /* 元素入队 */
queue.Enqueue(1); queue.Enqueue(1);
queue.Enqueue(3); queue.Enqueue(3);
queue.Enqueue(2); queue.Enqueue(2);
queue.Enqueue(5); queue.Enqueue(5);
queue.Enqueue(4); queue.Enqueue(4);
/* 访问队首元素 */ /* 访问队首元素 */
int peek = queue.Peek(); int peek = queue.Peek();
/* 元素出队 */ /* 元素出队 */
int pop = queue.Dequeue(); int pop = queue.Dequeue();
/* 获取队列的长度 */ /* 获取队列的长度 */
int size = queue.Count; int size = queue.Count;
/* 判断队列是否为空 */ /* 判断队列是否为空 */
bool isEmpty = queue.Count == 0; bool isEmpty = queue.Count == 0;
``` ```
@ -134,24 +134,24 @@
/* 初始化队列 */ /* 初始化队列 */
// 在 Go 中，将 list 作为队列来使用 // 在 Go 中，将 list 作为队列来使用
queue := list.New() queue := list.New()
/* 元素入队 */ /* 元素入队 */
queue.PushBack(1) queue.PushBack(1)
queue.PushBack(3) queue.PushBack(3)
queue.PushBack(2) queue.PushBack(2)
queue.PushBack(5) queue.PushBack(5)
queue.PushBack(4) queue.PushBack(4)
/* 访问队首元素 */ /* 访问队首元素 */
peek := queue.Front() peek := queue.Front()
/* 元素出队 */ /* 元素出队 */
pop := queue.Front() pop := queue.Front()
queue.Remove(pop) queue.Remove(pop)
/* 获取队列的长度 */ /* 获取队列的长度 */
size := queue.Len() size := queue.Len()
/* 判断队列是否为空 */ /* 判断队列是否为空 */
isEmpty := queue.Len() == 0 isEmpty := queue.Len() == 0
``` ```
@ -162,24 +162,24 @@
/* 初始化队列 */ /* 初始化队列 */
// Swift 没有内置的队列类，可以把 Array 当作队列来使用 // Swift 没有内置的队列类，可以把 Array 当作队列来使用
var queue: [Int] = [] var queue: [Int] = []
/* 元素入队 */ /* 元素入队 */
queue.append(1) queue.append(1)
queue.append(3) queue.append(3)
queue.append(2) queue.append(2)
queue.append(5) queue.append(5)
queue.append(4) queue.append(4)
/* 访问队首元素 */ /* 访问队首元素 */
let peek = queue.first! let peek = queue.first!
/* 元素出队 */ /* 元素出队 */
// 由于是数组，因此 removeFirst 的复杂度为 O(n) // 由于是数组，因此 removeFirst 的复杂度为 O(n)
let pool = queue.removeFirst() let pool = queue.removeFirst()
/* 获取队列的长度 */ /* 获取队列的长度 */
let size = queue.count let size = queue.count
/* 判断队列是否为空 */ /* 判断队列是否为空 */
let isEmpty = queue.isEmpty let isEmpty = queue.isEmpty
``` ```
@ -190,24 +190,24 @@
/* 初始化队列 */ /* 初始化队列 */
// JavaScript 没有内置的队列，可以把 Array 当作队列来使用 // JavaScript 没有内置的队列，可以把 Array 当作队列来使用
const queue = []; const queue = [];
/* 元素入队 */ /* 元素入队 */
queue.push(1); queue.push(1);
queue.push(3); queue.push(3);
queue.push(2); queue.push(2);
queue.push(5); queue.push(5);
queue.push(4); queue.push(4);
/* 访问队首元素 */ /* 访问队首元素 */
const peek = queue[0]; const peek = queue[0];
/* 元素出队 */ /* 元素出队 */
// 底层是数组，因此 shift() 方法的时间复杂度为 O(n) // 底层是数组，因此 shift() 方法的时间复杂度为 O(n)
const pop = queue.shift(); const pop = queue.shift();
/* 获取队列的长度 */ /* 获取队列的长度 */
const size = queue.length; const size = queue.length;
/* 判断队列是否为空 */ /* 判断队列是否为空 */
const empty = queue.length === 0; const empty = queue.length === 0;
``` ```
@ -216,26 +216,26 @@
```typescript title="queue.ts" ```typescript title="queue.ts"
/* 初始化队列 */ /* 初始化队列 */
// TypeScript 没有内置的队列，可以把 Array 当作队列来使用 // TypeScript 没有内置的队列，可以把 Array 当作队列来使用
const queue: number[] = []; const queue: number[] = [];
/* 元素入队 */ /* 元素入队 */
queue.push(1); queue.push(1);
queue.push(3); queue.push(3);
queue.push(2); queue.push(2);
queue.push(5); queue.push(5);
queue.push(4); queue.push(4);
/* 访问队首元素 */ /* 访问队首元素 */
const peek = queue[0]; const peek = queue[0];
/* 元素出队 */ /* 元素出队 */
// 底层是数组，因此 shift() 方法的时间复杂度为 O(n) // 底层是数组，因此 shift() 方法的时间复杂度为 O(n)
const pop = queue.shift(); const pop = queue.shift();
/* 获取队列的长度 */ /* 获取队列的长度 */
const size = queue.length; const size = queue.length;
/* 判断队列是否为空 */ /* 判断队列是否为空 */
const empty = queue.length === 0; const empty = queue.length === 0;
``` ```
@ -307,23 +307,23 @@
```kotlin title="queue.kt" ```kotlin title="queue.kt"
/* 初始化队列 */ /* 初始化队列 */
val queue = LinkedList<Int>() val queue = LinkedList<Int>()
/* 元素入队 */ /* 元素入队 */
queue.offer(1) queue.offer(1)
queue.offer(3) queue.offer(3)
queue.offer(2) queue.offer(2)
queue.offer(5) queue.offer(5)
queue.offer(4) queue.offer(4)
/* 访问队首元素 */ /* 访问队首元素 */
val peek = queue.peek() val peek = queue.peek()
/* 元素出队 */ /* 元素出队 */
val pop = queue.poll() val pop = queue.poll()
/* 获取队列的长度 */ /* 获取队列的长度 */
val size = queue.size val size = queue.size
/* 判断队列是否为空 */ /* 判断队列是否为空 */
val isEmpty = queue.isEmpty() val isEmpty = queue.isEmpty()
``` ```
@ -331,7 +331,29 @@
=== "Ruby" === "Ruby"
```ruby title="queue.rb" ```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" === "Zig"

107
docs/chapter_stack_and_queue/stack.md
View File

@ -26,25 +26,25 @@
```python title="stack.py" ```python title="stack.py"
# 初始化栈 # 初始化栈
# Python 没有内置的栈类，可以把 list 当作栈来使用 # Python 没有内置的栈类，可以把 list 当作栈来使用
stack: list[int] = [] stack: list[int] = []
# 元素入栈 # 元素入栈
stack.append(1) stack.append(1)
stack.append(3) stack.append(3)
stack.append(2) stack.append(2)
stack.append(5) stack.append(5)
stack.append(4) stack.append(4)
# 访问栈顶元素 # 访问栈顶元素
peek: int = stack[-1] peek: int = stack[-1]
# 元素出栈 # 元素出栈
pop: int = stack.pop() pop: int = stack.pop()
# 获取栈的长度 # 获取栈的长度
size: int = len(stack) size: int = len(stack)
# 判断是否为空 # 判断是否为空
is_empty: bool = len(stack) == 0 is_empty: bool = len(stack) == 0
``` ```
@ -54,23 +54,23 @@
```cpp title="stack.cpp" ```cpp title="stack.cpp"
/* 初始化栈 */ /* 初始化栈 */
stack<int> stack; stack<int> stack;
/* 元素入栈 */ /* 元素入栈 */
stack.push(1); stack.push(1);
stack.push(3); stack.push(3);
stack.push(2); stack.push(2);
stack.push(5); stack.push(5);
stack.push(4); stack.push(4);
/* 访问栈顶元素 */ /* 访问栈顶元素 */
int top = stack.top(); int top = stack.top();
/* 元素出栈 */ /* 元素出栈 */
stack.pop(); // 无返回值 stack.pop(); // 无返回值
/* 获取栈的长度 */ /* 获取栈的长度 */
int size = stack.size(); int size = stack.size();
/* 判断是否为空 */ /* 判断是否为空 */
bool empty = stack.empty(); bool empty = stack.empty();
``` ```
@ -106,23 +106,23 @@
```csharp title="stack.cs" ```csharp title="stack.cs"
/* 初始化栈 */ /* 初始化栈 */
Stack<int> stack = new(); Stack<int> stack = new();
/* 元素入栈 */ /* 元素入栈 */
stack.Push(1); stack.Push(1);
stack.Push(3); stack.Push(3);
stack.Push(2); stack.Push(2);
stack.Push(5); stack.Push(5);
stack.Push(4); stack.Push(4);
/* 访问栈顶元素 */ /* 访问栈顶元素 */
int peek = stack.Peek(); int peek = stack.Peek();
/* 元素出栈 */ /* 元素出栈 */
int pop = stack.Pop(); int pop = stack.Pop();
/* 获取栈的长度 */ /* 获取栈的长度 */
int size = stack.Count; int size = stack.Count;
/* 判断是否为空 */ /* 判断是否为空 */
bool isEmpty = stack.Count == 0; bool isEmpty = stack.Count == 0;
``` ```
@ -133,24 +133,24 @@
/* 初始化栈 */ /* 初始化栈 */
// 在 Go 中，推荐将 Slice 当作栈来使用 // 在 Go 中，推荐将 Slice 当作栈来使用
var stack []int var stack []int
/* 元素入栈 */ /* 元素入栈 */
stack = append(stack, 1) stack = append(stack, 1)
stack = append(stack, 3) stack = append(stack, 3)
stack = append(stack, 2) stack = append(stack, 2)
stack = append(stack, 5) stack = append(stack, 5)
stack = append(stack, 4) stack = append(stack, 4)
/* 访问栈顶元素 */ /* 访问栈顶元素 */
peek := stack[len(stack)-1] peek := stack[len(stack)-1]
/* 元素出栈 */ /* 元素出栈 */
pop := stack[len(stack)-1] pop := stack[len(stack)-1]
stack = stack[:len(stack)-1] stack = stack[:len(stack)-1]
/* 获取栈的长度 */ /* 获取栈的长度 */
size := len(stack) size := len(stack)
/* 判断是否为空 */ /* 判断是否为空 */
isEmpty := len(stack) == 0 isEmpty := len(stack) == 0
``` ```
@ -161,23 +161,23 @@
/* 初始化栈 */ /* 初始化栈 */
// Swift 没有内置的栈类，可以把 Array 当作栈来使用 // Swift 没有内置的栈类，可以把 Array 当作栈来使用
var stack: [Int] = [] var stack: [Int] = []
/* 元素入栈 */ /* 元素入栈 */
stack.append(1) stack.append(1)
stack.append(3) stack.append(3)
stack.append(2) stack.append(2)
stack.append(5) stack.append(5)
stack.append(4) stack.append(4)
/* 访问栈顶元素 */ /* 访问栈顶元素 */
let peek = stack.last! let peek = stack.last!
/* 元素出栈 */ /* 元素出栈 */
let pop = stack.removeLast() let pop = stack.removeLast()
/* 获取栈的长度 */ /* 获取栈的长度 */
let size = stack.count let size = stack.count
/* 判断是否为空 */ /* 判断是否为空 */
let isEmpty = stack.isEmpty let isEmpty = stack.isEmpty
``` ```
@ -186,25 +186,25 @@
```javascript title="stack.js" ```javascript title="stack.js"
/* 初始化栈 */ /* 初始化栈 */
// JavaScript 没有内置的栈类，可以把 Array 当作栈来使用 // JavaScript 没有内置的栈类，可以把 Array 当作栈来使用
const stack = []; const stack = [];
/* 元素入栈 */ /* 元素入栈 */
stack.push(1); stack.push(1);
stack.push(3); stack.push(3);
stack.push(2); stack.push(2);
stack.push(5); stack.push(5);
stack.push(4); stack.push(4);
/* 访问栈顶元素 */ /* 访问栈顶元素 */
const peek = stack[stack.length-1]; const peek = stack[stack.length-1];
/* 元素出栈 */ /* 元素出栈 */
const pop = stack.pop(); const pop = stack.pop();
/* 获取栈的长度 */ /* 获取栈的长度 */
const size = stack.length; const size = stack.length;
/* 判断是否为空 */ /* 判断是否为空 */
const is_empty = stack.length === 0; const is_empty = stack.length === 0;
``` ```
@ -213,25 +213,25 @@
```typescript title="stack.ts" ```typescript title="stack.ts"
/* 初始化栈 */ /* 初始化栈 */
// TypeScript 没有内置的栈类，可以把 Array 当作栈来使用 // TypeScript 没有内置的栈类，可以把 Array 当作栈来使用
const stack: number[] = []; const stack: number[] = [];
/* 元素入栈 */ /* 元素入栈 */
stack.push(1); stack.push(1);
stack.push(3); stack.push(3);
stack.push(2); stack.push(2);
stack.push(5); stack.push(5);
stack.push(4); stack.push(4);
/* 访问栈顶元素 */ /* 访问栈顶元素 */
const peek = stack[stack.length - 1]; const peek = stack[stack.length - 1];
/* 元素出栈 */ /* 元素出栈 */
const pop = stack.pop(); const pop = stack.pop();
/* 获取栈的长度 */ /* 获取栈的长度 */
const size = stack.length; const size = stack.length;
/* 判断是否为空 */ /* 判断是否为空 */
const is_empty = stack.length === 0; const is_empty = stack.length === 0;
``` ```
@ -301,23 +301,23 @@
```kotlin title="stack.kt" ```kotlin title="stack.kt"
/* 初始化栈 */ /* 初始化栈 */
val stack = Stack<Int>() val stack = Stack<Int>()
/* 元素入栈 */ /* 元素入栈 */
stack.push(1) stack.push(1)
stack.push(3) stack.push(3)
stack.push(2) stack.push(2)
stack.push(5) stack.push(5)
stack.push(4) stack.push(4)
/* 访问栈顶元素 */ /* 访问栈顶元素 */
val peek = stack.peek() val peek = stack.peek()
/* 元素出栈 */ /* 元素出栈 */
val pop = stack.pop() val pop = stack.pop()
/* 获取栈的长度 */ /* 获取栈的长度 */
val size = stack.size val size = stack.size
/* 判断是否为空 */ /* 判断是否为空 */
val isEmpty = stack.isEmpty() val isEmpty = stack.isEmpty()
``` ```
@ -325,7 +325,28 @@
=== "Ruby" === "Ruby"
```ruby title="stack.rb" ```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" === "Zig"