Re-translate the Japanese version (#1871)

* Retranslate Japanese docs with GPT-5.4

* Retranslate Japanese code with GPT-5.4

ja/codes/zig/chapter_stack_and_queue/array_queue.zig

@@ -0,0 +1,140 @@
+// File: array_queue.zig
+// Created Time: 2023-01-15
+// Author: codingonion (coderonion@gmail.com)
+
+const std = @import("std");
+const inc = @import("include");
+
+// 循環配列ベースのキュー
+pub fn ArrayQueue(comptime T: type) type {
+    return struct {
+        const Self = @This();
+
+        nums: []T = undefined,                          // キュー要素を格納する配列
+        cap: usize = 0,                                 // キューの容量
+        front: usize = 0,                               // 先頭ポインタ。先頭要素を指す
+        queSize: usize = 0,                             // 末尾ポインタ。キューの末尾 + 1 を指す
+        mem_arena: ?std.heap.ArenaAllocator = null,
+        mem_allocator: std.mem.Allocator = undefined,   // メモリアロケータ
+
+        // コンストラクタ（メモリを確保して配列を初期化）
+        pub fn init(self: *Self, allocator: std.mem.Allocator, cap: usize) !void {
+            if (self.mem_arena == null) {
+                self.mem_arena = std.heap.ArenaAllocator.init(allocator);
+                self.mem_allocator = self.mem_arena.?.allocator();
+            }
+            self.cap = cap;
+            self.nums = try self.mem_allocator.alloc(T, self.cap);
+            @memset(self.nums, @as(T, 0));
+        }
+        
+        // デストラクタ（メモリを解放する）
+        pub fn deinit(self: *Self) void {
+            if (self.mem_arena == null) return;
+            self.mem_arena.?.deinit();
+        }
+
+        // キューの容量を取得
+        pub fn capacity(self: *Self) usize {
+            return self.cap;
+        }
+
+        // キューの長さを取得
+        pub fn size(self: *Self) usize {
+            return self.queSize;
+        }
+
+        // キューが空かどうかを判定
+        pub fn isEmpty(self: *Self) bool {
+            return self.queSize == 0;
+        }
+
+        // エンキュー
+        pub fn push(self: *Self, num: T) !void {
+            if (self.size() == self.capacity()) {
+                std.debug.print("キューがいっぱいです\n", .{});
+                return;
+            }
+            // 末尾ポインタを計算し、末尾インデックス + 1 を指す
+            // 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする
+            var rear = (self.front + self.queSize) % self.capacity();
+            // 末尾ノードの後ろに num を追加
+            self.nums[rear] = num;
+            self.queSize += 1;
+        } 
+
+        // デキュー
+        pub fn pop(self: *Self) T {
+            var num = self.peek();
+            // 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す
+            self.front = (self.front + 1) % self.capacity();
+            self.queSize -= 1;
+            return num;
+        } 
+
+        // キュー先頭の要素にアクセス
+        pub fn peek(self: *Self) T {
+            if (self.isEmpty()) @panic("キューが空です");
+            return self.nums[self.front];
+        } 
+
+        // 配列を返す
+        pub fn toArray(self: *Self) ![]T {
+            // 有効長の範囲内のリスト要素のみを変換
+            var res = try self.mem_allocator.alloc(T, self.size());
+            @memset(res, @as(T, 0));
+            var i: usize = 0;
+            var j: usize = self.front;
+            while (i < self.size()) : ({ i += 1; j += 1; }) {
+                res[i] = self.nums[j % self.capacity()];
+            }
+            return res;
+        }
+    };
+}
+
+// Driver Code
+pub fn main() !void {
+    // キューを初期化
+    var capacity: usize = 10;
+    var queue = ArrayQueue(i32){};
+    try queue.init(std.heap.page_allocator, capacity);
+    defer queue.deinit();
+
+    // 要素をエンキュー
+    try queue.push(1);
+    try queue.push(3);
+    try queue.push(2);
+    try queue.push(5);
+    try queue.push(4);
+    std.debug.print("キュー queue = ", .{});
+    inc.PrintUtil.printArray(i32, try queue.toArray());
+
+    // キュー先頭の要素にアクセス
+    var peek = queue.peek();
+    std.debug.print("\n先頭要素 peek = {}", .{peek});
+
+    // 要素をデキュー
+    var pop = queue.pop();
+    std.debug.print("\nデキューした要素 pop = {}、デキュー後 queue = ", .{pop});
+    inc.PrintUtil.printArray(i32, try queue.toArray());
+
+    // キューの長さを取得
+    var size = queue.size();
+    std.debug.print("\nキューの長さ size = {}", .{size});
+
+    // キューが空かどうかを判定
+    var is_empty = queue.isEmpty();
+    std.debug.print("\nキューが空かどうか = {}", .{is_empty});
+
+    // 循環配列をテストする
+    var i: i32 = 0;
+    while (i < 10) : (i += 1) {
+        try queue.push(i);
+        _ = queue.pop();
+        std.debug.print("\n第 {} 回のエンキュー + デキュー後 queue = ", .{i});
+        inc.PrintUtil.printArray(i32, try queue.toArray());
+    }
+
+    _ = try std.io.getStdIn().reader().readByte();
+}

ja/codes/zig/chapter_stack_and_queue/array_stack.zig

@@ -0,0 +1,97 @@
+// File: array_stack.zig
+// Created Time: 2023-01-08
+// Author: codingonion (coderonion@gmail.com)
+
+const std = @import("std");
+const inc = @import("include");
+
+// 配列ベースのスタック
+pub fn ArrayStack(comptime T: type) type {
+    return struct {
+        const Self = @This();
+
+        stack: ?std.ArrayList(T) = null,     
+
+        // コンストラクタ（メモリを確保してスタックを初期化）
+        pub fn init(self: *Self, allocator: std.mem.Allocator) void {
+            if (self.stack == null) {
+                self.stack = std.ArrayList(T).init(allocator);
+            }
+        }
+
+        // デストラクタ（メモリを解放）
+        pub fn deinit(self: *Self) void {
+            if (self.stack == null) return;
+            self.stack.?.deinit();
+        }
+
+        // スタックの長さを取得
+        pub fn size(self: *Self) usize {
+            return self.stack.?.items.len;
+        }
+
+        // スタックが空かどうかを判定
+        pub fn isEmpty(self: *Self) bool {
+            return self.size() == 0;
+        }
+
+        // スタックトップの要素にアクセス
+        pub fn peek(self: *Self) T {
+            if (self.isEmpty()) @panic("スタックが空です");
+            return self.stack.?.items[self.size() - 1];
+        }  
+
+        // プッシュ
+        pub fn push(self: *Self, num: T) !void {
+            try self.stack.?.append(num);
+        } 
+
+        // ポップ
+        pub fn pop(self: *Self) T {
+            var num = self.stack.?.pop();
+            return num;
+        } 
+
+        // ArrayList を返す
+        pub fn toList(self: *Self) std.ArrayList(T) {
+            return self.stack.?;
+        }
+    };
+}
+
+// Driver Code
+pub fn main() !void {
+    // スタックを初期化
+    var stack = ArrayStack(i32){};
+    stack.init(std.heap.page_allocator);
+    // メモリの遅延解放
+    defer stack.deinit();
+
+    // 要素をプッシュ
+    try stack.push(1);
+    try stack.push(3);
+    try stack.push(2);
+    try stack.push(5);
+    try stack.push(4);
+    std.debug.print("スタック stack = ", .{});
+    inc.PrintUtil.printList(i32, stack.toList());
+
+    // スタックトップの要素にアクセス
+    var peek = stack.peek();
+    std.debug.print("\nスタックトップ要素 peek = {}", .{peek});
+
+    // 要素をポップ
+    var top = stack.pop();
+    std.debug.print("\nポップした要素 pop = {}、ポップ後 stack = ", .{top});
+    inc.PrintUtil.printList(i32, stack.toList());
+
+    // スタックの長さを取得
+    var size = stack.size();
+    std.debug.print("\nスタックの長さ size = {}", .{size});
+
+    // スタックが空かどうかを判定
+    var is_empty = stack.isEmpty();
+    std.debug.print("\nスタックが空かどうか = {}", .{is_empty});
+
+    _ = try std.io.getStdIn().reader().readByte();
+}

ja/codes/zig/chapter_stack_and_queue/deque.zig

@@ -0,0 +1,51 @@
+// File: deque.zig
+// Created Time: 2023-01-15
+// Author: codingonion (coderonion@gmail.com)
+
+const std = @import("std");
+const inc = @import("include");
+
+// Driver Code
+pub fn main() !void {
+    // 両端キューを初期化
+    const L = std.TailQueue(i32);
+    var deque = L{};  
+
+    // 要素をエンキュー
+    var node1 = L.Node{ .data = 2 };
+    var node2 = L.Node{ .data = 5 };
+    var node3 = L.Node{ .data = 4 };
+    var node4 = L.Node{ .data = 3 };
+    var node5 = L.Node{ .data = 1 };
+    deque.append(&node1);   // 末尾に追加する
+    deque.append(&node2);
+    deque.append(&node3);
+    deque.prepend(&node4);  // 先頭に追加する
+    deque.prepend(&node5);
+    std.debug.print("両端キュー deque = ", .{});
+    inc.PrintUtil.printQueue(i32, deque);
+
+    // 要素にアクセス
+    var peek_first = deque.first.?.data; // 先頭要素
+    std.debug.print("\n先頭要素 peek_first = {}", .{peek_first});
+    var peek_last = deque.last.?.data;   // 末尾要素
+    std.debug.print("\n末尾要素 peek_last = {}", .{peek_last});
+
+    // 要素をデキュー
+    var pop_first = deque.popFirst().?.data;    // 先頭要素を取り出す
+    std.debug.print("\n先頭からデキューした要素 pop_first = {}、先頭からデキュー後 deque = ", .{pop_first});
+    inc.PrintUtil.printQueue(i32, deque);
+    var pop_last = deque.pop().?.data;          // 末尾要素を取り出す
+    std.debug.print("\n末尾からデキューした要素 pop_last = {}、末尾からデキュー後 deque = ", .{pop_last});
+    inc.PrintUtil.printQueue(i32, deque);
+
+    // 両端キューの長さを取得
+    var size = deque.len;
+    std.debug.print("\n両端キューの長さ size = {}", .{size});
+
+    // 両端キューが空かどうかを判定
+    var is_empty = if (deque.len == 0) true else false;
+    std.debug.print("\n両端キューが空かどうか = {}", .{is_empty});
+
+    _ = try std.io.getStdIn().reader().readByte();
+}

ja/codes/zig/chapter_stack_and_queue/linkedlist_deque.zig

@@ -0,0 +1,207 @@
+// File: linkedlist_deque.zig
+// Created Time: 2023-01-15
+// Author: codingonion (coderonion@gmail.com)
+
+const std = @import("std");
+const inc = @import("include");
+
+// 双方向連結リストノード
+pub fn ListNode(comptime T: type) type {
+    return struct {
+        const Self = @This();
+        
+        val: T = undefined,     // ノード値
+        next: ?*Self = null,    // 後継ノードへのポインタ
+        prev: ?*Self = null,    // 前駆ノードへのポインタ
+
+        // Initialize a list node with specific value
+        pub fn init(self: *Self, x: i32) void {
+            self.val = x;
+            self.next = null;
+            self.prev = null;
+        }
+    };
+}
+
+// 双方向連結リストベースの両端キュー
+pub fn LinkedListDeque(comptime T: type) type {
+    return struct {
+        const Self = @This();
+
+        front: ?*ListNode(T) = null,                    // 先頭ノード front
+        rear: ?*ListNode(T) = null,                     // 末尾ノード rear
+        que_size: usize = 0,                             // 両端キューの長さ
+        mem_arena: ?std.heap.ArenaAllocator = null,
+        mem_allocator: std.mem.Allocator = undefined,   // メモリアロケータ
+
+        // コンストラクタ（メモリ確保 + キューを初期化）
+        pub fn init(self: *Self, allocator: std.mem.Allocator) !void {
+            if (self.mem_arena == null) {
+                self.mem_arena = std.heap.ArenaAllocator.init(allocator);
+                self.mem_allocator = self.mem_arena.?.allocator();
+            }
+            self.front = null;
+            self.rear = null;
+            self.que_size = 0;
+        }
+
+        // デストラクタ（メモリを解放する）
+        pub fn deinit(self: *Self) void {
+            if (self.mem_arena == null) return;
+            self.mem_arena.?.deinit();
+        }
+
+        // 両端キューの長さを取得
+        pub fn size(self: *Self) usize {
+            return self.que_size;
+        }
+
+        // 両端キューが空かどうかを判定
+        pub fn isEmpty(self: *Self) bool {
+            return self.size() == 0;
+        }
+
+        // エンキュー操作
+        pub fn push(self: *Self, num: T, is_front: bool) !void {
+            var node = try self.mem_allocator.create(ListNode(T));
+            node.init(num);
+            // 連結リストが空なら、front と rear の両方を node に向ける
+            if (self.isEmpty()) {
+                self.front = node;
+                self.rear = node;
+            // 先頭へのエンキュー操作
+            } else if (is_front) {
+                // node を連結リストの先頭に追加
+                self.front.?.prev = node;
+                node.next = self.front;
+                self.front = node;  // 先頭ノードを更新する
+            // 末尾へのエンキュー操作
+            } else {
+                // node を連結リストの末尾に追加
+                self.rear.?.next = node;
+                node.prev = self.rear;
+                self.rear = node;   // 末尾ノードを更新する
+            }
+            self.que_size += 1;      // キューの長さを更新
+        } 
+
+        // キュー先頭にエンキュー
+        pub fn pushFirst(self: *Self, num: T) !void {
+            try self.push(num, true);
+        } 
+
+        // キュー末尾にエンキュー
+        pub fn pushLast(self: *Self, num: T) !void {
+            try self.push(num, false);
+        } 
+        
+        // デキュー操作
+        pub fn pop(self: *Self, is_front: bool) T {
+            if (self.isEmpty()) @panic("両端キューが空です");
+            var val: T = undefined;
+            // キュー先頭からの取り出し
+            if (is_front) {
+                val = self.front.?.val;     // 先頭ノードの値を一時保存
+                // 先頭ノードを削除
+                var fNext = self.front.?.next;
+                if (fNext != null) {
+                    fNext.?.prev = null;
+                    self.front.?.next = null;
+                }
+                self.front = fNext;         // 先頭ノードを更新する
+            // キュー末尾からの取り出し
+            } else {
+                val = self.rear.?.val;      // 末尾ノードの値を一時保存
+                // 末尾ノードを削除
+                var rPrev = self.rear.?.prev;
+                if (rPrev != null) {
+                    rPrev.?.next = null;
+                    self.rear.?.prev = null;
+                }
+                self.rear = rPrev;          // 末尾ノードを更新する
+            }
+            self.que_size -= 1;              // キューの長さを更新
+            return val;
+        } 
+
+        // キュー先頭からデキュー
+        pub fn popFirst(self: *Self) T {
+            return self.pop(true);
+        } 
+
+        // キュー末尾からデキュー
+        pub fn popLast(self: *Self) T {
+            return self.pop(false);
+        } 
+
+        // キュー先頭の要素にアクセス
+        pub fn peekFirst(self: *Self) T {
+            if (self.isEmpty()) @panic("両端キューが空です");
+            return self.front.?.val;
+        }  
+
+        // キュー末尾の要素にアクセス
+        pub fn peekLast(self: *Self) T {
+            if (self.isEmpty()) @panic("両端キューが空です");
+            return self.rear.?.val;
+        }
+
+        // 出力用の配列を返す
+        pub fn toArray(self: *Self) ![]T {
+            var node = self.front;
+            var res = try self.mem_allocator.alloc(T, self.size());
+            @memset(res, @as(T, 0));
+            var i: usize = 0;
+            while (i < res.len) : (i += 1) {
+                res[i] = node.?.val;
+                node = node.?.next;
+            }
+            return res;
+        }
+    };
+}
+
+// Driver Code
+pub fn main() !void {
+    // 両端キューを初期化
+    var deque = LinkedListDeque(i32){};
+    try deque.init(std.heap.page_allocator);
+    defer deque.deinit();
+    try deque.pushLast(3);
+    try deque.pushLast(2);
+    try deque.pushLast(5);
+    std.debug.print("両端キュー deque = ", .{});
+    inc.PrintUtil.printArray(i32, try deque.toArray());
+
+    // 要素にアクセス
+    var peek_first = deque.peekFirst();
+    std.debug.print("\n先頭要素 peek_first = {}", .{peek_first});
+    var peek_last = deque.peekLast();
+    std.debug.print("\n末尾要素 peek_last = {}", .{peek_last});
+
+    // 要素をエンキュー
+    try deque.pushLast(4);
+    std.debug.print("\n要素 4 を末尾からエンキューした後 deque = ", .{});
+    inc.PrintUtil.printArray(i32, try deque.toArray());
+    try deque.pushFirst(1);
+    std.debug.print("\n要素 1 を先頭からエンキューした後 deque = ", .{});
+    inc.PrintUtil.printArray(i32, try deque.toArray());
+
+    // 要素をデキュー
+    var pop_last = deque.popLast();
+    std.debug.print("\n末尾から取り出した要素 = {}，末尾から取り出した後 deque = ", .{pop_last});
+    inc.PrintUtil.printArray(i32, try deque.toArray());
+    var pop_first = deque.popFirst();
+    std.debug.print("\n先頭から取り出した要素 = {}，先頭から取り出した後 deque = ", .{pop_first});
+    inc.PrintUtil.printArray(i32, try deque.toArray());
+
+    // 両端キューの長さを取得
+    var size = deque.size();
+    std.debug.print("\n両端キューの長さ size = {}", .{size});
+
+    // 両端キューが空かどうかを判定
+    var is_empty = deque.isEmpty();
+    std.debug.print("\n両端キューが空かどうか = {}", .{is_empty});
+
+    _ = try std.io.getStdIn().reader().readByte();
+}

ja/codes/zig/chapter_stack_and_queue/linkedlist_queue.zig

@@ -0,0 +1,127 @@
+// File: linkedlist_queue.zig
+// Created Time: 2023-01-15
+// Author: codingonion (coderonion@gmail.com)
+
+const std = @import("std");
+const inc = @import("include");
+
+// 連結リストベースのキュー
+pub fn LinkedListQueue(comptime T: type) type {
+    return struct {
+        const Self = @This();
+
+        front: ?*inc.ListNode(T) = null,                // 先頭ノード front
+        rear: ?*inc.ListNode(T) = null,                 // 末尾ノード rear
+        que_size: usize = 0,                            // キューの長さ
+        mem_arena: ?std.heap.ArenaAllocator = null,
+        mem_allocator: std.mem.Allocator = undefined,   // メモリアロケータ
+
+        // コンストラクタ（メモリ確保 + キューを初期化）
+        pub fn init(self: *Self, allocator: std.mem.Allocator) !void {
+            if (self.mem_arena == null) {
+                self.mem_arena = std.heap.ArenaAllocator.init(allocator);
+                self.mem_allocator = self.mem_arena.?.allocator();
+            }
+            self.front = null;
+            self.rear = null;
+            self.que_size = 0;
+        }
+
+        // デストラクタ（メモリを解放する）
+        pub fn deinit(self: *Self) void {
+            if (self.mem_arena == null) return;
+            self.mem_arena.?.deinit();
+        }
+
+        // キューの長さを取得
+        pub fn size(self: *Self) usize {
+            return self.que_size;
+        }
+
+        // キューが空かどうかを判定
+        pub fn isEmpty(self: *Self) bool {
+            return self.size() == 0;
+        }
+
+        // キュー先頭の要素にアクセス
+        pub fn peek(self: *Self) T {
+            if (self.size() == 0) @panic("キューが空です");
+            return self.front.?.val;
+        }  
+
+        // エンキュー
+        pub fn push(self: *Self, num: T) !void {
+            // 末尾ノードの後ろに num を追加
+            var node = try self.mem_allocator.create(inc.ListNode(T));
+            node.init(num);
+            // キューが空なら、先頭・末尾ノードをともにそのノードに設定
+            if (self.front == null) {
+                self.front = node;
+                self.rear = node;
+            // キューが空でなければ、そのノードを末尾ノードの後ろに追加
+            } else {
+                self.rear.?.next = node;
+                self.rear = node;
+            }
+            self.que_size += 1;
+        } 
+
+        // デキュー
+        pub fn pop(self: *Self) T {
+            var num = self.peek();
+            // 先頭ノードを削除
+            self.front = self.front.?.next;
+            self.que_size -= 1;
+            return num;
+        } 
+
+        // 連結リストを配列に変換
+        pub fn toArray(self: *Self) ![]T {
+            var node = self.front;
+            var res = try self.mem_allocator.alloc(T, self.size());
+            @memset(res, @as(T, 0));
+            var i: usize = 0;
+            while (i < res.len) : (i += 1) {
+                res[i] = node.?.val;
+                node = node.?.next;
+            }
+            return res;
+        }
+    };
+}
+
+// Driver Code
+pub fn main() !void {
+    // キューを初期化
+    var queue = LinkedListQueue(i32){};
+    try queue.init(std.heap.page_allocator);
+    defer queue.deinit();
+
+    // 要素をエンキュー
+    try queue.push(1);
+    try queue.push(3);
+    try queue.push(2);
+    try queue.push(5);
+    try queue.push(4);
+    std.debug.print("キュー queue = ", .{});
+    inc.PrintUtil.printArray(i32, try queue.toArray());
+
+    // キュー先頭の要素にアクセス
+    var peek = queue.peek();
+    std.debug.print("\n先頭要素 peek = {}", .{peek});
+
+    // 要素をデキュー
+    var pop = queue.pop();
+    std.debug.print("\nデキューした要素 pop = {}、デキュー後 queue = ", .{pop});
+    inc.PrintUtil.printArray(i32, try queue.toArray());
+
+    // キューの長さを取得
+    var size = queue.size();
+    std.debug.print("\nキューの長さ size = {}", .{size});
+
+    // キューが空かどうかを判定
+    var is_empty = queue.isEmpty();
+    std.debug.print("\nキューが空かどうか = {}", .{is_empty});
+
+    _ = try std.io.getStdIn().reader().readByte();
+}

ja/codes/zig/chapter_stack_and_queue/linkedlist_stack.zig

@@ -0,0 +1,118 @@
+// File: linkedlist_stack.zig
+// Created Time: 2023-01-08
+// Author: codingonion (coderonion@gmail.com)
+
+const std = @import("std");
+const inc = @import("include");
+
+// 連結リストベースのスタック
+pub fn LinkedListStack(comptime T: type) type {
+    return struct {
+        const Self = @This();
+
+        stack_top: ?*inc.ListNode(T) = null,             // 先頭ノードをスタックトップとする
+        stk_size: usize = 0,                             // スタックの長さ
+        mem_arena: ?std.heap.ArenaAllocator = null,
+        mem_allocator: std.mem.Allocator = undefined,    // メモリアロケータ
+
+        // コンストラクタ（メモリを確保してスタックを初期化）
+        pub fn init(self: *Self, allocator: std.mem.Allocator) !void {
+            if (self.mem_arena == null) {
+                self.mem_arena = std.heap.ArenaAllocator.init(allocator);
+                self.mem_allocator = self.mem_arena.?.allocator();
+            }
+            self.stack_top = null;
+            self.stk_size = 0;
+        }
+
+        // デストラクタ（メモリを解放する）
+        pub fn deinit(self: *Self) void {
+            if (self.mem_arena == null) return;
+            self.mem_arena.?.deinit();
+        }
+
+        // スタックの長さを取得
+        pub fn size(self: *Self) usize {
+            return self.stk_size;
+        }
+
+        // スタックが空かどうかを判定
+        pub fn isEmpty(self: *Self) bool {
+            return self.size() == 0;
+        }
+
+        // スタックトップの要素にアクセス
+        pub fn peek(self: *Self) T {
+            if (self.size() == 0) @panic("スタックが空です");
+            return self.stack_top.?.val;
+        }  
+
+        // プッシュ
+        pub fn push(self: *Self, num: T) !void {
+            var node = try self.mem_allocator.create(inc.ListNode(T));
+            node.init(num);
+            node.next = self.stack_top;
+            self.stack_top = node;
+            self.stk_size += 1;
+        } 
+
+        // ポップ
+        pub fn pop(self: *Self) T {
+            var num = self.peek();
+            self.stack_top = self.stack_top.?.next;
+            self.stk_size -= 1;
+            return num;
+        } 
+
+        // スタックを配列に変換
+        pub fn toArray(self: *Self) ![]T {
+            var node = self.stack_top;
+            var res = try self.mem_allocator.alloc(T, self.size());
+            @memset(res, @as(T, 0));
+            var i: usize = 0;
+            while (i < res.len) : (i += 1) {
+                res[res.len - i - 1] = node.?.val;
+                node = node.?.next;
+            }
+            return res;
+        }
+    };
+}
+
+// Driver Code
+pub fn main() !void {
+    // スタックを初期化
+    var stack = LinkedListStack(i32){};
+    try stack.init(std.heap.page_allocator);
+    // メモリの遅延解放
+    defer stack.deinit();
+
+    // 要素をプッシュ
+    try stack.push(1);
+    try stack.push(3);
+    try stack.push(2);
+    try stack.push(5);
+    try stack.push(4);
+    std.debug.print("スタック stack = ", .{});
+    inc.PrintUtil.printArray(i32, try stack.toArray());
+
+    // スタックトップの要素にアクセス
+    var peek = stack.peek();
+    std.debug.print("\nスタック頂部の要素 top = {}", .{peek});
+
+    // 要素をポップ
+    var pop = stack.pop();
+    std.debug.print("\nポップした要素 pop = {}，ポップ後の stack = ", .{pop});
+    inc.PrintUtil.printArray(i32, try stack.toArray());
+
+    // スタックの長さを取得
+    var size = stack.size();
+    std.debug.print("\nスタックの長さ size = {}", .{size});
+
+    // スタックが空かどうかを判定
+    var is_empty = stack.isEmpty();
+    std.debug.print("\nスタックが空かどうか = {}", .{is_empty});
+
+    _ = try std.io.getStdIn().reader().readByte();
+}
+

ja/codes/zig/chapter_stack_and_queue/queue.zig

@@ -0,0 +1,46 @@
+// File: queue.zig
+// Created Time: 2023-01-15
+// Author: codingonion (coderonion@gmail.com)
+
+const std = @import("std");
+const inc = @import("include");
+
+// Driver Code
+pub fn main() !void {
+    // キューを初期化
+    const L = std.TailQueue(i32);
+    var queue = L{};  
+
+    // 要素をエンキュー
+    var node1 = L.Node{ .data = 1 };
+    var node2 = L.Node{ .data = 3 };
+    var node3 = L.Node{ .data = 2 };
+    var node4 = L.Node{ .data = 5 };
+    var node5 = L.Node{ .data = 4 };
+    queue.append(&node1);
+    queue.append(&node2);
+    queue.append(&node3);
+    queue.append(&node4);
+    queue.append(&node5);
+    std.debug.print("キュー queue = ", .{});
+    inc.PrintUtil.printQueue(i32, queue);
+
+    // キュー先頭の要素にアクセス
+    var peek = queue.first.?.data;
+    std.debug.print("\n先頭要素 peek = {}", .{peek});
+
+    // 要素をデキュー
+    var pop = queue.popFirst().?.data;
+    std.debug.print("\nデキューした要素 pop = {}、デキュー後 queue = ", .{pop});
+    inc.PrintUtil.printQueue(i32, queue);
+
+    // キューの長さを取得
+    var size = queue.len;
+    std.debug.print("\nキューの長さ size = {}", .{size});
+
+    // キューが空かどうかを判定
+    var is_empty = if (queue.len == 0) true else false;
+    std.debug.print("\nキューが空かどうか = {}", .{is_empty});
+
+    _ = try std.io.getStdIn().reader().readByte();
+}

ja/codes/zig/chapter_stack_and_queue/stack.zig

@@ -0,0 +1,43 @@
+// File: stack.zig
+// Created Time: 2023-01-08
+// Author: codingonion (coderonion@gmail.com)
+
+const std = @import("std");
+const inc = @import("include");
+
+// Driver Code
+pub fn main() !void {
+    // スタックを初期化する
+    // zig では、ArrayList をスタックとして使うことが推奨される
+    var stack = std.ArrayList(i32).init(std.heap.page_allocator);
+    // メモリの遅延解放
+    defer stack.deinit();
+
+    // 要素をプッシュ
+    try stack.append(1);
+    try stack.append(3);
+    try stack.append(2);
+    try stack.append(5);
+    try stack.append(4);
+    std.debug.print("スタック stack = ", .{});
+    inc.PrintUtil.printList(i32, stack);
+
+    // スタックトップの要素にアクセス
+    var peek = stack.items[stack.items.len - 1];
+    std.debug.print("\nスタックトップ要素 peek = {}", .{peek});
+
+    // 要素をポップ
+    var pop = stack.pop();
+    std.debug.print("\nポップした要素 pop = {}，ポップ後の stack = ", .{pop});
+    inc.PrintUtil.printList(i32, stack);
+
+    // スタックの長さを取得
+    var size = stack.items.len;
+    std.debug.print("\nスタックの長さ size = {}", .{size});
+
+    // スタックが空かどうかを判定
+    var is_empty = if (stack.items.len == 0) true else false;
+    std.debug.print("\nスタックが空かどうか = {}", .{is_empty});
+
+    _ = try std.io.getStdIn().reader().readByte();
+}