mirror of
https://github.com/krahets/hello-algo.git
synced 2026-04-23 18:11:45 +08:00
feat: Traditional Chinese version (#1163)
* First commit * Update mkdocs.yml * Translate all the docs to traditional Chinese * Translate the code files. * Translate the docker file * Fix mkdocs.yml * Translate all the figures from SC to TC * 二叉搜尋樹 -> 二元搜尋樹 * Update terminology. * Update terminology * 构造函数/构造方法 -> 建構子 异或 -> 互斥或 * 擴充套件 -> 擴展 * constant - 常量 - 常數 * 類 -> 類別 * AVL -> AVL 樹 * 數組 -> 陣列 * 係統 -> 系統 斐波那契數列 -> 費波那契數列 運算元量 -> 運算量 引數 -> 參數 * 聯絡 -> 關聯 * 麵試 -> 面試 * 面向物件 -> 物件導向 歸併排序 -> 合併排序 范式 -> 範式 * Fix 算法 -> 演算法 * 錶示 -> 表示 反碼 -> 一補數 補碼 -> 二補數 列列尾部 -> 佇列尾部 區域性性 -> 區域性 一摞 -> 一疊 * Synchronize with main branch * 賬號 -> 帳號 推匯 -> 推導 * Sync with main branch * First commit * Update mkdocs.yml * Translate all the docs to traditional Chinese * Translate the code files. * Translate the docker file * Fix mkdocs.yml * Translate all the figures from SC to TC * 二叉搜尋樹 -> 二元搜尋樹 * Update terminology * 构造函数/构造方法 -> 建構子 异或 -> 互斥或 * 擴充套件 -> 擴展 * constant - 常量 - 常數 * 類 -> 類別 * AVL -> AVL 樹 * 數組 -> 陣列 * 係統 -> 系統 斐波那契數列 -> 費波那契數列 運算元量 -> 運算量 引數 -> 參數 * 聯絡 -> 關聯 * 麵試 -> 面試 * 面向物件 -> 物件導向 歸併排序 -> 合併排序 范式 -> 範式 * Fix 算法 -> 演算法 * 錶示 -> 表示 反碼 -> 一補數 補碼 -> 二補數 列列尾部 -> 佇列尾部 區域性性 -> 區域性 一摞 -> 一疊 * Synchronize with main branch * 賬號 -> 帳號 推匯 -> 推導 * Sync with main branch * Update terminology.md * 操作数量（num. of operations）-> 操作數量 * 字首和->前綴和 * Update figures * 歸 -> 迴 記憶體洩漏 -> 記憶體流失 * Fix the bug of the file filter * 支援 -> 支持 Add zh-Hant/README.md * Add the zh-Hant chapter covers. Bug fixes. * 外掛 -> 擴充功能 * Add the landing page for zh-Hant version * Unify the font of the chapter covers for the zh, en, and zh-Hant version * Move zh-Hant/ to zh-hant/ * Translate terminology.md to traditional Chinese
This commit is contained in:
Yudong Jin
Binary file not shown.
|
After Width: | Height: | Size: 30 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 28 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 27 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 22 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 23 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 27 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 22 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 25 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 26 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 23 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 21 KiB |
433
zh-hant/docs/chapter_stack_and_queue/deque.md
Normal file
433
zh-hant/docs/chapter_stack_and_queue/deque.md
Normal file
@@ -0,0 +1,433 @@
|
||||
# 雙向佇列
|
||||
|
||||
在佇列中，我們僅能刪除頭部元素或在尾部新增元素。如下圖所示，<u>雙向佇列（double-ended queue）</u>提供了更高的靈活性，允許在頭部和尾部執行元素的新增或刪除操作。
|
||||
|
||||
|
||||
|
||||
## 雙向佇列常用操作
|
||||
|
||||
雙向佇列的常用操作如下表所示，具體的方法名稱需要根據所使用的程式語言來確定。
|
||||
|
||||
<p align="center"> 表 <id> 雙向佇列操作效率 </p>
|
||||
|
||||
| 方法名 | 描述 | 時間複雜度 |
|
||||
| -------------- | ---------------- | ---------- |
|
||||
| `push_first()` | 將元素新增至佇列首 | $O(1)$ |
|
||||
| `push_last()` | 將元素新增至佇列尾 | $O(1)$ |
|
||||
| `pop_first()` | 刪除佇列首元素 | $O(1)$ |
|
||||
| `pop_last()` | 刪除佇列尾元素 | $O(1)$ |
|
||||
| `peek_first()` | 訪問佇列首元素 | $O(1)$ |
|
||||
| `peek_last()` | 訪問佇列尾元素 | $O(1)$ |
|
||||
|
||||
同樣地，我們可以直接使用程式語言中已實現的雙向佇列類別：
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python title="deque.py"
|
||||
from collections import deque
|
||||
|
||||
# 初始化雙向佇列
|
||||
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
|
||||
```
|
||||
|
||||
=== "C++"
|
||||
|
||||
```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();
|
||||
```
|
||||
|
||||
=== "Java"
|
||||
|
||||
```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();
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
```csharp title="deque.cs"
|
||||
/* 初始化雙向佇列 */
|
||||
// 在 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;
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
|
||||
```go title="deque_test.go"
|
||||
/* 初始化雙向佇列 */
|
||||
// 在 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
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="deque.swift"
|
||||
/* 初始化雙向佇列 */
|
||||
// Swift 沒有內建的雙向佇列類別，可以把 Array 當作雙向佇列來使用
|
||||
var deque: [Int] = []
|
||||
|
||||
/* 元素入列 */
|
||||
deque.append(2) // 新增至佇列尾
|
||||
deque.append(5)
|
||||
deque.append(4)
|
||||
deque.insert(3, at: 0) // 新增至佇列首
|
||||
deque.insert(1, at: 0)
|
||||
|
||||
/* 訪問元素 */
|
||||
let peekFirst = deque.first! // 佇列首元素
|
||||
let peekLast = deque.last! // 佇列尾元素
|
||||
|
||||
/* 元素出列 */
|
||||
// 使用 Array 模擬時 popFirst 的複雜度為 O(n)
|
||||
let popFirst = deque.removeFirst() // 佇列首元素出列
|
||||
let popLast = deque.removeLast() // 佇列尾元素出列
|
||||
|
||||
/* 獲取雙向佇列的長度 */
|
||||
let size = deque.count
|
||||
|
||||
/* 判斷雙向佇列是否為空 */
|
||||
let isEmpty = deque.isEmpty
|
||||
```
|
||||
|
||||
=== "JS"
|
||||
|
||||
```javascript title="deque.js"
|
||||
/* 初始化雙向佇列 */
|
||||
// JavaScript 沒有內建的雙端佇列，只能把 Array 當作雙端佇列來使用
|
||||
const deque = [];
|
||||
|
||||
/* 元素入列 */
|
||||
deque.push(2);
|
||||
deque.push(5);
|
||||
deque.push(4);
|
||||
// 請注意，由於是陣列，unshift() 方法的時間複雜度為 O(n)
|
||||
deque.unshift(3);
|
||||
deque.unshift(1);
|
||||
|
||||
/* 訪問元素 */
|
||||
const peekFirst = deque[0];
|
||||
const peekLast = deque[deque.length - 1];
|
||||
|
||||
/* 元素出列 */
|
||||
// 請注意，由於是陣列，shift() 方法的時間複雜度為 O(n)
|
||||
const popFront = deque.shift();
|
||||
const popBack = deque.pop();
|
||||
|
||||
/* 獲取雙向佇列的長度 */
|
||||
const size = deque.length;
|
||||
|
||||
/* 判斷雙向佇列是否為空 */
|
||||
const isEmpty = size === 0;
|
||||
```
|
||||
|
||||
=== "TS"
|
||||
|
||||
```typescript title="deque.ts"
|
||||
/* 初始化雙向佇列 */
|
||||
// TypeScript 沒有內建的雙端佇列，只能把 Array 當作雙端佇列來使用
|
||||
const deque: number[] = [];
|
||||
|
||||
/* 元素入列 */
|
||||
deque.push(2);
|
||||
deque.push(5);
|
||||
deque.push(4);
|
||||
// 請注意，由於是陣列，unshift() 方法的時間複雜度為 O(n)
|
||||
deque.unshift(3);
|
||||
deque.unshift(1);
|
||||
|
||||
/* 訪問元素 */
|
||||
const peekFirst: number = deque[0];
|
||||
const peekLast: number = deque[deque.length - 1];
|
||||
|
||||
/* 元素出列 */
|
||||
// 請注意，由於是陣列，shift() 方法的時間複雜度為 O(n)
|
||||
const popFront: number = deque.shift() as number;
|
||||
const popBack: number = deque.pop() as number;
|
||||
|
||||
/* 獲取雙向佇列的長度 */
|
||||
const size: number = deque.length;
|
||||
|
||||
/* 判斷雙向佇列是否為空 */
|
||||
const isEmpty: boolean = size === 0;
|
||||
```
|
||||
|
||||
=== "Dart"
|
||||
|
||||
```dart title="deque.dart"
|
||||
/* 初始化雙向佇列 */
|
||||
// 在 Dart 中，Queue 被定義為雙向佇列
|
||||
Queue<int> deque = Queue<int>();
|
||||
|
||||
/* 元素入列 */
|
||||
deque.addLast(2); // 新增至佇列尾
|
||||
deque.addLast(5);
|
||||
deque.addLast(4);
|
||||
deque.addFirst(3); // 新增至佇列首
|
||||
deque.addFirst(1);
|
||||
|
||||
/* 訪問元素 */
|
||||
int peekFirst = deque.first; // 佇列首元素
|
||||
int peekLast = deque.last; // 佇列尾元素
|
||||
|
||||
/* 元素出列 */
|
||||
int popFirst = deque.removeFirst(); // 佇列首元素出列
|
||||
int popLast = deque.removeLast(); // 佇列尾元素出列
|
||||
|
||||
/* 獲取雙向佇列的長度 */
|
||||
int size = deque.length;
|
||||
|
||||
/* 判斷雙向佇列是否為空 */
|
||||
bool isEmpty = deque.isEmpty;
|
||||
```
|
||||
|
||||
=== "Rust"
|
||||
|
||||
```rust title="deque.rs"
|
||||
/* 初始化雙向佇列 */
|
||||
let mut deque: VecDeque<u32> = VecDeque::new();
|
||||
|
||||
/* 元素入列 */
|
||||
deque.push_back(2); // 新增至佇列尾
|
||||
deque.push_back(5);
|
||||
deque.push_back(4);
|
||||
deque.push_front(3); // 新增至佇列首
|
||||
deque.push_front(1);
|
||||
|
||||
/* 訪問元素 */
|
||||
if let Some(front) = deque.front() { // 佇列首元素
|
||||
}
|
||||
if let Some(rear) = deque.back() { // 佇列尾元素
|
||||
}
|
||||
|
||||
/* 元素出列 */
|
||||
if let Some(pop_front) = deque.pop_front() { // 佇列首元素出列
|
||||
}
|
||||
if let Some(pop_rear) = deque.pop_back() { // 佇列尾元素出列
|
||||
}
|
||||
|
||||
/* 獲取雙向佇列的長度 */
|
||||
let size = deque.len();
|
||||
|
||||
/* 判斷雙向佇列是否為空 */
|
||||
let is_empty = deque.is_empty();
|
||||
```
|
||||
|
||||
=== "C"
|
||||
|
||||
```c title="deque.c"
|
||||
// C 未提供內建雙向佇列
|
||||
```
|
||||
|
||||
=== "Kotlin"
|
||||
|
||||
```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()
|
||||
```
|
||||
|
||||
=== "Ruby"
|
||||
|
||||
```ruby title="deque.rb"
|
||||
|
||||
```
|
||||
|
||||
=== "Zig"
|
||||
|
||||
```zig title="deque.zig"
|
||||
|
||||
```
|
||||
|
||||
??? pythontutor "視覺化執行"
|
||||
|
||||
https://pythontutor.com/render.html#code=from%20collections%20import%20deque%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%0A%20%20%20%20deq%20%3D%20deque%28%29%0A%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%85%A5%E9%98%9F%0A%20%20%20%20deq.append%282%29%20%20%23%20%E6%B7%BB%E5%8A%A0%E8%87%B3%E9%98%9F%E5%B0%BE%0A%20%20%20%20deq.append%285%29%0A%20%20%20%20deq.append%284%29%0A%20%20%20%20deq.appendleft%283%29%20%20%23%20%E6%B7%BB%E5%8A%A0%E8%87%B3%E9%98%9F%E9%A6%96%0A%20%20%20%20deq.appendleft%281%29%0A%20%20%20%20print%28%22%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%20deque%20%3D%22,%20deq%29%0A%0A%20%20%20%20%23%20%E8%AE%BF%E9%97%AE%E5%85%83%E7%B4%A0%0A%20%20%20%20front%20%3D%20deq%5B0%5D%20%20%23%20%E9%98%9F%E9%A6%96%E5%85%83%E7%B4%A0%0A%20%20%20%20print%28%22%E9%98%9F%E9%A6%96%E5%85%83%E7%B4%A0%20front%20%3D%22,%20front%29%0A%20%20%20%20rear%20%3D%20deq%5B-1%5D%20%20%23%20%E9%98%9F%E5%B0%BE%E5%85%83%E7%B4%A0%0A%20%20%20%20print%28%22%E9%98%9F%E5%B0%BE%E5%85%83%E7%B4%A0%20rear%20%3D%22,%20rear%29%0A%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%87%BA%E9%98%9F%0A%20%20%20%20pop_front%20%3D%20deq.popleft%28%29%20%20%23%20%E9%98%9F%E9%A6%96%E5%85%83%E7%B4%A0%E5%87%BA%E9%98%9F%0A%20%20%20%20print%28%22%E9%98%9F%E9%A6%96%E5%87%BA%E9%98%9F%E5%85%83%E7%B4%A0%20%20pop_front%20%3D%22,%20pop_front%29%0A%20%20%20%20print%28%22%E9%98%9F%E9%A6%96%E5%87%BA%E9%98%9F%E5%90%8E%20deque%20%3D%22,%20deq%29%0A%20%20%20%20pop_rear%20%3D%20deq.pop%28%29%20%20%23%20%E9%98%9F%E5%B0%BE%E5%85%83%E7%B4%A0%E5%87%BA%E9%98%9F%0A%20%20%20%20print%28%22%E9%98%9F%E5%B0%BE%E5%87%BA%E9%98%9F%E5%85%83%E7%B4%A0%20%20pop_rear%20%3D%22,%20pop_rear%29%0A%20%20%20%20print%28%22%E9%98%9F%E5%B0%BE%E5%87%BA%E9%98%9F%E5%90%8E%20deque%20%3D%22,%20deq%29%0A%0A%20%20%20%20%23%20%E8%8E%B7%E5%8F%96%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%E7%9A%84%E9%95%BF%E5%BA%A6%0A%20%20%20%20size%20%3D%20len%28deq%29%0A%20%20%20%20print%28%22%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%E9%95%BF%E5%BA%A6%20size%20%3D%22,%20size%29%0A%0A%20%20%20%20%23%20%E5%88%A4%E6%96%AD%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%0A%20%20%20%20is_empty%20%3D%20len%28deq%29%20%3D%3D%200%0A%20%20%20%20print%28%22%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%20%3D%22,%20is_empty%29&cumulative=false&curInstr=3&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false
|
||||
|
||||
## 雙向佇列實現 *
|
||||
|
||||
雙向佇列的實現與佇列類似，可以選擇鏈結串列或陣列作為底層資料結構。
|
||||
|
||||
### 基於雙向鏈結串列的實現
|
||||
|
||||
回顧上一節內容，我們使用普通單向鏈結串列來實現佇列，因為它可以方便地刪除頭節點（對應出列操作）和在尾節點後新增新節點（對應入列操作）。
|
||||
|
||||
對於雙向佇列而言，頭部和尾部都可以執行入列和出列操作。換句話說，雙向佇列需要實現另一個對稱方向的操作。為此，我們採用“雙向鏈結串列”作為雙向佇列的底層資料結構。
|
||||
|
||||
如下圖所示，我們將雙向鏈結串列的頭節點和尾節點視為雙向佇列的佇列首和佇列尾，同時實現在兩端新增和刪除節點的功能。
|
||||
|
||||
=== "LinkedListDeque"
|
||||
|
||||
|
||||
=== "push_last()"
|
||||
|
||||
|
||||
=== "push_first()"
|
||||
|
||||
|
||||
=== "pop_last()"
|
||||
|
||||
|
||||
=== "pop_first()"
|
||||
|
||||
|
||||
實現程式碼如下所示：
|
||||
|
||||
```src
|
||||
[file]{linkedlist_deque}-[class]{linked_list_deque}-[func]{}
|
||||
```
|
||||
|
||||
### 基於陣列的實現
|
||||
|
||||
如下圖所示，與基於陣列實現佇列類似，我們也可以使用環形陣列來實現雙向佇列。
|
||||
|
||||
=== "ArrayDeque"
|
||||
|
||||
|
||||
=== "push_last()"
|
||||
|
||||
|
||||
=== "push_first()"
|
||||
|
||||
|
||||
=== "pop_last()"
|
||||
|
||||
|
||||
=== "pop_first()"
|
||||
|
||||
|
||||
在佇列的實現基礎上，僅需增加“佇列首入列”和“佇列尾出列”的方法：
|
||||
|
||||
```src
|
||||
[file]{array_deque}-[class]{array_deque}-[func]{}
|
||||
```
|
||||
|
||||
## 雙向佇列應用
|
||||
|
||||
雙向佇列兼具堆疊與佇列的邏輯，**因此它可以實現這兩者的所有應用場景，同時提供更高的自由度**。
|
||||
|
||||
我們知道，軟體的“撤銷”功能通常使用堆疊來實現：系統將每次更改操作 `push` 到堆疊中，然後透過 `pop` 實現撤銷。然而，考慮到系統資源的限制，軟體通常會限制撤銷的步數（例如僅允許儲存 $50$ 步）。當堆疊的長度超過 $50$ 時，軟體需要在堆疊底（佇列首）執行刪除操作。**但堆疊無法實現該功能，此時就需要使用雙向佇列來替代堆疊**。請注意，“撤銷”的核心邏輯仍然遵循堆疊的先入後出原則，只是雙向佇列能夠更加靈活地實現一些額外邏輯。
|
||||
9
zh-hant/docs/chapter_stack_and_queue/index.md
Normal file
9
zh-hant/docs/chapter_stack_and_queue/index.md
Normal file
@@ -0,0 +1,9 @@
|
||||
# 堆疊與佇列
|
||||
|
||||
|
||||
|
||||
!!! abstract
|
||||
|
||||
堆疊如同疊貓貓，而佇列就像貓貓排隊。
|
||||
|
||||
兩者分別代表先入後出和先入先出的邏輯關係。
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 25 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 26 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 21 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 19 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 24 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 20 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 22 KiB |
407
zh-hant/docs/chapter_stack_and_queue/queue.md
Executable file
407
zh-hant/docs/chapter_stack_and_queue/queue.md
Executable file
@@ -0,0 +1,407 @@
|
||||
# 佇列
|
||||
|
||||
<u>佇列（queue）</u>是一種遵循先入先出規則的線性資料結構。顧名思義，佇列模擬了排隊現象，即新來的人不斷加入佇列尾部，而位於佇列頭部的人逐個離開。
|
||||
|
||||
如下圖所示，我們將佇列頭部稱為“佇列首”，尾部稱為“佇列尾”，將把元素加入列尾的操作稱為“入列”，刪除佇列首元素的操作稱為“出列”。
|
||||
|
||||
|
||||
|
||||
## 佇列常用操作
|
||||
|
||||
佇列的常見操作如下表所示。需要注意的是，不同程式語言的方法名稱可能會有所不同。我們在此採用與堆疊相同的方法命名。
|
||||
|
||||
<p align="center"> 表 <id> 佇列操作效率 </p>
|
||||
|
||||
| 方法名 | 描述 | 時間複雜度 |
|
||||
| -------- | ---------------------------- | ---------- |
|
||||
| `push()` | 元素入列，即將元素新增至佇列尾 | $O(1)$ |
|
||||
| `pop()` | 佇列首元素出列 | $O(1)$ |
|
||||
| `peek()` | 訪問佇列首元素 | $O(1)$ |
|
||||
|
||||
我們可以直接使用程式語言中現成的佇列類別：
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python title="queue.py"
|
||||
from collections import deque
|
||||
|
||||
# 初始化佇列
|
||||
# 在 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
|
||||
```
|
||||
|
||||
=== "C++"
|
||||
|
||||
```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();
|
||||
```
|
||||
|
||||
=== "Java"
|
||||
|
||||
```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();
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
```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;
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
|
||||
```go title="queue_test.go"
|
||||
/* 初始化佇列 */
|
||||
// 在 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
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="queue.swift"
|
||||
/* 初始化佇列 */
|
||||
// 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
|
||||
```
|
||||
|
||||
=== "JS"
|
||||
|
||||
```javascript title="queue.js"
|
||||
/* 初始化佇列 */
|
||||
// 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;
|
||||
```
|
||||
|
||||
=== "TS"
|
||||
|
||||
```typescript title="queue.ts"
|
||||
/* 初始化佇列 */
|
||||
// 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;
|
||||
```
|
||||
|
||||
=== "Dart"
|
||||
|
||||
```dart title="queue.dart"
|
||||
/* 初始化佇列 */
|
||||
// 在 Dart 中，佇列類別 Qeque 是雙向佇列，也可作為佇列使用
|
||||
Queue<int> queue = Queue();
|
||||
|
||||
/* 元素入列 */
|
||||
queue.add(1);
|
||||
queue.add(3);
|
||||
queue.add(2);
|
||||
queue.add(5);
|
||||
queue.add(4);
|
||||
|
||||
/* 訪問佇列首元素 */
|
||||
int peek = queue.first;
|
||||
|
||||
/* 元素出列 */
|
||||
int pop = queue.removeFirst();
|
||||
|
||||
/* 獲取佇列的長度 */
|
||||
int size = queue.length;
|
||||
|
||||
/* 判斷佇列是否為空 */
|
||||
bool isEmpty = queue.isEmpty;
|
||||
```
|
||||
|
||||
=== "Rust"
|
||||
|
||||
```rust title="queue.rs"
|
||||
/* 初始化雙向佇列 */
|
||||
// 在 Rust 中使用雙向佇列作為普通佇列來使用
|
||||
let mut deque: VecDeque<u32> = VecDeque::new();
|
||||
|
||||
/* 元素入列 */
|
||||
deque.push_back(1);
|
||||
deque.push_back(3);
|
||||
deque.push_back(2);
|
||||
deque.push_back(5);
|
||||
deque.push_back(4);
|
||||
|
||||
/* 訪問佇列首元素 */
|
||||
if let Some(front) = deque.front() {
|
||||
}
|
||||
|
||||
/* 元素出列 */
|
||||
if let Some(pop) = deque.pop_front() {
|
||||
}
|
||||
|
||||
/* 獲取佇列的長度 */
|
||||
let size = deque.len();
|
||||
|
||||
/* 判斷佇列是否為空 */
|
||||
let is_empty = deque.is_empty();
|
||||
```
|
||||
|
||||
=== "C"
|
||||
|
||||
```c title="queue.c"
|
||||
// C 未提供內建佇列
|
||||
```
|
||||
|
||||
=== "Kotlin"
|
||||
|
||||
```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()
|
||||
```
|
||||
|
||||
=== "Ruby"
|
||||
|
||||
```ruby title="queue.rb"
|
||||
|
||||
```
|
||||
|
||||
=== "Zig"
|
||||
|
||||
```zig title="queue.zig"
|
||||
|
||||
```
|
||||
|
||||
??? pythontutor "視覺化執行"
|
||||
|
||||
https://pythontutor.com/render.html#code=from%20collections%20import%20deque%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E9%98%9F%E5%88%97%0A%20%20%20%20%23%20%E5%9C%A8%20Python%20%E4%B8%AD%EF%BC%8C%E6%88%91%E4%BB%AC%E4%B8%80%E8%88%AC%E5%B0%86%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%E7%B1%BB%20deque%20%E7%9C%8B%E4%BD%9C%E9%98%9F%E5%88%97%E4%BD%BF%E7%94%A8%0A%20%20%20%20%23%20%E8%99%BD%E7%84%B6%20queue.Queue%28%29%20%E6%98%AF%E7%BA%AF%E6%AD%A3%E7%9A%84%E9%98%9F%E5%88%97%E7%B1%BB%EF%BC%8C%E4%BD%86%E4%B8%8D%E5%A4%AA%E5%A5%BD%E7%94%A8%0A%20%20%20%20que%20%3D%20deque%28%29%0A%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%85%A5%E9%98%9F%0A%20%20%20%20que.append%281%29%0A%20%20%20%20que.append%283%29%0A%20%20%20%20que.append%282%29%0A%20%20%20%20que.append%285%29%0A%20%20%20%20que.append%284%29%0A%20%20%20%20print%28%22%E9%98%9F%E5%88%97%20que%20%3D%22,%20que%29%0A%0A%20%20%20%20%23%20%E8%AE%BF%E9%97%AE%E9%98%9F%E9%A6%96%E5%85%83%E7%B4%A0%0A%20%20%20%20front%20%3D%20que%5B0%5D%0A%20%20%20%20print%28%22%E9%98%9F%E9%A6%96%E5%85%83%E7%B4%A0%20front%20%3D%22,%20front%29%0A%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%87%BA%E9%98%9F%0A%20%20%20%20pop%20%3D%20que.popleft%28%29%0A%20%20%20%20print%28%22%E5%87%BA%E9%98%9F%E5%85%83%E7%B4%A0%20pop%20%3D%22,%20pop%29%0A%20%20%20%20print%28%22%E5%87%BA%E9%98%9F%E5%90%8E%20que%20%3D%22,%20que%29%0A%0A%20%20%20%20%23%20%E8%8E%B7%E5%8F%96%E9%98%9F%E5%88%97%E7%9A%84%E9%95%BF%E5%BA%A6%0A%20%20%20%20size%20%3D%20len%28que%29%0A%20%20%20%20print%28%22%E9%98%9F%E5%88%97%E9%95%BF%E5%BA%A6%20size%20%3D%22,%20size%29%0A%0A%20%20%20%20%23%20%E5%88%A4%E6%96%AD%E9%98%9F%E5%88%97%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%0A%20%20%20%20is_empty%20%3D%20len%28que%29%20%3D%3D%200%0A%20%20%20%20print%28%22%E9%98%9F%E5%88%97%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%20%3D%22,%20is_empty%29&cumulative=false&curInstr=3&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false
|
||||
|
||||
## 佇列實現
|
||||
|
||||
為了實現佇列，我們需要一種資料結構，可以在一端新增元素，並在另一端刪除元素，鏈結串列和陣列都符合要求。
|
||||
|
||||
### 基於鏈結串列的實現
|
||||
|
||||
如下圖所示，我們可以將鏈結串列的“頭節點”和“尾節點”分別視為“佇列首”和“佇列尾”，規定佇列尾僅可新增節點，佇列首僅可刪除節點。
|
||||
|
||||
=== "LinkedListQueue"
|
||||
|
||||
|
||||
=== "push()"
|
||||
|
||||
|
||||
=== "pop()"
|
||||
|
||||
|
||||
以下是用鏈結串列實現佇列的程式碼：
|
||||
|
||||
```src
|
||||
[file]{linkedlist_queue}-[class]{linked_list_queue}-[func]{}
|
||||
```
|
||||
|
||||
### 基於陣列的實現
|
||||
|
||||
在陣列中刪除首元素的時間複雜度為 $O(n)$ ，這會導致出列操作效率較低。然而，我們可以採用以下巧妙方法來避免這個問題。
|
||||
|
||||
我們可以使用一個變數 `front` 指向佇列首元素的索引，並維護一個變數 `size` 用於記錄佇列長度。定義 `rear = front + size` ，這個公式計算出的 `rear` 指向佇列尾元素之後的下一個位置。
|
||||
|
||||
基於此設計，**陣列中包含元素的有效區間為 `[front, rear - 1]`**，各種操作的實現方法如下圖所示。
|
||||
|
||||
- 入列操作：將輸入元素賦值給 `rear` 索引處，並將 `size` 增加 1 。
|
||||
- 出列操作：只需將 `front` 增加 1 ，並將 `size` 減少 1 。
|
||||
|
||||
可以看到，入列和出列操作都只需進行一次操作，時間複雜度均為 $O(1)$ 。
|
||||
|
||||
=== "ArrayQueue"
|
||||
|
||||
|
||||
=== "push()"
|
||||
|
||||
|
||||
=== "pop()"
|
||||
|
||||
|
||||
你可能會發現一個問題：在不斷進行入列和出列的過程中，`front` 和 `rear` 都在向右移動，**當它們到達陣列尾部時就無法繼續移動了**。為了解決此問題，我們可以將陣列視為首尾相接的“環形陣列”。
|
||||
|
||||
對於環形陣列，我們需要讓 `front` 或 `rear` 在越過陣列尾部時，直接回到陣列頭部繼續走訪。這種週期性規律可以透過“取餘操作”來實現，程式碼如下所示：
|
||||
|
||||
```src
|
||||
[file]{array_queue}-[class]{array_queue}-[func]{}
|
||||
```
|
||||
|
||||
以上實現的佇列仍然具有侷限性：其長度不可變。然而，這個問題不難解決，我們可以將陣列替換為動態陣列，從而引入擴容機制。有興趣的讀者可以嘗試自行實現。
|
||||
|
||||
兩種實現的對比結論與堆疊一致，在此不再贅述。
|
||||
|
||||
## 佇列典型應用
|
||||
|
||||
- **淘寶訂單**。購物者下單後，訂單將加入列列中，系統隨後會根據順序處理佇列中的訂單。在雙十一期間，短時間內會產生海量訂單，高併發成為工程師們需要重點攻克的問題。
|
||||
- **各類待辦事項**。任何需要實現“先來後到”功能的場景，例如印表機的任務佇列、餐廳的出餐佇列等，佇列在這些場景中可以有效地維護處理順序。
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 20 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 21 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 19 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 20 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 24 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 21 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 22 KiB |
415
zh-hant/docs/chapter_stack_and_queue/stack.md
Executable file
415
zh-hant/docs/chapter_stack_and_queue/stack.md
Executable file
@@ -0,0 +1,415 @@
|
||||
# 堆疊
|
||||
|
||||
<u>堆疊（stack）</u>是一種遵循先入後出邏輯的線性資料結構。
|
||||
|
||||
我們可以將堆疊類比為桌面上的一疊盤子，如果想取出底部的盤子，則需要先將上面的盤子依次移走。我們將盤子替換為各種型別的元素（如整數、字元、物件等），就得到了堆疊這種資料結構。
|
||||
|
||||
如下圖所示，我們把堆積疊元素的頂部稱為“堆疊頂”，底部稱為“堆疊底”。將把元素新增到堆疊頂的操作叫作“入堆疊”，刪除堆疊頂元素的操作叫作“出堆疊”。
|
||||
|
||||
|
||||
|
||||
## 堆疊的常用操作
|
||||
|
||||
堆疊的常用操作如下表所示，具體的方法名需要根據所使用的程式語言來確定。在此，我們以常見的 `push()`、`pop()`、`peek()` 命名為例。
|
||||
|
||||
<p align="center"> 表 <id> 堆疊的操作效率 </p>
|
||||
|
||||
| 方法 | 描述 | 時間複雜度 |
|
||||
| -------- | ---------------------- | ---------- |
|
||||
| `push()` | 元素入堆疊（新增至堆疊頂） | $O(1)$ |
|
||||
| `pop()` | 堆疊頂元素出堆疊 | $O(1)$ |
|
||||
| `peek()` | 訪問堆疊頂元素 | $O(1)$ |
|
||||
|
||||
通常情況下，我們可以直接使用程式語言內建的堆疊類別。然而，某些語言可能沒有專門提供堆疊類別，這時我們可以將該語言的“陣列”或“鏈結串列”當作堆疊來使用，並在程式邏輯上忽略與堆疊無關的操作。
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python title="stack.py"
|
||||
# 初始化堆疊
|
||||
# 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
|
||||
```
|
||||
|
||||
=== "C++"
|
||||
|
||||
```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();
|
||||
```
|
||||
|
||||
=== "Java"
|
||||
|
||||
```java title="stack.java"
|
||||
/* 初始化堆疊 */
|
||||
Stack<Integer> stack = new Stack<>();
|
||||
|
||||
/* 元素入堆疊 */
|
||||
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.size();
|
||||
|
||||
/* 判斷是否為空 */
|
||||
boolean isEmpty = stack.isEmpty();
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
```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;
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
|
||||
```go title="stack_test.go"
|
||||
/* 初始化堆疊 */
|
||||
// 在 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
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="stack.swift"
|
||||
/* 初始化堆疊 */
|
||||
// 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
|
||||
```
|
||||
|
||||
=== "JS"
|
||||
|
||||
```javascript title="stack.js"
|
||||
/* 初始化堆疊 */
|
||||
// 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;
|
||||
```
|
||||
|
||||
=== "TS"
|
||||
|
||||
```typescript title="stack.ts"
|
||||
/* 初始化堆疊 */
|
||||
// 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;
|
||||
```
|
||||
|
||||
=== "Dart"
|
||||
|
||||
```dart title="stack.dart"
|
||||
/* 初始化堆疊 */
|
||||
// Dart 沒有內建的堆疊類別，可以把 List 當作堆疊來使用
|
||||
List<int> stack = [];
|
||||
|
||||
/* 元素入堆疊 */
|
||||
stack.add(1);
|
||||
stack.add(3);
|
||||
stack.add(2);
|
||||
stack.add(5);
|
||||
stack.add(4);
|
||||
|
||||
/* 訪問堆疊頂元素 */
|
||||
int peek = stack.last;
|
||||
|
||||
/* 元素出堆疊 */
|
||||
int pop = stack.removeLast();
|
||||
|
||||
/* 獲取堆疊的長度 */
|
||||
int size = stack.length;
|
||||
|
||||
/* 判斷是否為空 */
|
||||
bool isEmpty = stack.isEmpty;
|
||||
```
|
||||
|
||||
=== "Rust"
|
||||
|
||||
```rust title="stack.rs"
|
||||
/* 初始化堆疊 */
|
||||
// 把 Vec 當作堆疊來使用
|
||||
let mut stack: Vec<i32> = Vec::new();
|
||||
|
||||
/* 元素入堆疊 */
|
||||
stack.push(1);
|
||||
stack.push(3);
|
||||
stack.push(2);
|
||||
stack.push(5);
|
||||
stack.push(4);
|
||||
|
||||
/* 訪問堆疊頂元素 */
|
||||
let top = stack.last().unwrap();
|
||||
|
||||
/* 元素出堆疊 */
|
||||
let pop = stack.pop().unwrap();
|
||||
|
||||
/* 獲取堆疊的長度 */
|
||||
let size = stack.len();
|
||||
|
||||
/* 判斷是否為空 */
|
||||
let is_empty = stack.is_empty();
|
||||
```
|
||||
|
||||
=== "C"
|
||||
|
||||
```c title="stack.c"
|
||||
// C 未提供內建堆疊
|
||||
```
|
||||
|
||||
=== "Kotlin"
|
||||
|
||||
```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()
|
||||
```
|
||||
|
||||
=== "Ruby"
|
||||
|
||||
```ruby title="stack.rb"
|
||||
|
||||
```
|
||||
|
||||
=== "Zig"
|
||||
|
||||
```zig title="stack.zig"
|
||||
|
||||
```
|
||||
|
||||
??? pythontutor "視覺化執行"
|
||||
|
||||
https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E6%A0%88%0A%20%20%20%20%23%20Python%20%E6%B2%A1%E6%9C%89%E5%86%85%E7%BD%AE%E7%9A%84%E6%A0%88%E7%B1%BB%EF%BC%8C%E5%8F%AF%E4%BB%A5%E6%8A%8A%20list%20%E5%BD%93%E4%BD%9C%E6%A0%88%E6%9D%A5%E4%BD%BF%E7%94%A8%0A%20%20%20%20stack%20%3D%20%5B%5D%0A%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%85%A5%E6%A0%88%0A%20%20%20%20stack.append%281%29%0A%20%20%20%20stack.append%283%29%0A%20%20%20%20stack.append%282%29%0A%20%20%20%20stack.append%285%29%0A%20%20%20%20stack.append%284%29%0A%20%20%20%20print%28%22%E6%A0%88%20stack%20%3D%22,%20stack%29%0A%0A%20%20%20%20%23%20%E8%AE%BF%E9%97%AE%E6%A0%88%E9%A1%B6%E5%85%83%E7%B4%A0%0A%20%20%20%20peek%20%3D%20stack%5B-1%5D%0A%20%20%20%20print%28%22%E6%A0%88%E9%A1%B6%E5%85%83%E7%B4%A0%20peek%20%3D%22,%20peek%29%0A%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%87%BA%E6%A0%88%0A%20%20%20%20pop%20%3D%20stack.pop%28%29%0A%20%20%20%20print%28%22%E5%87%BA%E6%A0%88%E5%85%83%E7%B4%A0%20pop%20%3D%22,%20pop%29%0A%20%20%20%20print%28%22%E5%87%BA%E6%A0%88%E5%90%8E%20stack%20%3D%22,%20stack%29%0A%0A%20%20%20%20%23%20%E8%8E%B7%E5%8F%96%E6%A0%88%E7%9A%84%E9%95%BF%E5%BA%A6%0A%20%20%20%20size%20%3D%20len%28stack%29%0A%20%20%20%20print%28%22%E6%A0%88%E7%9A%84%E9%95%BF%E5%BA%A6%20size%20%3D%22,%20size%29%0A%0A%20%20%20%20%23%20%E5%88%A4%E6%96%AD%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%0A%20%20%20%20is_empty%20%3D%20len%28stack%29%20%3D%3D%200%0A%20%20%20%20print%28%22%E6%A0%88%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%20%3D%22,%20is_empty%29&cumulative=false&curInstr=2&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false
|
||||
|
||||
## 堆疊的實現
|
||||
|
||||
為了深入瞭解堆疊的執行機制，我們來嘗試自己實現一個堆疊類別。
|
||||
|
||||
堆疊遵循先入後出的原則，因此我們只能在堆疊頂新增或刪除元素。然而，陣列和鏈結串列都可以在任意位置新增和刪除元素，**因此堆疊可以視為一種受限制的陣列或鏈結串列**。換句話說，我們可以“遮蔽”陣列或鏈結串列的部分無關操作，使其對外表現的邏輯符合堆疊的特性。
|
||||
|
||||
### 基於鏈結串列的實現
|
||||
|
||||
使用鏈結串列實現堆疊時，我們可以將鏈結串列的頭節點視為堆疊頂，尾節點視為堆疊底。
|
||||
|
||||
如下圖所示，對於入堆疊操作，我們只需將元素插入鏈結串列頭部，這種節點插入方法被稱為“頭插法”。而對於出堆疊操作，只需將頭節點從鏈結串列中刪除即可。
|
||||
|
||||
=== "LinkedListStack"
|
||||
|
||||
|
||||
=== "push()"
|
||||
|
||||
|
||||
=== "pop()"
|
||||
|
||||
|
||||
以下是基於鏈結串列實現堆疊的示例程式碼：
|
||||
|
||||
```src
|
||||
[file]{linkedlist_stack}-[class]{linked_list_stack}-[func]{}
|
||||
```
|
||||
|
||||
### 基於陣列的實現
|
||||
|
||||
使用陣列實現堆疊時，我們可以將陣列的尾部作為堆疊頂。如下圖所示，入堆疊與出堆疊操作分別對應在陣列尾部新增元素與刪除元素，時間複雜度都為 $O(1)$ 。
|
||||
|
||||
=== "ArrayStack"
|
||||
|
||||
|
||||
=== "push()"
|
||||
|
||||
|
||||
=== "pop()"
|
||||
|
||||
|
||||
由於入堆疊的元素可能會源源不斷地增加，因此我們可以使用動態陣列，這樣就無須自行處理陣列擴容問題。以下為示例程式碼：
|
||||
|
||||
```src
|
||||
[file]{array_stack}-[class]{array_stack}-[func]{}
|
||||
```
|
||||
|
||||
## 兩種實現對比
|
||||
|
||||
**支持操作**
|
||||
|
||||
兩種實現都支持堆疊定義中的各項操作。陣列實現額外支持隨機訪問，但這已超出了堆疊的定義範疇，因此一般不會用到。
|
||||
|
||||
**時間效率**
|
||||
|
||||
在基於陣列的實現中，入堆疊和出堆疊操作都在預先分配好的連續記憶體中進行，具有很好的快取本地性，因此效率較高。然而，如果入堆疊時超出陣列容量，會觸發擴容機制，導致該次入堆疊操作的時間複雜度變為 $O(n)$ 。
|
||||
|
||||
在基於鏈結串列的實現中，鏈結串列的擴容非常靈活，不存在上述陣列擴容時效率降低的問題。但是，入堆疊操作需要初始化節點物件並修改指標，因此效率相對較低。不過，如果入堆疊元素本身就是節點物件，那麼可以省去初始化步驟，從而提高效率。
|
||||
|
||||
綜上所述，當入堆疊與出堆疊操作的元素是基本資料型別時，例如 `int` 或 `double` ，我們可以得出以下結論。
|
||||
|
||||
- 基於陣列實現的堆疊在觸發擴容時效率會降低，但由於擴容是低頻操作，因此平均效率更高。
|
||||
- 基於鏈結串列實現的堆疊可以提供更加穩定的效率表現。
|
||||
|
||||
**空間效率**
|
||||
|
||||
在初始化串列時，系統會為串列分配“初始容量”，該容量可能超出實際需求；並且，擴容機制通常是按照特定倍率（例如 2 倍）進行擴容的，擴容後的容量也可能超出實際需求。因此，**基於陣列實現的堆疊可能造成一定的空間浪費**。
|
||||
|
||||
然而，由於鏈結串列節點需要額外儲存指標，**因此鏈結串列節點佔用的空間相對較大**。
|
||||
|
||||
綜上，我們不能簡單地確定哪種實現更加節省記憶體，需要針對具體情況進行分析。
|
||||
|
||||
## 堆疊的典型應用
|
||||
|
||||
- **瀏覽器中的後退與前進、軟體中的撤銷與反撤銷**。每當我們開啟新的網頁，瀏覽器就會對上一個網頁執行入堆疊，這樣我們就可以通過後退操作回到上一個網頁。後退操作實際上是在執行出堆疊。如果要同時支持後退和前進，那麼需要兩個堆疊來配合實現。
|
||||
- **程式記憶體管理**。每次呼叫函式時，系統都會在堆疊頂新增一個堆疊幀，用於記錄函式的上下文資訊。在遞迴函式中，向下遞推階段會不斷執行入堆疊操作，而向上回溯階段則會不斷執行出堆疊操作。
|
||||
31
zh-hant/docs/chapter_stack_and_queue/summary.md
Normal file
31
zh-hant/docs/chapter_stack_and_queue/summary.md
Normal file
@@ -0,0 +1,31 @@
|
||||
# 小結
|
||||
|
||||
### 重點回顧
|
||||
|
||||
- 堆疊是一種遵循先入後出原則的資料結構，可透過陣列或鏈結串列來實現。
|
||||
- 在時間效率方面，堆疊的陣列實現具有較高的平均效率，但在擴容過程中，單次入堆疊操作的時間複雜度會劣化至 $O(n)$ 。相比之下，堆疊的鏈結串列實現具有更為穩定的效率表現。
|
||||
- 在空間效率方面，堆疊的陣列實現可能導致一定程度的空間浪費。但需要注意的是，鏈結串列節點所佔用的記憶體空間比陣列元素更大。
|
||||
- 佇列是一種遵循先入先出原則的資料結構，同樣可以透過陣列或鏈結串列來實現。在時間效率和空間效率的對比上，佇列的結論與前述堆疊的結論相似。
|
||||
- 雙向佇列是一種具有更高自由度的佇列，它允許在兩端進行元素的新增和刪除操作。
|
||||
|
||||
### Q & A
|
||||
|
||||
**Q**：瀏覽器的前進後退是否是雙向鏈結串列實現？
|
||||
|
||||
瀏覽器的前進後退功能本質上是“堆疊”的體現。當用戶訪問一個新頁面時，該頁面會被新增到堆疊頂；當用戶點選後退按鈕時，該頁面會從堆疊頂彈出。使用雙向佇列可以方便地實現一些額外操作，這個在“雙向佇列”章節有提到。
|
||||
|
||||
**Q**：在出堆疊後，是否需要釋放出堆疊節點的記憶體？
|
||||
|
||||
如果後續仍需要使用彈出節點，則不需要釋放記憶體。若之後不需要用到，`Java` 和 `Python` 等語言擁有自動垃圾回收機制，因此不需要手動釋放記憶體；在 `C` 和 `C++` 中需要手動釋放記憶體。
|
||||
|
||||
**Q**：雙向佇列像是兩個堆疊拼接在了一起，它的用途是什麼？
|
||||
|
||||
雙向佇列就像是堆疊和佇列的組合或兩個堆疊拼在了一起。它表現的是堆疊 + 佇列的邏輯，因此可以實現堆疊與佇列的所有應用，並且更加靈活。
|
||||
|
||||
**Q**：撤銷（undo）和反撤銷（redo）具體是如何實現的？
|
||||
|
||||
使用兩個堆疊，堆疊 `A` 用於撤銷，堆疊 `B` 用於反撤銷。
|
||||
|
||||
1. 每當使用者執行一個操作，將這個操作壓入堆疊 `A` ，並清空堆疊 `B` 。
|
||||
2. 當用戶執行“撤銷”時，從堆疊 `A` 中彈出最近的操作，並將其壓入堆疊 `B` 。
|
||||
3. 當用戶執行“反撤銷”時，從堆疊 `B` 中彈出最近的操作，並將其壓入堆疊 `A` 。
|
||||
Reference in New Issue
Block a user