Re-translate the Japanese version (#1871)

* Retranslate Japanese docs with GPT-5.4

* Retranslate Japanese code with GPT-5.4

ja/codes/rust/chapter_stack_and_queue/array_deque.rs

@@ -0,0 +1,160 @@
+/*
+ * File: array_deque.rs
+ * Created Time: 2023-03-11
+ * Author: codingonion (coderonion@gmail.com)
+ */
+use hello_algo_rust::include::print_util;
+/* 循環配列ベースの両端キュー */
+struct ArrayDeque<T> {
+    nums: Vec<T>,    // 両端キューの要素を格納する配列
+    front: usize,    // 先頭ポインタ。先頭要素を指す
+    que_size: usize, // 両端キューの長さ
+}
+
+impl<T: Copy + Default> ArrayDeque<T> {
+    /* コンストラクタ */
+    pub fn new(capacity: usize) -> Self {
+        Self {
+            nums: vec![T::default(); 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 が配列の先頭を越えて前に出たら末尾に戻る
+        ((i + self.capacity() as i32) % self.capacity() as i32) as usize
+    }
+
+    /* キュー先頭にエンキュー */
+    pub fn push_first(&mut self, num: T) {
+        if self.que_size == self.capacity() {
+            println!("両端キューがいっぱいです");
+            return;
+        }
+        // 先頭ポインタを左に 1 つ移動する
+        // 剰余演算により、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: T) {
+        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) -> T {
+        let num = self.peek_first();
+        // 先頭ポインタを 1 つ後ろへ進める
+        self.front = self.index(self.front as i32 + 1);
+        self.que_size -= 1;
+        num
+    }
+
+    /* キュー末尾からデキュー */
+    fn pop_last(&mut self) -> T {
+        let num = self.peek_last();
+        self.que_size -= 1;
+        num
+    }
+
+    /* キュー先頭の要素にアクセス */
+    fn peek_first(&self) -> T {
+        if self.is_empty() {
+            panic!("両端キューが空です")
+        };
+        self.nums[self.front]
+    }
+
+    /* キュー末尾の要素にアクセス */
+    fn peek_last(&self) -> T {
+        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<T> {
+        // 有効長の範囲内のリスト要素のみを変換
+        let mut res = vec![T::default(); 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);
+}

ja/codes/rust/chapter_stack_and_queue/array_queue.rs

@@ -0,0 +1,125 @@
+/*
+ * File: array_queue.rs
+ * Created Time: 2023-02-06
+ * Author: WSL0809 (wslzzy@outlook.com)
+ */
+
+/* 循環配列ベースのキュー */
+struct ArrayQueue<T> {
+    nums: Vec<T>,      // キュー要素を格納する配列
+    front: i32,        // 先頭ポインタ。先頭要素を指す
+    que_size: i32,     // キューの長さ
+    que_capacity: i32, // キューの容量
+}
+
+impl<T: Copy + Default> ArrayQueue<T> {
+    /* コンストラクタ */
+    fn new(capacity: i32) -> ArrayQueue<T> {
+        ArrayQueue {
+            nums: vec![T::default(); 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: T) {
+        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) -> T {
+        let num = self.peek();
+        // 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す
+        self.front = (self.front + 1) % self.que_capacity;
+        self.que_size -= 1;
+        num
+    }
+
+    /* キュー先頭の要素にアクセス */
+    fn peek(&self) -> T {
+        if self.is_empty() {
+            panic!("index out of bounds");
+        }
+        self.nums[self.front as usize]
+    }
+
+    /* 配列を返す */
+    fn to_vector(&self) -> Vec<T> {
+        let cap = self.que_capacity;
+        let mut j = self.front;
+        let mut arr = vec![T::default(); cap 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());
+    }
+}

ja/codes/rust/chapter_stack_and_queue/array_stack.rs

@@ -0,0 +1,86 @@
+/*
+ * File: array_stack.rs
+ * Created Time: 2023-02-05
+ * Author: WSL0809 (wslzzy@outlook.com), codingonion (coderonion@gmail.com)
+ */
+
+use hello_algo_rust::include::print_util;
+
+/* 配列ベースのスタック */
+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}");
+}

ja/codes/rust/chapter_stack_and_queue/deque.rs

@@ -0,0 +1,49 @@
+/*
+ * File: deque.rs
+ * Created Time: 2023-02-05
+ * Author: codingonion (coderonion@gmail.com), xBLACKICEx (xBLACKICEx@outlook.com)
+ */
+
+use hello_algo_rust::include::print_util;
+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}");
+}

ja/codes/rust/chapter_stack_and_queue/linkedlist_deque.rs

@@ -0,0 +1,218 @@
+/*
+ * File: linkedlist_deque.rs
+ * Created Time: 2023-03-11
+ * Author: codingonion (coderonion@gmail.com)
+ */
+
+use hello_algo_rust::include::print_util;
+
+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.que_size == 0;
+    }
+
+    /* エンキュー操作 */
+    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);
+    }
+
+    /* デキュー操作 */
+    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; // キューの長さを更新
+                old_front.borrow().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; // キューの長さを更新
+                old_rear.borrow().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> {
+        let mut res: Vec<T> = Vec::new();
+        fn recur<T: Copy>(cur: Option<&Rc<RefCell<ListNode<T>>>>, res: &mut Vec<T>) {
+            if let Some(cur) = cur {
+                res.push(cur.borrow().val);
+                recur(cur.borrow().next.as_ref(), res);
+            }
+        }
+
+        recur(head, &mut res);
+        res
+    }
+}
+
+/* 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);
+}

ja/codes/rust/chapter_stack_and_queue/linkedlist_queue.rs

@@ -0,0 +1,126 @@
+/*
+ * File: linkedlist_queue.rs
+ * Created Time: 2023-03-11
+ * Author: codingonion (coderonion@gmail.com)
+ */
+
+use hello_algo_rust::include::{print_util, 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.que_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;
+            old_front.borrow().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> {
+        let mut res: Vec<T> = Vec::new();
+
+        fn recur<T: Copy>(cur: Option<&Rc<RefCell<ListNode<T>>>>, res: &mut Vec<T>) {
+            if let Some(cur) = cur {
+                res.push(cur.borrow().val);
+                recur(cur.borrow().next.as_ref(), res);
+            }
+        }
+
+        recur(head, &mut res);
+
+        res
+    }
+}
+
+/* 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);
+}

ja/codes/rust/chapter_stack_and_queue/linkedlist_stack.rs

@@ -0,0 +1,105 @@
+/*
+ * File: linkedlist_stack.rs
+ * Created Time: 2023-03-11
+ * Author: codingonion (coderonion@gmail.com)
+ */
+
+use hello_algo_rust::include::{print_util, 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| {
+            self.stack_peek = old_head.borrow_mut().next.take();
+            self.stk_size -= 1;
+
+            old_head.borrow().val
+        })
+    }
+
+    /* スタックトップの要素にアクセス */
+    pub fn peek(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {
+        self.stack_peek.as_ref()
+    }
+
+    /* List を Array に変換して返す */
+    pub fn to_array(&self) -> Vec<T> {
+        fn _to_array<T: Sized + Copy>(head: Option<&Rc<RefCell<ListNode<T>>>>) -> Vec<T> {
+            if let Some(node) = head {
+                let mut nums = _to_array(node.borrow().next.as_ref());
+                nums.push(node.borrow().val);
+                return nums;
+            }
+            return Vec::new();
+        }
+
+        _to_array(self.peek())
+    }
+}
+
+/* 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());
+
+    /* スタックトップの要素にアクセス */
+    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());
+
+    /* スタックの長さを取得 */
+    let size = stack.size();
+    print!("\nスタックの長さ size = {}", size);
+
+    /* 空かどうかを判定 */
+    let is_empty = stack.is_empty();
+    print!("\nスタックが空かどうか = {}", is_empty);
+}

ja/codes/rust/chapter_stack_and_queue/queue.rs

@@ -0,0 +1,41 @@
+/*
+ * File: queue.rs
+ * Created Time: 2023-02-05
+ * Author: codingonion (coderonion@gmail.com), xBLACKICEx (xBLACKICEx@outlook.com)
+ */
+
+use hello_algo_rust::include::print_util;
+
+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}");
+}

ja/codes/rust/chapter_stack_and_queue/stack.rs

@@ -0,0 +1,40 @@
+/*
+ * File: stack.rs
+ * Created Time: 2023-02-05
+ * Author: codingonion (coderonion@gmail.com)
+ */
+
+use hello_algo_rust::include::print_util;
+
+/* 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}");
+}