xinyin025/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-07-21 19:06:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: Traditional Chinese version (#1163)

Browse Source 
* 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
Download Patch File Download Diff File Expand all files Collapse all files
zh-hant/codes/rust/chapter_stack_and_queue/array_deque.rs
+162
View File
@@ -0,0 +1,162 @@
/*
* File: array_deque.rs
* Created Time: 2023-03-11
* Author: codingonion (coderonion@gmail.com)
*/
include!("../include/include.rs");
/* 基於環形陣列實現的雙向佇列 */
struct ArrayDeque {
nums: Vec<i32>, // 用於儲存雙向佇列元素的陣列
front: usize, // 佇列首指標，指向佇列首元素
que_size: usize, // 雙向佇列長度
}
impl ArrayDeque {
/* 建構子 */
pub fn new(capacity: usize) -> Self {
Self {
nums: vec![0; capacity],
front: 0,
que_size: 0,
}
}
/* 獲取雙向佇列的容量 */
pub fn capacity(&self) -> usize {
self.nums.len()
}
/* 獲取雙向佇列的長度 */
pub fn size(&self) -> usize {
self.que_size
}
/* 判斷雙向佇列是否為空 */
pub fn is_empty(&self) -> bool {
self.que_size == 0
}
/* 計算環形陣列索引 */
fn index(&self, i: i32) -> usize {
// 透過取餘操作實現陣列首尾相連
// 當 i 越過陣列尾部後，回到頭部
// 當 i 越過陣列頭部後，回到尾部
return ((i + self.capacity() as i32) % self.capacity() as i32) as usize;
}
/* 佇列首入列 */
pub fn push_first(&mut self, num: i32) {
if self.que_size == self.capacity() {
println!("雙向佇列已滿");
return;
}
// 佇列首指標向左移動一位
// 透過取餘操作實現 front 越過陣列頭部後回到尾部
self.front = self.index(self.front as i32 - 1);
// 將 num 新增至佇列首
self.nums[self.front] = num;
self.que_size += 1;
}
/* 佇列尾入列 */
pub fn push_last(&mut self, num: i32) {
if self.que_size == self.capacity() {
println!("雙向佇列已滿");
return;
}
// 計算佇列尾指標，指向佇列尾索引 + 1
let rear = self.index(self.front as i32 + self.que_size as i32);
// 將 num 新增至佇列尾
self.nums[rear] = num;
self.que_size += 1;
}
/* 佇列首出列 */
fn pop_first(&mut self) -> i32 {
let num = self.peek_first();
// 佇列首指標向後移動一位
self.front = self.index(self.front as i32 + 1);
self.que_size -= 1;
num
}
/* 佇列尾出列 */
fn pop_last(&mut self) -> i32 {
let num = self.peek_last();
self.que_size -= 1;
num
}
/* 訪問佇列首元素 */
fn peek_first(&self) -> i32 {
if self.is_empty() {
panic!("雙向佇列為空")
};
self.nums[self.front]
}
/* 訪問佇列尾元素 */
fn peek_last(&self) -> i32 {
if self.is_empty() {
panic!("雙向佇列為空")
};
// 計算尾元素索引
let last = self.index(self.front as i32 + self.que_size as i32 - 1);
self.nums[last]
}
/* 返回陣列用於列印 */
fn to_array(&self) -> Vec<i32> {
// 僅轉換有效長度範圍內的串列元素
let mut res = vec![0; self.que_size];
let mut j = self.front;
for i in 0..self.que_size {
res[i] = self.nums[self.index(j as i32)];
j += 1;
}
res
}
}
/* Driver Code */
fn main() {
/* 初始化雙向佇列 */
let mut deque = ArrayDeque::new(10);
deque.push_last(3);
deque.push_last(2);
deque.push_last(5);
print!("雙向佇列 deque = ");
print_util::print_array(&deque.to_array());
/* 訪問元素 */
let peek_first = deque.peek_first();
print!("\n佇列首元素 peek_first = {}", peek_first);
let peek_last = deque.peek_last();
print!("\n佇列尾元素 peek_last = {}", peek_last);
/* 元素入列 */
deque.push_last(4);
print!("\n元素 4 佇列尾入列後 deque = ");
print_util::print_array(&deque.to_array());
deque.push_first(1);
print!("\n元素 1 佇列首入列後 deque = ");
print_util::print_array(&deque.to_array());
/* 元素出列 */
let pop_last = deque.pop_last();
print!("\n佇列尾出列元素 = {}，佇列尾出列後 deque = ", pop_last);
print_util::print_array(&deque.to_array());
let pop_first = deque.pop_first();
print!("\n佇列首出列元素 = {}，佇列首出列後 deque = ", pop_first);
print_util::print_array(&deque.to_array());
/* 獲取雙向佇列的長度 */
let size = deque.size();
print!("\n雙向佇列長度 size = {}", size);
/* 判斷雙向佇列是否為空 */
let is_empty = deque.is_empty();
print!("\n雙向佇列是否為空 = {}", is_empty);
}
zh-hant/codes/rust/chapter_stack_and_queue/array_queue.rs
+125
View File
@@ -0,0 +1,125 @@
/*
* File: array_queue.rs
* Created Time: 2023-02-06
* Author: WSL0809 (wslzzy@outlook.com)
*/
/* 基於環形陣列實現的佇列 */
struct ArrayQueue {
nums: Vec<i32>, // 用於儲存佇列元素的陣列
front: i32, // 佇列首指標，指向佇列首元素
que_size: i32, // 佇列長度
que_capacity: i32, // 佇列容量
}
impl ArrayQueue {
/* 建構子 */
fn new(capacity: i32) -> ArrayQueue {
ArrayQueue {
nums: vec![0; capacity as usize],
front: 0,
que_size: 0,
que_capacity: capacity,
}
}
/* 獲取佇列的容量 */
fn capacity(&self) -> i32 {
self.que_capacity
}
/* 獲取佇列的長度 */
fn size(&self) -> i32 {
self.que_size
}
/* 判斷佇列是否為空 */
fn is_empty(&self) -> bool {
self.que_size == 0
}
/* 入列 */
fn push(&mut self, num: i32) {
if self.que_size == self.capacity() {
println!("佇列已滿");
return;
}
// 計算佇列尾指標，指向佇列尾索引 + 1
// 透過取餘操作實現 rear 越過陣列尾部後回到頭部
let rear = (self.front + self.que_size) % self.que_capacity;
// 將 num 新增至佇列尾
self.nums[rear as usize] = num;
self.que_size += 1;
}
/* 出列 */
fn pop(&mut self) -> i32 {
let num = self.peek();
// 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部
self.front = (self.front + 1) % self.que_capacity;
self.que_size -= 1;
num
}
/* 訪問佇列首元素 */
fn peek(&self) -> i32 {
if self.is_empty() {
panic!("index out of bounds");
}
self.nums[self.front as usize]
}
/* 返回陣列 */
fn to_vector(&self) -> Vec<i32> {
let cap = self.que_capacity;
let mut j = self.front;
let mut arr = vec![0; self.que_size as usize];
for i in 0..self.que_size {
arr[i as usize] = self.nums[(j % cap) as usize];
j += 1;
}
arr
}
}
/* Driver Code */
fn main() {
/* 初始化佇列 */
let capacity = 10;
let mut queue = ArrayQueue::new(capacity);
/* 元素入列 */
queue.push(1);
queue.push(3);
queue.push(2);
queue.push(5);
queue.push(4);
println!("佇列 queue = {:?}", queue.to_vector());
/* 訪問佇列首元素 */
let peek = queue.peek();
println!("佇列首元素 peek = {}", peek);
/* 元素出列 */
let pop = queue.pop();
println!(
"出列元素 pop = {:?},出列後 queue = {:?}",
pop,
queue.to_vector()
);
/* 獲取佇列的長度 */
let size = queue.size();
println!("佇列長度 size = {}", size);
/* 判斷佇列是否為空 */
let is_empty = queue.is_empty();
println!("佇列是否為空 = {}", is_empty);
/* 測試環形陣列 */
for i in 0..10 {
queue.push(i);
queue.pop();
println!("第 {:?} 輪入列 + 出列後 queue = {:?}", i, queue.to_vector());
}
}
zh-hant/codes/rust/chapter_stack_and_queue/array_stack.rs
+86
View File
@@ -0,0 +1,86 @@
/*
* File: array_stack.rs
* Created Time: 2023-02-05
* Author: WSL0809 (wslzzy@outlook.com), codingonion (coderonion@gmail.com)
*/
include!("../include/include.rs");
/* 基於陣列實現的堆疊 */
struct ArrayStack<T> {
stack: Vec<T>,
}
impl<T> ArrayStack<T> {
/* 初始化堆疊 */
fn new() -> ArrayStack<T> {
ArrayStack::<T> {
stack: Vec::<T>::new(),
}
}
/* 獲取堆疊的長度 */
fn size(&self) -> usize {
self.stack.len()
}
/* 判斷堆疊是否為空 */
fn is_empty(&self) -> bool {
self.size() == 0
}
/* 入堆疊 */
fn push(&mut self, num: T) {
self.stack.push(num);
}
/* 出堆疊 */
fn pop(&mut self) -> Option<T> {
self.stack.pop()
}
/* 訪問堆疊頂元素 */
fn peek(&self) -> Option<&T> {
if self.is_empty() {
panic!("堆疊為空")
};
self.stack.last()
}
/* 返回 &Vec */
fn to_array(&self) -> &Vec<T> {
&self.stack
}
}
/* Driver Code */
fn main() {
// 初始化堆疊
let mut stack = ArrayStack::<i32>::new();
// 元素入堆疊
stack.push(1);
stack.push(3);
stack.push(2);
stack.push(5);
stack.push(4);
print!("堆疊 stack = ");
print_util::print_array(stack.to_array());
//訪問堆疊頂元素
let peek = stack.peek().unwrap();
print!("\n堆疊頂元素 peek = {}", peek);
// 元素出堆疊
let pop = stack.pop().unwrap();
print!("\n出堆疊元素 pop = {pop}，出堆疊後 stack = ");
print_util::print_array(stack.to_array());
// 獲取堆疊的長度
let size = stack.size();
print!("\n堆疊的長度 size = {size}");
// 判斷是否為空
let is_empty = stack.is_empty();
print!("\n堆疊是否為空 = {is_empty}");
}
zh-hant/codes/rust/chapter_stack_and_queue/deque.rs
+50
View File
@@ -0,0 +1,50 @@
/*
* File: deque.rs
* Created Time: 2023-02-05
* Author: codingonion (coderonion@gmail.com), xBLACKICEx (xBLACKICEx@outlook.com)
*/
include!("../include/include.rs");
use std::collections::VecDeque;
/* Driver Code */
pub fn main() {
// 初始化雙向佇列
let mut deque: VecDeque<i32> = VecDeque::new();
deque.push_back(3);
deque.push_back(2);
deque.push_back(5);
print!("雙向佇列 deque = ");
print_util::print_queue(&deque);
// 訪問元素
let peek_first = deque.front().unwrap();
print!("\n佇列首元素 peekFirst = {peek_first}");
let peek_last = deque.back().unwrap();
print!("\n佇列尾元素 peekLast = {peek_last}");
/* 元素入列 */
deque.push_back(4);
print!("\n元素 4 佇列尾入列後 deque = ");
print_util::print_queue(&deque);
deque.push_front(1);
print!("\n元素 1 佇列首入列後 deque = ");
print_util::print_queue(&deque);
// 元素出列
let pop_last = deque.pop_back().unwrap();
print!("\n佇列尾出列元素 = {pop_last}，佇列尾出列後 deque = ");
print_util::print_queue(&deque);
let pop_first = deque.pop_front().unwrap();
print!("\n佇列首出列元素 = {pop_first}，佇列首出列後 deque = ");
print_util::print_queue(&deque);
// 獲取雙向佇列的長度
let size = deque.len();
print!("\n雙向佇列長度 size = {size}");
// 判斷雙向佇列是否為空
let is_empty = deque.is_empty();
print!("\n雙向佇列是否為空 = {is_empty}");
}
zh-hant/codes/rust/chapter_stack_and_queue/linkedlist_deque.rs
+214
View File
@@ -0,0 +1,214 @@
/*
* File: linkedlist_deque.rs
* Created Time: 2023-03-11
* Author: codingonion (coderonion@gmail.com)
*/
include!("../include/include.rs");
use std::cell::RefCell;
use std::rc::Rc;
/* 雙向鏈結串列節點 */
pub struct ListNode<T> {
pub val: T, // 節點值
pub next: Option<Rc<RefCell<ListNode<T>>>>, // 後繼節點指標
pub prev: Option<Rc<RefCell<ListNode<T>>>>, // 前驅節點指標
}
impl<T> ListNode<T> {
pub fn new(val: T) -> Rc<RefCell<ListNode<T>>> {
Rc::new(RefCell::new(ListNode {
val,
next: None,
prev: None,
}))
}
}
/* 基於雙向鏈結串列實現的雙向佇列 */
#[allow(dead_code)]
pub struct LinkedListDeque<T> {
front: Option<Rc<RefCell<ListNode<T>>>>, // 頭節點 front
rear: Option<Rc<RefCell<ListNode<T>>>>, // 尾節點 rear
que_size: usize, // 雙向佇列的長度
}
impl<T: Copy> LinkedListDeque<T> {
pub fn new() -> Self {
Self {
front: None,
rear: None,
que_size: 0,
}
}
/* 獲取雙向佇列的長度 */
pub fn size(&self) -> usize {
return self.que_size;
}
/* 判斷雙向佇列是否為空 */
pub fn is_empty(&self) -> bool {
return self.size() == 0;
}
/* 入列操作 */
pub fn push(&mut self, num: T, is_front: bool) {
let node = ListNode::new(num);
// 佇列首入列操作
if is_front {
match self.front.take() {
// 若鏈結串列為空，則令 front 和 rear 都指向 node
None => {
self.rear = Some(node.clone());
self.front = Some(node);
}
// 將 node 新增至鏈結串列頭部
Some(old_front) => {
old_front.borrow_mut().prev = Some(node.clone());
node.borrow_mut().next = Some(old_front);
self.front = Some(node); // 更新頭節點
}
}
}
// 佇列尾入列操作
else {
match self.rear.take() {
// 若鏈結串列為空，則令 front 和 rear 都指向 node
None => {
self.front = Some(node.clone());
self.rear = Some(node);
}
// 將 node 新增至鏈結串列尾部
Some(old_rear) => {
old_rear.borrow_mut().next = Some(node.clone());
node.borrow_mut().prev = Some(old_rear);
self.rear = Some(node); // 更新尾節點
}
}
}
self.que_size += 1; // 更新佇列長度
}
/* 佇列首入列 */
pub fn push_first(&mut self, num: T) {
self.push(num, true);
}
/* 佇列尾入列 */
pub fn push_last(&mut self, num: T) {
self.push(num, false);
}
/* 出列操作 */
pub fn pop(&mut self, is_front: bool) -> Option<T> {
// 若佇列為空，直接返回 None
if self.is_empty() {
return None;
};
// 佇列首出列操作
if is_front {
self.front.take().map(|old_front| {
match old_front.borrow_mut().next.take() {
Some(new_front) => {
new_front.borrow_mut().prev.take();
self.front = Some(new_front); // 更新頭節點
}
None => {
self.rear.take();
}
}
self.que_size -= 1; // 更新佇列長度
Rc::try_unwrap(old_front).ok().unwrap().into_inner().val
})
}
// 佇列尾出列操作
else {
self.rear.take().map(|old_rear| {
match old_rear.borrow_mut().prev.take() {
Some(new_rear) => {
new_rear.borrow_mut().next.take();
self.rear = Some(new_rear); // 更新尾節點
}
None => {
self.front.take();
}
}
self.que_size -= 1; // 更新佇列長度
Rc::try_unwrap(old_rear).ok().unwrap().into_inner().val
})
}
}
/* 佇列首出列 */
pub fn pop_first(&mut self) -> Option<T> {
return self.pop(true);
}
/* 佇列尾出列 */
pub fn pop_last(&mut self) -> Option<T> {
return self.pop(false);
}
/* 訪問佇列首元素 */
pub fn peek_first(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {
self.front.as_ref()
}
/* 訪問佇列尾元素 */
pub fn peek_last(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {
self.rear.as_ref()
}
/* 返回陣列用於列印 */
pub fn to_array(&self, head: Option<&Rc<RefCell<ListNode<T>>>>) -> Vec<T> {
if let Some(node) = head {
let mut nums = self.to_array(node.borrow().next.as_ref());
nums.insert(0, node.borrow().val);
return nums;
}
return Vec::new();
}
}
/* Driver Code */
fn main() {
/* 初始化雙向佇列 */
let mut deque = LinkedListDeque::new();
deque.push_last(3);
deque.push_last(2);
deque.push_last(5);
print!("雙向佇列 deque = ");
print_util::print_array(&deque.to_array(deque.peek_first()));
/* 訪問元素 */
let peek_first = deque.peek_first().unwrap().borrow().val;
print!("\n佇列首元素 peek_first = {}", peek_first);
let peek_last = deque.peek_last().unwrap().borrow().val;
print!("\n佇列尾元素 peek_last = {}", peek_last);
/* 元素入列 */
deque.push_last(4);
print!("\n元素 4 佇列尾入列後 deque = ");
print_util::print_array(&deque.to_array(deque.peek_first()));
deque.push_first(1);
print!("\n元素 1 佇列首入列後 deque = ");
print_util::print_array(&deque.to_array(deque.peek_first()));
/* 元素出列 */
let pop_last = deque.pop_last().unwrap();
print!("\n佇列尾出列元素 = {}，佇列尾出列後 deque = ", pop_last);
print_util::print_array(&deque.to_array(deque.peek_first()));
let pop_first = deque.pop_first().unwrap();
print!("\n佇列首出列元素 = {}，佇列首出列後 deque = ", pop_first);
print_util::print_array(&deque.to_array(deque.peek_first()));
/* 獲取雙向佇列的長度 */
let size = deque.size();
print!("\n雙向佇列長度 size = {}", size);
/* 判斷雙向佇列是否為空 */
let is_empty = deque.is_empty();
print!("\n雙向佇列是否為空 = {}", is_empty);
}
zh-hant/codes/rust/chapter_stack_and_queue/linkedlist_queue.rs
+121
View File
@@ -0,0 +1,121 @@
/*
* File: linkedlist_queue.rs
* Created Time: 2023-03-11
* Author: codingonion (coderonion@gmail.com)
*/
include!("../include/include.rs");
use list_node::ListNode;
use std::cell::RefCell;
use std::rc::Rc;
/* 基於鏈結串列實現的佇列 */
#[allow(dead_code)]
pub struct LinkedListQueue<T> {
front: Option<Rc<RefCell<ListNode<T>>>>, // 頭節點 front
rear: Option<Rc<RefCell<ListNode<T>>>>, // 尾節點 rear
que_size: usize, // 佇列的長度
}
impl<T: Copy> LinkedListQueue<T> {
pub fn new() -> Self {
Self {
front: None,
rear: None,
que_size: 0,
}
}
/* 獲取佇列的長度 */
pub fn size(&self) -> usize {
return self.que_size;
}
/* 判斷佇列是否為空 */
pub fn is_empty(&self) -> bool {
return self.size() == 0;
}
/* 入列 */
pub fn push(&mut self, num: T) {
// 在尾節點後新增 num
let new_rear = ListNode::new(num);
match self.rear.take() {
// 如果佇列不為空，則將該節點新增到尾節點後
Some(old_rear) => {
old_rear.borrow_mut().next = Some(new_rear.clone());
self.rear = Some(new_rear);
}
// 如果佇列為空，則令頭、尾節點都指向該節點
None => {
self.front = Some(new_rear.clone());
self.rear = Some(new_rear);
}
}
self.que_size += 1;
}
/* 出列 */
pub fn pop(&mut self) -> Option<T> {
self.front.take().map(|old_front| {
match old_front.borrow_mut().next.take() {
Some(new_front) => {
self.front = Some(new_front);
}
None => {
self.rear.take();
}
}
self.que_size -= 1;
Rc::try_unwrap(old_front).ok().unwrap().into_inner().val
})
}
/* 訪問佇列首元素 */
pub fn peek(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {
self.front.as_ref()
}
/* 將鏈結串列轉化為 Array 並返回 */
pub fn to_array(&self, head: Option<&Rc<RefCell<ListNode<T>>>>) -> Vec<T> {
if let Some(node) = head {
let mut nums = self.to_array(node.borrow().next.as_ref());
nums.insert(0, node.borrow().val);
return nums;
}
return Vec::new();
}
}
/* Driver Code */
fn main() {
/* 初始化佇列 */
let mut queue = LinkedListQueue::new();
/* 元素入列 */
queue.push(1);
queue.push(3);
queue.push(2);
queue.push(5);
queue.push(4);
print!("佇列 queue = ");
print_util::print_array(&queue.to_array(queue.peek()));
/* 訪問佇列首元素 */
let peek = queue.peek().unwrap().borrow().val;
print!("\n佇列首元素 peek = {}", peek);
/* 元素出列 */
let pop = queue.pop().unwrap();
print!("\n出列元素 pop = {}，出列後 queue = ", pop);
print_util::print_array(&queue.to_array(queue.peek()));
/* 獲取佇列的長度 */
let size = queue.size();
print!("\n佇列長度 size = {}", size);
/* 判斷佇列是否為空 */
let is_empty = queue.is_empty();
print!("\n佇列是否為空 = {}", is_empty);
}
zh-hant/codes/rust/chapter_stack_and_queue/linkedlist_stack.rs
+108
View File
@@ -0,0 +1,108 @@
/*
* File: linkedlist_stack.rs
* Created Time: 2023-03-11
* Author: codingonion (coderonion@gmail.com)
*/
include!("../include/include.rs");
use list_node::ListNode;
use std::cell::RefCell;
use std::rc::Rc;
/* 基於鏈結串列實現的堆疊 */
#[allow(dead_code)]
pub struct LinkedListStack<T> {
stack_peek: Option<Rc<RefCell<ListNode<T>>>>, // 將頭節點作為堆疊頂
stk_size: usize, // 堆疊的長度
}
impl<T: Copy> LinkedListStack<T> {
pub fn new() -> Self {
Self {
stack_peek: None,
stk_size: 0,
}
}
/* 獲取堆疊的長度 */
pub fn size(&self) -> usize {
return self.stk_size;
}
/* 判斷堆疊是否為空 */
pub fn is_empty(&self) -> bool {
return self.size() == 0;
}
/* 入堆疊 */
pub fn push(&mut self, num: T) {
let node = ListNode::new(num);
node.borrow_mut().next = self.stack_peek.take();
self.stack_peek = Some(node);
self.stk_size += 1;
}
/* 出堆疊 */
pub fn pop(&mut self) -> Option<T> {
self.stack_peek.take().map(|old_head| {
match old_head.borrow_mut().next.take() {
Some(new_head) => {
self.stack_peek = Some(new_head);
}
None => {
self.stack_peek = None;
}
}
self.stk_size -= 1;
Rc::try_unwrap(old_head).ok().unwrap().into_inner().val
})
}
/* 訪問堆疊頂元素 */
pub fn peek(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {
self.stack_peek.as_ref()
}
/* 將 List 轉化為 Array 並返回 */
pub fn to_array(&self, head: Option<&Rc<RefCell<ListNode<T>>>>) -> Vec<T> {
if let Some(node) = head {
let mut nums = self.to_array(node.borrow().next.as_ref());
nums.push(node.borrow().val);
return nums;
}
return Vec::new();
}
}
/* Driver Code */
fn main() {
/* 初始化堆疊 */
let mut stack = LinkedListStack::new();
/* 元素入堆疊 */
stack.push(1);
stack.push(3);
stack.push(2);
stack.push(5);
stack.push(4);
print!("堆疊 stack = ");
print_util::print_array(&stack.to_array(stack.peek()));
/* 訪問堆疊頂元素 */
let peek = stack.peek().unwrap().borrow().val;
print!("\n堆疊頂元素 peek = {}", peek);
/* 元素出堆疊 */
let pop = stack.pop().unwrap();
print!("\n出堆疊元素 pop = {}，出堆疊後 stack = ", pop);
print_util::print_array(&stack.to_array(stack.peek()));
/* 獲取堆疊的長度 */
let size = stack.size();
print!("\n堆疊的長度 size = {}", size);
/* 判斷是否為空 */
let is_empty = stack.is_empty();
print!("\n堆疊是否為空 = {}", is_empty);
}
zh-hant/codes/rust/chapter_stack_and_queue/queue.rs
+41
View File
@@ -0,0 +1,41 @@
/*
* File: queue.rs
* Created Time: 2023-02-05
* Author: codingonion (coderonion@gmail.com), xBLACKICEx (xBLACKICEx@outlook.com)
*/
include!("../include/include.rs");
use std::collections::VecDeque;
/* Driver Code */
pub fn main() {
// 初始化佇列
let mut queue: VecDeque<i32> = VecDeque::new();
// 元素入列
queue.push_back(1);
queue.push_back(3);
queue.push_back(2);
queue.push_back(5);
queue.push_back(4);
print!("佇列 queue = ");
print_util::print_queue(&queue);
// 訪問佇列首元素
let peek = queue.front().unwrap();
println!("\n佇列首元素 peek = {peek}");
// 元素出列
let pop = queue.pop_front().unwrap();
print!("出列元素 pop = {pop}，出列後 queue = ");
print_util::print_queue(&queue);
// 獲取佇列的長度
let size = queue.len();
print!("\n佇列長度 size = {size}");
// 判斷佇列是否為空
let is_empty = queue.is_empty();
print!("\n佇列是否為空 = {is_empty}");
}
zh-hant/codes/rust/chapter_stack_and_queue/stack.rs
+40
View File
@@ -0,0 +1,40 @@
/*
* File: stack.rs
* Created Time: 2023-02-05
* Author: codingonion (coderonion@gmail.com)
*/
include!("../include/include.rs");
/* Driver Code */
pub fn main() {
// 初始化堆疊
// 在 rust 中，推薦將 Vec 當作堆疊來使用
let mut stack: Vec<i32> = Vec::new();
// 元素入堆疊
stack.push(1);
stack.push(3);
stack.push(2);
stack.push(5);
stack.push(4);
print!("堆疊 stack = ");
print_util::print_array(&stack);
// 訪問堆疊頂元素
let peek = stack.last().unwrap();
print!("\n堆疊頂元素 peek = {peek}");
// 元素出堆疊
let pop = stack.pop().unwrap();
print!("\n出堆疊元素 pop = {pop}，出堆疊後 stack = ");
print_util::print_array(&stack);
// 獲取堆疊的長度
let size = stack.len();
print!("\n堆疊的長度 size = {size}");
// 判斷堆疊是否為空
let is_empty = stack.is_empty();
print!("\n堆疊是否為空 = {is_empty}");
}