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
2024-04-06 02:30:11 +08:00
committed by GitHub
parent 33d7f8a2e5
commit 5f7385c8a3
1875 changed files with 102923 additions and 18 deletions
@@ -0,0 +1,152 @@
/**
* File: array_deque.cs
* Created Time: 2023-03-08
* Author: hpstory (hpstory1024@163.com)
*/
namespace hello_algo.chapter_stack_and_queue;
/* 基於環形陣列實現的雙向佇列 */
public class ArrayDeque {
int[] nums; // 用於儲存雙向佇列元素的陣列
int front; // 佇列首指標,指向佇列首元素
int queSize; // 雙向佇列長度
/* 建構子 */
public ArrayDeque(int capacity) {
nums = new int[capacity];
front = queSize = 0;
}
/* 獲取雙向佇列的容量 */
int Capacity() {
return nums.Length;
}
/* 獲取雙向佇列的長度 */
public int Size() {
return queSize;
}
/* 判斷雙向佇列是否為空 */
public bool IsEmpty() {
return queSize == 0;
}
/* 計算環形陣列索引 */
int Index(int i) {
// 透過取餘操作實現陣列首尾相連
// 當 i 越過陣列尾部後,回到頭部
// 當 i 越過陣列頭部後,回到尾部
return (i + Capacity()) % Capacity();
}
/* 佇列首入列 */
public void PushFirst(int num) {
if (queSize == Capacity()) {
Console.WriteLine("雙向佇列已滿");
return;
}
// 佇列首指標向左移動一位
// 透過取餘操作實現 front 越過陣列頭部後回到尾部
front = Index(front - 1);
// 將 num 新增至佇列首
nums[front] = num;
queSize++;
}
/* 佇列尾入列 */
public void PushLast(int num) {
if (queSize == Capacity()) {
Console.WriteLine("雙向佇列已滿");
return;
}
// 計算佇列尾指標,指向佇列尾索引 + 1
int rear = Index(front + queSize);
// 將 num 新增至佇列尾
nums[rear] = num;
queSize++;
}
/* 佇列首出列 */
public int PopFirst() {
int num = PeekFirst();
// 佇列首指標向後移動一位
front = Index(front + 1);
queSize--;
return num;
}
/* 佇列尾出列 */
public int PopLast() {
int num = PeekLast();
queSize--;
return num;
}
/* 訪問佇列首元素 */
public int PeekFirst() {
if (IsEmpty()) {
throw new InvalidOperationException();
}
return nums[front];
}
/* 訪問佇列尾元素 */
public int PeekLast() {
if (IsEmpty()) {
throw new InvalidOperationException();
}
// 計算尾元素索引
int last = Index(front + queSize - 1);
return nums[last];
}
/* 返回陣列用於列印 */
public int[] ToArray() {
// 僅轉換有效長度範圍內的串列元素
int[] res = new int[queSize];
for (int i = 0, j = front; i < queSize; i++, j++) {
res[i] = nums[Index(j)];
}
return res;
}
}
public class array_deque {
[Test]
public void Test() {
/* 初始化雙向佇列 */
ArrayDeque deque = new(10);
deque.PushLast(3);
deque.PushLast(2);
deque.PushLast(5);
Console.WriteLine("雙向佇列 deque = " + string.Join(" ", deque.ToArray()));
/* 訪問元素 */
int peekFirst = deque.PeekFirst();
Console.WriteLine("佇列首元素 peekFirst = " + peekFirst);
int peekLast = deque.PeekLast();
Console.WriteLine("佇列尾元素 peekLast = " + peekLast);
/* 元素入列 */
deque.PushLast(4);
Console.WriteLine("元素 4 佇列尾入列後 deque = " + string.Join(" ", deque.ToArray()));
deque.PushFirst(1);
Console.WriteLine("元素 1 佇列首入列後 deque = " + string.Join(" ", deque.ToArray()));
/* 元素出列 */
int popLast = deque.PopLast();
Console.WriteLine("佇列尾出列元素 = " + popLast + ",佇列尾出列後 deque = " + string.Join(" ", deque.ToArray()));
int popFirst = deque.PopFirst();
Console.WriteLine("佇列首出列元素 = " + popFirst + ",佇列首出列後 deque = " + string.Join(" ", deque.ToArray()));
/* 獲取雙向佇列的長度 */
int size = deque.Size();
Console.WriteLine("雙向佇列長度 size = " + size);
/* 判斷雙向佇列是否為空 */
bool isEmpty = deque.IsEmpty();
Console.WriteLine("雙向佇列是否為空 = " + isEmpty);
}
}
@@ -0,0 +1,114 @@
/**
* File: array_queue.cs
* Created Time: 2022-12-23
* Author: haptear (haptear@hotmail.com)
*/
namespace hello_algo.chapter_stack_and_queue;
/* 基於環形陣列實現的佇列 */
class ArrayQueue {
int[] nums; // 用於儲存佇列元素的陣列
int front; // 佇列首指標,指向佇列首元素
int queSize; // 佇列長度
public ArrayQueue(int capacity) {
nums = new int[capacity];
front = queSize = 0;
}
/* 獲取佇列的容量 */
int Capacity() {
return nums.Length;
}
/* 獲取佇列的長度 */
public int Size() {
return queSize;
}
/* 判斷佇列是否為空 */
public bool IsEmpty() {
return queSize == 0;
}
/* 入列 */
public void Push(int num) {
if (queSize == Capacity()) {
Console.WriteLine("佇列已滿");
return;
}
// 計算佇列尾指標,指向佇列尾索引 + 1
// 透過取餘操作實現 rear 越過陣列尾部後回到頭部
int rear = (front + queSize) % Capacity();
// 將 num 新增至佇列尾
nums[rear] = num;
queSize++;
}
/* 出列 */
public int Pop() {
int num = Peek();
// 佇列首指標向後移動一位,若越過尾部,則返回到陣列頭部
front = (front + 1) % Capacity();
queSize--;
return num;
}
/* 訪問佇列首元素 */
public int Peek() {
if (IsEmpty())
throw new Exception();
return nums[front];
}
/* 返回陣列 */
public int[] ToArray() {
// 僅轉換有效長度範圍內的串列元素
int[] res = new int[queSize];
for (int i = 0, j = front; i < queSize; i++, j++) {
res[i] = nums[j % this.Capacity()];
}
return res;
}
}
public class array_queue {
[Test]
public void Test() {
/* 初始化佇列 */
int capacity = 10;
ArrayQueue queue = new(capacity);
/* 元素入列 */
queue.Push(1);
queue.Push(3);
queue.Push(2);
queue.Push(5);
queue.Push(4);
Console.WriteLine("佇列 queue = " + string.Join(",", queue.ToArray()));
/* 訪問佇列首元素 */
int peek = queue.Peek();
Console.WriteLine("佇列首元素 peek = " + peek);
/* 元素出列 */
int pop = queue.Pop();
Console.WriteLine("出列元素 pop = " + pop + ",出列後 queue = " + string.Join(",", queue.ToArray()));
/* 獲取佇列的長度 */
int size = queue.Size();
Console.WriteLine("佇列長度 size = " + size);
/* 判斷佇列是否為空 */
bool isEmpty = queue.IsEmpty();
Console.WriteLine("佇列是否為空 = " + isEmpty);
/* 測試環形陣列 */
for (int i = 0; i < 10; i++) {
queue.Push(i);
queue.Pop();
Console.WriteLine("第 " + i + " 輪入列 + 出列後 queue = " + string.Join(",", queue.ToArray()));
}
}
}
@@ -0,0 +1,84 @@
/**
* File: array_stack.cs
* Created Time: 2022-12-23
* Author: haptear (haptear@hotmail.com)
*/
namespace hello_algo.chapter_stack_and_queue;
/* 基於陣列實現的堆疊 */
class ArrayStack {
List<int> stack;
public ArrayStack() {
// 初始化串列(動態陣列)
stack = [];
}
/* 獲取堆疊的長度 */
public int Size() {
return stack.Count;
}
/* 判斷堆疊是否為空 */
public bool IsEmpty() {
return Size() == 0;
}
/* 入堆疊 */
public void Push(int num) {
stack.Add(num);
}
/* 出堆疊 */
public int Pop() {
if (IsEmpty())
throw new Exception();
var val = Peek();
stack.RemoveAt(Size() - 1);
return val;
}
/* 訪問堆疊頂元素 */
public int Peek() {
if (IsEmpty())
throw new Exception();
return stack[Size() - 1];
}
/* 將 List 轉化為 Array 並返回 */
public int[] ToArray() {
return [.. stack];
}
}
public class array_stack {
[Test]
public void Test() {
/* 初始化堆疊 */
ArrayStack stack = new();
/* 元素入堆疊 */
stack.Push(1);
stack.Push(3);
stack.Push(2);
stack.Push(5);
stack.Push(4);
Console.WriteLine("堆疊 stack = " + string.Join(",", stack.ToArray()));
/* 訪問堆疊頂元素 */
int peek = stack.Peek();
Console.WriteLine("堆疊頂元素 peek = " + peek);
/* 元素出堆疊 */
int pop = stack.Pop();
Console.WriteLine("出堆疊元素 pop = " + pop + ",出堆疊後 stack = " + string.Join(",", stack.ToArray()));
/* 獲取堆疊的長度 */
int size = stack.Size();
Console.WriteLine("堆疊的長度 size = " + size);
/* 判斷是否為空 */
bool isEmpty = stack.IsEmpty();
Console.WriteLine("堆疊是否為空 = " + isEmpty);
}
}
@@ -0,0 +1,44 @@
/**
* File: deque.cs
* Created Time: 2022-12-30
* Author: moonache (microin1301@outlook.com)
*/
namespace hello_algo.chapter_stack_and_queue;
public class deque {
[Test]
public void Test() {
/* 初始化雙向佇列 */
// 在 C# 中,將鏈結串列 LinkedList 看作雙向佇列來使用
LinkedList<int> deque = new();
/* 元素入列 */
deque.AddLast(2); // 新增至佇列尾
deque.AddLast(5);
deque.AddLast(4);
deque.AddFirst(3); // 新增至佇列首
deque.AddFirst(1);
Console.WriteLine("雙向佇列 deque = " + string.Join(",", deque));
/* 訪問元素 */
int? peekFirst = deque.First?.Value; // 佇列首元素
Console.WriteLine("佇列首元素 peekFirst = " + peekFirst);
int? peekLast = deque.Last?.Value; // 佇列尾元素
Console.WriteLine("佇列尾元素 peekLast = " + peekLast);
/* 元素出列 */
deque.RemoveFirst(); // 佇列首元素出列
Console.WriteLine("佇列首元素出列後 deque = " + string.Join(",", deque));
deque.RemoveLast(); // 佇列尾元素出列
Console.WriteLine("佇列尾元素出列後 deque = " + string.Join(",", deque));
/* 獲取雙向佇列的長度 */
int size = deque.Count;
Console.WriteLine("雙向佇列長度 size = " + size);
/* 判斷雙向佇列是否為空 */
bool isEmpty = deque.Count == 0;
Console.WriteLine("雙向佇列是否為空 = " + isEmpty);
}
}
@@ -0,0 +1,177 @@
/**
* File: linkedlist_deque.cs
* Created Time: 2023-03-08
* Author: hpstory (hpstory1024@163.com)
*/
namespace hello_algo.chapter_stack_and_queue;
/* 雙向鏈結串列節點 */
public class ListNode(int val) {
public int val = val; // 節點值
public ListNode? next = null; // 後繼節點引用
public ListNode? prev = null; // 前驅節點引用
}
/* 基於雙向鏈結串列實現的雙向佇列 */
public class LinkedListDeque {
ListNode? front, rear; // 頭節點 front, 尾節點 rear
int queSize = 0; // 雙向佇列的長度
public LinkedListDeque() {
front = null;
rear = null;
}
/* 獲取雙向佇列的長度 */
public int Size() {
return queSize;
}
/* 判斷雙向佇列是否為空 */
public bool IsEmpty() {
return Size() == 0;
}
/* 入列操作 */
void Push(int num, bool isFront) {
ListNode node = new(num);
// 若鏈結串列為空,則令 front 和 rear 都指向 node
if (IsEmpty()) {
front = node;
rear = node;
}
// 佇列首入列操作
else if (isFront) {
// 將 node 新增至鏈結串列頭部
front!.prev = node;
node.next = front;
front = node; // 更新頭節點
}
// 佇列尾入列操作
else {
// 將 node 新增至鏈結串列尾部
rear!.next = node;
node.prev = rear;
rear = node; // 更新尾節點
}
queSize++; // 更新佇列長度
}
/* 佇列首入列 */
public void PushFirst(int num) {
Push(num, true);
}
/* 佇列尾入列 */
public void PushLast(int num) {
Push(num, false);
}
/* 出列操作 */
int? Pop(bool isFront) {
if (IsEmpty())
throw new Exception();
int? val;
// 佇列首出列操作
if (isFront) {
val = front?.val; // 暫存頭節點值
// 刪除頭節點
ListNode? fNext = front?.next;
if (fNext != null) {
fNext.prev = null;
front!.next = null;
}
front = fNext; // 更新頭節點
}
// 佇列尾出列操作
else {
val = rear?.val; // 暫存尾節點值
// 刪除尾節點
ListNode? rPrev = rear?.prev;
if (rPrev != null) {
rPrev.next = null;
rear!.prev = null;
}
rear = rPrev; // 更新尾節點
}
queSize--; // 更新佇列長度
return val;
}
/* 佇列首出列 */
public int? PopFirst() {
return Pop(true);
}
/* 佇列尾出列 */
public int? PopLast() {
return Pop(false);
}
/* 訪問佇列首元素 */
public int? PeekFirst() {
if (IsEmpty())
throw new Exception();
return front?.val;
}
/* 訪問佇列尾元素 */
public int? PeekLast() {
if (IsEmpty())
throw new Exception();
return rear?.val;
}
/* 返回陣列用於列印 */
public int?[] ToArray() {
ListNode? node = front;
int?[] res = new int?[Size()];
for (int i = 0; i < res.Length; i++) {
res[i] = node?.val;
node = node?.next;
}
return res;
}
}
public class linkedlist_deque {
[Test]
public void Test() {
/* 初始化雙向佇列 */
LinkedListDeque deque = new();
deque.PushLast(3);
deque.PushLast(2);
deque.PushLast(5);
Console.WriteLine("雙向佇列 deque = " + string.Join(" ", deque.ToArray()));
/* 訪問元素 */
int? peekFirst = deque.PeekFirst();
Console.WriteLine("佇列首元素 peekFirst = " + peekFirst);
int? peekLast = deque.PeekLast();
Console.WriteLine("佇列尾元素 peekLast = " + peekLast);
/* 元素入列 */
deque.PushLast(4);
Console.WriteLine("元素 4 佇列尾入列後 deque = " + string.Join(" ", deque.ToArray()));
deque.PushFirst(1);
Console.WriteLine("元素 1 佇列首入列後 deque = " + string.Join(" ", deque.ToArray()));
/* 元素出列 */
int? popLast = deque.PopLast();
Console.WriteLine("佇列尾出列元素 = " + popLast + ",佇列尾出列後 deque = " + string.Join(" ", deque.ToArray()));
int? popFirst = deque.PopFirst();
Console.WriteLine("佇列首出列元素 = " + popFirst + ",佇列首出列後 deque = " + string.Join(" ", deque.ToArray()));
/* 獲取雙向佇列的長度 */
int size = deque.Size();
Console.WriteLine("雙向佇列長度 size = " + size);
/* 判斷雙向佇列是否為空 */
bool isEmpty = deque.IsEmpty();
Console.WriteLine("雙向佇列是否為空 = " + isEmpty);
}
}
@@ -0,0 +1,106 @@
/**
* File: linkedlist_queue.cs
* Created Time: 2022-12-23
* Author: haptear (haptear@hotmail.com)
*/
namespace hello_algo.chapter_stack_and_queue;
/* 基於鏈結串列實現的佇列 */
class LinkedListQueue {
ListNode? front, rear; // 頭節點 front ,尾節點 rear
int queSize = 0;
public LinkedListQueue() {
front = null;
rear = null;
}
/* 獲取佇列的長度 */
public int Size() {
return queSize;
}
/* 判斷佇列是否為空 */
public bool IsEmpty() {
return Size() == 0;
}
/* 入列 */
public void Push(int num) {
// 在尾節點後新增 num
ListNode node = new(num);
// 如果佇列為空,則令頭、尾節點都指向該節點
if (front == null) {
front = node;
rear = node;
// 如果佇列不為空,則將該節點新增到尾節點後
} else if (rear != null) {
rear.next = node;
rear = node;
}
queSize++;
}
/* 出列 */
public int Pop() {
int num = Peek();
// 刪除頭節點
front = front?.next;
queSize--;
return num;
}
/* 訪問佇列首元素 */
public int Peek() {
if (IsEmpty())
throw new Exception();
return front!.val;
}
/* 將鏈結串列轉化為 Array 並返回 */
public int[] ToArray() {
if (front == null)
return [];
ListNode? node = front;
int[] res = new int[Size()];
for (int i = 0; i < res.Length; i++) {
res[i] = node!.val;
node = node.next;
}
return res;
}
}
public class linkedlist_queue {
[Test]
public void Test() {
/* 初始化佇列 */
LinkedListQueue queue = new();
/* 元素入列 */
queue.Push(1);
queue.Push(3);
queue.Push(2);
queue.Push(5);
queue.Push(4);
Console.WriteLine("佇列 queue = " + string.Join(",", queue.ToArray()));
/* 訪問佇列首元素 */
int peek = queue.Peek();
Console.WriteLine("佇列首元素 peek = " + peek);
/* 元素出列 */
int pop = queue.Pop();
Console.WriteLine("出列元素 pop = " + pop + ",出列後 queue = " + string.Join(",", queue.ToArray()));
/* 獲取佇列的長度 */
int size = queue.Size();
Console.WriteLine("佇列長度 size = " + size);
/* 判斷佇列是否為空 */
bool isEmpty = queue.IsEmpty();
Console.WriteLine("佇列是否為空 = " + isEmpty);
}
}
@@ -0,0 +1,97 @@
/**
* File: linkedlist_stack.cs
* Created Time: 2022-12-23
* Author: haptear (haptear@hotmail.com)
*/
namespace hello_algo.chapter_stack_and_queue;
/* 基於鏈結串列實現的堆疊 */
class LinkedListStack {
ListNode? stackPeek; // 將頭節點作為堆疊頂
int stkSize = 0; // 堆疊的長度
public LinkedListStack() {
stackPeek = null;
}
/* 獲取堆疊的長度 */
public int Size() {
return stkSize;
}
/* 判斷堆疊是否為空 */
public bool IsEmpty() {
return Size() == 0;
}
/* 入堆疊 */
public void Push(int num) {
ListNode node = new(num) {
next = stackPeek
};
stackPeek = node;
stkSize++;
}
/* 出堆疊 */
public int Pop() {
int num = Peek();
stackPeek = stackPeek!.next;
stkSize--;
return num;
}
/* 訪問堆疊頂元素 */
public int Peek() {
if (IsEmpty())
throw new Exception();
return stackPeek!.val;
}
/* 將 List 轉化為 Array 並返回 */
public int[] ToArray() {
if (stackPeek == null)
return [];
ListNode? node = stackPeek;
int[] res = new int[Size()];
for (int i = res.Length - 1; i >= 0; i--) {
res[i] = node!.val;
node = node.next;
}
return res;
}
}
public class linkedlist_stack {
[Test]
public void Test() {
/* 初始化堆疊 */
LinkedListStack stack = new();
/* 元素入堆疊 */
stack.Push(1);
stack.Push(3);
stack.Push(2);
stack.Push(5);
stack.Push(4);
Console.WriteLine("堆疊 stack = " + string.Join(",", stack.ToArray()));
/* 訪問堆疊頂元素 */
int peek = stack.Peek();
Console.WriteLine("堆疊頂元素 peek = " + peek);
/* 元素出堆疊 */
int pop = stack.Pop();
Console.WriteLine("出堆疊元素 pop = " + pop + ",出堆疊後 stack = " + string.Join(",", stack.ToArray()));
/* 獲取堆疊的長度 */
int size = stack.Size();
Console.WriteLine("堆疊的長度 size = " + size);
/* 判斷是否為空 */
bool isEmpty = stack.IsEmpty();
Console.WriteLine("堆疊是否為空 = " + isEmpty);
}
}
@@ -0,0 +1,39 @@
/**
* File: queue.cs
* Created Time: 2022-12-23
* Author: haptear (haptear@hotmail.com)
*/
namespace hello_algo.chapter_stack_and_queue;
public class queue {
[Test]
public void Test() {
/* 初始化佇列 */
Queue<int> queue = new();
/* 元素入列 */
queue.Enqueue(1);
queue.Enqueue(3);
queue.Enqueue(2);
queue.Enqueue(5);
queue.Enqueue(4);
Console.WriteLine("佇列 queue = " + string.Join(",", queue));
/* 訪問佇列首元素 */
int peek = queue.Peek();
Console.WriteLine("佇列首元素 peek = " + peek);
/* 元素出列 */
int pop = queue.Dequeue();
Console.WriteLine("出列元素 pop = " + pop + ",出列後 queue = " + string.Join(",", queue));
/* 獲取佇列的長度 */
int size = queue.Count;
Console.WriteLine("佇列長度 size = " + size);
/* 判斷佇列是否為空 */
bool isEmpty = queue.Count == 0;
Console.WriteLine("佇列是否為空 = " + isEmpty);
}
}
@@ -0,0 +1,40 @@
/**
* File: stack.cs
* Created Time: 2022-12-23
* Author: haptear (haptear@hotmail.com)
*/
namespace hello_algo.chapter_stack_and_queue;
public class stack {
[Test]
public void Test() {
/* 初始化堆疊 */
Stack<int> stack = new();
/* 元素入堆疊 */
stack.Push(1);
stack.Push(3);
stack.Push(2);
stack.Push(5);
stack.Push(4);
// 請注意,stack.ToArray() 得到的是倒序序列,即索引 0 為堆疊頂
Console.WriteLine("堆疊 stack = " + string.Join(",", stack));
/* 訪問堆疊頂元素 */
int peek = stack.Peek();
Console.WriteLine("堆疊頂元素 peek = " + peek);
/* 元素出堆疊 */
int pop = stack.Pop();
Console.WriteLine("出堆疊元素 pop = " + pop + ",出堆疊後 stack = " + string.Join(",", stack));
/* 獲取堆疊的長度 */
int size = stack.Count;
Console.WriteLine("堆疊的長度 size = " + size);
/* 判斷是否為空 */
bool isEmpty = stack.Count == 0;
Console.WriteLine("堆疊是否為空 = " + isEmpty);
}
}