Retranslate the complete Japanese online edition from Chinese (#2008)

* Retranslate the complete Japanese online edition from Chinese

* Fit Japanese homepage labels and localize heading permalinks

* Point Japanese contribution instructions to the Japanese preview

* Replace locale conditionals with multilingual UI tables
This commit is contained in:
Yudong Jin
2026-10-30 02:12:26 +08:00
committed by GitHub
parent 455e8c1281
commit 7257641e0e
1987 changed files with 23531 additions and 23261 deletions

View File

@@ -5,19 +5,19 @@
const std = @import("std");
const inc = @import("include");
// 循環配列ベースのキュー
// 循環配列で実装したキュー
pub fn ArrayQueue(comptime T: type) type {
return struct {
const Self = @This();
nums: []T = undefined, // キュー要素を格納する配列
nums: []T = undefined, // キューの要素を格納する配列
cap: usize = 0, // キューの容量
front: usize = 0, // 先頭ポインタ。先頭要素を指す
queSize: usize = 0, // 末尾ポインタ。キューの末尾 + 1 を指す
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);
@@ -28,13 +28,13 @@ pub fn ArrayQueue(comptime T: type) type {
@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;
}
@@ -44,7 +44,7 @@ pub fn ArrayQueue(comptime T: type) type {
return self.queSize;
}
// キューが空かどうかを判定
// キューが空か判定
pub fn isEmpty(self: *Self) bool {
return self.queSize == 0;
}
@@ -52,13 +52,13 @@ pub fn ArrayQueue(comptime T: type) type {
// エンキュー
pub fn push(self: *Self, num: T) !void {
if (self.size() == self.capacity()) {
std.debug.print("キューがいっぱいです\n", .{});
std.debug.print("キューが満杯です\n", .{});
return;
}
// 末尾ポインタを計算し、末尾インデックス + 1 を指す
// 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする
// 末尾のインデックス + 1 を指す末尾ポインタを計算する
// 剰余演算で、rear が配列末尾を越えたら先頭へ戻る
var rear = (self.front + self.queSize) % self.capacity();
// 末尾ノードの後ろに num を追加
// 末尾ノードの後ろに num を追加する
self.nums[rear] = num;
self.queSize += 1;
}
@@ -66,13 +66,13 @@ pub fn ArrayQueue(comptime T: type) type {
// デキュー
pub fn pop(self: *Self) T {
var num = self.peek();
// 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す
// 先頭ポインタを後ろに 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];
@@ -80,7 +80,7 @@ pub fn ArrayQueue(comptime T: type) type {
// 配列を返す
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;
@@ -93,15 +93,15 @@ pub fn ArrayQueue(comptime T: type) type {
};
}
// 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);
@@ -110,11 +110,11 @@ pub fn main() !void {
std.debug.print("キュー queue = ", .{});
inc.PrintUtil.printArray(i32, try queue.toArray());
// キュー先頭の要素にアクセス
// キューの先頭要素にアクセス
var peek = queue.peek();
std.debug.print("\n先頭要素 peek = {}", .{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());
@@ -123,16 +123,16 @@ pub fn main() !void {
var size = queue.size();
std.debug.print("\nキューの長さ size = {}", .{size});
// キューが空かどうかを判定
// キューが空か判定
var is_empty = queue.isEmpty();
std.debug.print("\nキューが空かどうか = {}", .{is_empty});
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});
std.debug.print("\n第 {} 回のエンキューとデキューの後 queue = ", .{i});
inc.PrintUtil.printArray(i32, try queue.toArray());
}

View File

@@ -5,37 +5,37 @@
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];
@@ -59,15 +59,15 @@ pub fn ArrayStack(comptime T: type) type {
};
}
// 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);
@@ -76,22 +76,22 @@ pub fn main() !void {
std.debug.print("スタック stack = ", .{});
inc.PrintUtil.printList(i32, stack.toList());
// スタックトップの要素にアクセス
// スタックの先頭要素にアクセスする
var peek = stack.peek();
std.debug.print("\nスタックトップ要素 peek = {}", .{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});
std.debug.print("\nスタックは空か = {}", .{is_empty});
_ = try std.io.getStdIn().reader().readByte();
}

View File

@@ -5,47 +5,47 @@
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(&node1); // キューの末尾に追加する
deque.append(&node2);
deque.append(&node3);
deque.prepend(&node4); // 先頭に追加する
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 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});
// 要素をデキューする
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});
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});
std.debug.print("\n両端キューは空か = {}", .{is_empty});
_ = try std.io.getStdIn().reader().readByte();
}

View File

@@ -5,16 +5,16 @@
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, // 前駆ノードへのポインタ
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;
@@ -23,7 +23,7 @@ pub fn ListNode(comptime T: type) type {
};
}
// 双方向連結リストベースの両端キュー
// 双方向連結リストで実装した両端キュー
pub fn LinkedListDeque(comptime T: type) type {
return struct {
const Self = @This();
@@ -34,7 +34,7 @@ pub fn LinkedListDeque(comptime T: type) type {
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);
@@ -45,18 +45,18 @@ pub fn LinkedListDeque(comptime T: type) type {
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;
}
@@ -65,32 +65,32 @@ pub fn LinkedListDeque(comptime T: type) type {
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 に向ける
// 連結リストが空の場合、front と rear の両方が node を指すようにする
if (self.isEmpty()) {
self.front = node;
self.rear = node;
// 先頭へのエンキュー操作
} else if (is_front) {
// node を連結リストの先頭に追加
// node を連結リストの先頭に追加する
self.front.?.prev = node;
node.next = self.front;
self.front = node; // 先頭ノードを更新する
// 末尾へのエンキュー操作
} else {
// node を連結リストの末尾に追加
// node を連結リストの末尾に追加する
self.rear.?.next = node;
node.prev = self.rear;
self.rear = node; // 末尾ノードを更新する
}
self.que_size += 1; // キューの長さを更新
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);
}
@@ -99,56 +99,56 @@ pub fn LinkedListDeque(comptime T: type) type {
pub fn pop(self: *Self, is_front: bool) T {
if (self.isEmpty()) @panic("両端キューが空です");
var val: T = undefined;
// 要素が1つの場合、先頭と末尾は同じノードを指す
// キューの長さが 1 のとき、先頭と末尾は同じノードを指す
if (self.que_size == 1) {
val = self.front.?.val;
self.front = null;
self.rear = null;
}
// キュー先頭からの取り出し
// 先頭からのデキュー操作
else if (is_front) {
val = self.front.?.val; // 先頭ノードの値を一時保存
// 先頭ノードを削除
val = self.front.?.val; // 先頭ノードの値を一時保存する
// 先頭ノードを削除する
var fNext = self.front.?.next;
fNext.?.prev = null;
self.front.?.next = null;
self.front = fNext; // 先頭ノードを更新する
// キュー末尾からの取り出し
// 末尾からのデキュー操作
} else {
val = self.rear.?.val; // 末尾ノードの値を一時保存
// 末尾ノードを削除
val = self.rear.?.val; // 末尾ノードの値を一時保存する
// 末尾ノードを削除する
var rPrev = self.rear.?.prev;
rPrev.?.next = null;
self.rear.?.prev = null;
self.rear = rPrev; // 末尾ノードを更新する
}
self.que_size -= 1; // キューの長さを更新
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());
@@ -163,9 +163,9 @@ pub fn LinkedListDeque(comptime T: type) type {
};
}
// Driver Code
// 実行用コード
pub fn main() !void {
// 両端キューを初期化
// 両端キューを初期化する
var deque = LinkedListDeque(i32){};
try deque.init(std.heap.page_allocator);
defer deque.deinit();
@@ -175,35 +175,35 @@ pub fn main() !void {
std.debug.print("両端キュー deque = ", .{});
inc.PrintUtil.printArray(i32, try deque.toArray());
// 要素にアクセス
// 要素にアクセスする
var peek_first = deque.peekFirst();
std.debug.print("\n先頭要素 peek_first = {}", .{peek_first});
std.debug.print("\nキューの先頭要素 peek_first = {}", .{peek_first});
var peek_last = deque.peekLast();
std.debug.print("\n末尾要素 peek_last = {}", .{peek_last});
std.debug.print("\nキューの末尾要素 peek_last = {}", .{peek_last});
// 要素をエンキュー
// 要素をエンキューする
try deque.pushLast(4);
std.debug.print("\n要素 4 を末尾からエンキューした後 deque = ", .{});
std.debug.print("\n要素 4 を末尾にエンキューした後 deque = ", .{});
inc.PrintUtil.printArray(i32, try deque.toArray());
try deque.pushFirst(1);
std.debug.print("\n要素 1 を先頭からエンキューした後 deque = ", .{});
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});
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});
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});
std.debug.print("\n両端キューは空か = {}", .{is_empty});
_ = try std.io.getStdIn().reader().readByte();
}

View File

@@ -5,7 +5,7 @@
const std = @import("std");
const inc = @import("include");
// 連結リストベースのキュー
// 連結リストで実装したキュー
pub fn LinkedListQueue(comptime T: type) type {
return struct {
const Self = @This();
@@ -16,7 +16,7 @@ pub fn LinkedListQueue(comptime T: type) type {
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);
@@ -27,7 +27,7 @@ pub fn LinkedListQueue(comptime T: type) type {
self.que_size = 0;
}
// デストラクタ(メモリを解放する)
// デストラクタ(メモリの解放)
pub fn deinit(self: *Self) void {
if (self.mem_arena == null) return;
self.mem_arena.?.deinit();
@@ -38,12 +38,12 @@ pub fn LinkedListQueue(comptime T: type) type {
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;
@@ -51,14 +51,14 @@ pub fn LinkedListQueue(comptime T: type) type {
// エンキュー
pub fn push(self: *Self, num: T) !void {
// 末尾ノードの後ろに num を追加
// 末尾ノードの後ろに 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;
@@ -69,13 +69,13 @@ pub fn LinkedListQueue(comptime T: type) type {
// デキュー
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());
@@ -90,14 +90,14 @@ pub fn LinkedListQueue(comptime T: type) type {
};
}
// 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);
@@ -106,11 +106,11 @@ pub fn main() !void {
std.debug.print("キュー queue = ", .{});
inc.PrintUtil.printArray(i32, try queue.toArray());
// キュー先頭の要素にアクセス
// キューの先頭要素にアクセス
var peek = queue.peek();
std.debug.print("\n先頭要素 peek = {}", .{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());
@@ -119,9 +119,9 @@ pub fn main() !void {
var size = queue.size();
std.debug.print("\nキューの長さ size = {}", .{size});
// キューが空かどうかを判定
// キューが空か判定
var is_empty = queue.isEmpty();
std.debug.print("\nキューが空かどうか = {}", .{is_empty});
std.debug.print("\nキューは空か = {}", .{is_empty});
_ = try std.io.getStdIn().reader().readByte();
}

View File

@@ -5,17 +5,17 @@
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, // 先頭ノードをスタックトップとする
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);
@@ -25,23 +25,23 @@ pub fn LinkedListStack(comptime T: type) type {
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;
@@ -64,7 +64,7 @@ pub fn LinkedListStack(comptime T: type) type {
return num;
}
// スタックを配列に変換
// スタックを配列に変換する
pub fn toArray(self: *Self) ![]T {
var node = self.stack_top;
var res = try self.mem_allocator.alloc(T, self.size());
@@ -79,15 +79,15 @@ pub fn LinkedListStack(comptime T: type) type {
};
}
// 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);
@@ -96,22 +96,22 @@ pub fn main() !void {
std.debug.print("スタック stack = ", .{});
inc.PrintUtil.printArray(i32, try stack.toArray());
// スタックトップの要素にアクセス
// スタックの先頭要素にアクセスする
var peek = stack.peek();
std.debug.print("\nスタック頂部の要素 top = {}", .{peek});
std.debug.print("\nスタックの先頭要素 top = {}", .{peek});
// 要素をポップ
// 要素をポップする
var pop = stack.pop();
std.debug.print("\nポップした要素 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});
std.debug.print("\nスタックは空か = {}", .{is_empty});
_ = try std.io.getStdIn().reader().readByte();
}

View File

@@ -5,13 +5,13 @@
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 };
@@ -25,11 +25,11 @@ pub fn main() !void {
std.debug.print("キュー queue = ", .{});
inc.PrintUtil.printQueue(i32, queue);
// キュー先頭の要素にアクセス
// キューの先頭要素にアクセス
var peek = queue.first.?.data;
std.debug.print("\n先頭要素 peek = {}", .{peek});
std.debug.print("\nキューの先頭要素 peek = {}", .{peek});
// 要素をデキュー
// 要素をデキューする
var pop = queue.popFirst().?.data;
std.debug.print("\nデキューした要素 pop = {}、デキュー後 queue = ", .{pop});
inc.PrintUtil.printQueue(i32, queue);
@@ -38,9 +38,9 @@ pub fn main() !void {
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});
std.debug.print("\nキューは空か = {}", .{is_empty});
_ = try std.io.getStdIn().reader().readByte();
}

View File

@@ -5,15 +5,15 @@
const std = @import("std");
const inc = @import("include");
// Driver Code
// 実行用コード
pub fn main() !void {
// スタックを初期化する
// zig では、ArrayList をスタックとして使うことが推奨される
// 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);
@@ -22,22 +22,22 @@ pub fn main() !void {
std.debug.print("スタック stack = ", .{});
inc.PrintUtil.printList(i32, stack);
// スタックトップの要素にアクセス
// スタックの先頭要素にアクセスする
var peek = stack.items[stack.items.len - 1];
std.debug.print("\nスタックトップ要素 peek = {}", .{peek});
std.debug.print("\nスタックの先頭要素 peek = {}", .{peek});
// 要素をポップ
// 要素をポップする
var pop = stack.pop();
std.debug.print("\nポップした要素 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});
std.debug.print("\nスタックは空か = {}", .{is_empty});
_ = try std.io.getStdIn().reader().readByte();
}