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
@@ -6,10 +6,10 @@
namespace hello_algo.chapter_stack_and_queue;
/* 循環配列ベースの両端キュー */
/* 循環配列で実装した両端キュー */
public class ArrayDeque {
int[] nums; // 両端キューの要素を格納する配列
int front; // 先頭ポインタ。先頭要素を指す
int front; // キューの先頭要素を指す先頭ポインタ
int queSize; // 両端キューの長さ
/* コンストラクタ */
@@ -18,73 +18,73 @@ public class ArrayDeque {
front = queSize = 0;
}
/* 両端キューの容量を取得 */
/* 両端キューの容量を取得する */
int Capacity() {
return nums.Length;
}
/* 両端キューの長さを取得 */
/* 両端キューの長さを取得する */
public int Size() {
return queSize;
}
/* 両端キューが空かどうかを判定 */
/* 両端キューが空かどうかを判定する */
public bool IsEmpty() {
return queSize == 0;
}
/* 循環配列のインデックスを計算 */
/* 循環配列のインデックスを計算する */
int Index(int i) {
// 剰余演算により配列の先頭と末尾をつなげる
// i が配列の末尾を越えたら先頭に戻る
// i が配列の先頭を越えて前に出たら末尾に戻る
// 剰余演算を使い、配列の先頭と末尾をつなぐ
// i が配列の末尾を越えたら、先頭に戻る
// i が配列の先頭を越えたら、末尾に戻る
return (i + Capacity()) % Capacity();
}
/* キュー先頭にエンキュー */
/* 先頭にエンキューする */
public void PushFirst(int num) {
if (queSize == Capacity()) {
Console.WriteLine("両端キューは満杯です");
Console.WriteLine("両端キューが満杯です");
return;
}
// 先頭ポインタを左に 1 つ移動する
// 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする
// 剰余演算により、front が配列の先頭を越えたら末尾に戻るようにする
front = Index(front - 1);
// num をキュー先頭に追加
// num をキューの先頭に追加する
nums[front] = num;
queSize++;
}
/* キュー末尾にエンキュー */
/* 末尾にエンキューする */
public void PushLast(int num) {
if (queSize == Capacity()) {
Console.WriteLine("両端キューは満杯です");
Console.WriteLine("両端キューが満杯です");
return;
}
// キュー末尾ポインタを計算し、末尾インデックス + 1 を指す
// 末尾のインデックス + 1 を指す末尾ポインタを計算する
int rear = Index(front + queSize);
// num をキュー末尾に追加
// num をキューの末尾に追加する
nums[rear] = num;
queSize++;
}
/* キュー先頭からデキュー */
/* 先頭からデキューする */
public int PopFirst() {
int num = PeekFirst();
// 先頭ポインタを 1 つ後ろへ進める
// 先頭ポインタを後ろに 1 つ移動する
front = Index(front + 1);
queSize--;
return num;
}
/* キュー末尾からデキュー */
/* 末尾からデキューする */
public int PopLast() {
int num = PeekLast();
queSize--;
return num;
}
/* キュー先頭の要素にアクセス */
/* キューの先頭要素にアクセス */
public int PeekFirst() {
if (IsEmpty()) {
throw new InvalidOperationException();
@@ -92,19 +92,19 @@ public class ArrayDeque {
return nums[front];
}
/* キュー末尾の要素にアクセス */
/* キューの末尾要素にアクセスする */
public int PeekLast() {
if (IsEmpty()) {
throw new InvalidOperationException();
}
// 末尾要素のインデックスを計算
// 末尾要素のインデックスを計算する
int last = Index(front + queSize - 1);
return nums[last];
}
/* 出力用の配列を返す */
/* 表示用の配列を返す */
public int[] ToArray() {
// 有効長の範囲内のリスト要素のみを変換
// 有効な長さの範囲内にあるリストの要素だけを変換する
int[] res = new int[queSize];
for (int i = 0, j = front; i < queSize; i++, j++) {
res[i] = nums[Index(j)];
@@ -116,37 +116,37 @@ public class ArrayDeque {
public class array_deque {
[Test]
public void Test() {
/* 両端キューを初期化 */
/* 両端キューを初期化する */
ArrayDeque deque = new(10);
deque.PushLast(3);
deque.PushLast(2);
deque.PushLast(5);
Console.WriteLine("双方向キュー deque = " + string.Join(" ", deque.ToArray()));
Console.WriteLine("両端キュー deque = " + string.Join(" ", deque.ToArray()));
/* 要素にアクセス */
/* 要素にアクセスする */
int peekFirst = deque.PeekFirst();
Console.WriteLine("先頭要素 peekFirst = " + peekFirst);
Console.WriteLine("キューの先頭要素 peekFirst = " + peekFirst);
int peekLast = deque.PeekLast();
Console.WriteLine("末尾要素 peekLast = " + peekLast);
Console.WriteLine("キューの末尾要素 peekLast = " + peekLast);
/* 要素をエンキュー */
/* 要素をエンキューする */
deque.PushLast(4);
Console.WriteLine("要素 4 を末尾にエンキューした後 deque = " + string.Join(" ", deque.ToArray()));
deque.PushFirst(1);
Console.WriteLine("要素 1 を先頭にエンキューした後 deque = " + string.Join(" ", deque.ToArray()));
/* 要素をデキュー */
/* 要素をデキューする */
int popLast = deque.PopLast();
Console.WriteLine("末尾からデキューした要素 = " + popLast + "、末尾からデキューした後 deque = " + string.Join(" ", deque.ToArray()));
int popFirst = deque.PopFirst();
Console.WriteLine("先頭からデキューした要素 = " + popFirst + "、先頭からデキューした後 deque = " + string.Join(" ", deque.ToArray()));
/* 両端キューの長さを取得 */
/* 両端キューの長さを取得する */
int size = deque.Size();
Console.WriteLine("双方向キューの長さ size = " + size);
Console.WriteLine("両端キューの長さ size = " + size);
/* 両端キューが空かどうかを判定 */
/* 両端キューが空かどうかを判定する */
bool isEmpty = deque.IsEmpty();
Console.WriteLine("双方向キューが空かどうか = " + isEmpty);
Console.WriteLine("両端キューは空か = " + isEmpty);
}
}
@@ -6,10 +6,10 @@
namespace hello_algo.chapter_stack_and_queue;
/* 循環配列ベースのキュー */
/* 循環配列で実装したキュー */
class ArrayQueue {
int[] nums; // キュー要素を格納する配列
int front; // 先頭ポインタ。先頭要素を指す
int[] nums; // キューの要素を格納する配列
int front; // キューの先頭要素を指す先頭ポインタ
int queSize; // キューの長さ
public ArrayQueue(int capacity) {
@@ -17,7 +17,7 @@ class ArrayQueue {
front = queSize = 0;
}
/* キューの容量を取得 */
/* キューの容量を取得する */
int Capacity() {
return nums.Length;
}
@@ -27,7 +27,7 @@ class ArrayQueue {
return queSize;
}
/* キューが空かどうかを判定 */
/* キューが空か判定 */
public bool IsEmpty() {
return queSize == 0;
}
@@ -35,13 +35,13 @@ class ArrayQueue {
/* エンキュー */
public void Push(int num) {
if (queSize == Capacity()) {
Console.WriteLine("キューは満杯です");
Console.WriteLine("キューが満杯です");
return;
}
// 末尾ポインタを計算し、末尾インデックス + 1 を指す
// 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする
// 末尾のインデックス + 1 を指す末尾ポインタを計算する
// 剰余演算で、rear が配列末尾を越えたら先頭へ戻る
int rear = (front + queSize) % Capacity();
// num をキュー末尾に追加
// num をキューの末尾に追加する
nums[rear] = num;
queSize++;
}
@@ -49,13 +49,13 @@ class ArrayQueue {
/* デキュー */
public int Pop() {
int num = Peek();
// 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す
// 先頭ポインタを後ろに 1 つ移動し、末尾を越えたら配列の先頭に戻す
front = (front + 1) % Capacity();
queSize--;
return num;
}
/* キュー先頭の要素にアクセス */
/* キューの先頭要素にアクセス */
public int Peek() {
if (IsEmpty())
throw new Exception();
@@ -64,7 +64,7 @@ class ArrayQueue {
/* 配列を返す */
public int[] ToArray() {
// 有効長の範囲内のリスト要素のみを変換
// 有効な長さの範囲内にあるリストの要素だけを変換する
int[] res = new int[queSize];
for (int i = 0, j = front; i < queSize; i++, j++) {
res[i] = nums[j % this.Capacity()];
@@ -76,11 +76,11 @@ class ArrayQueue {
public class array_queue {
[Test]
public void Test() {
/* キューを初期化 */
/* キューを初期化する */
int capacity = 10;
ArrayQueue queue = new(capacity);
/* 要素をエンキュー */
/* 要素をエンキューする */
queue.Push(1);
queue.Push(3);
queue.Push(2);
@@ -88,27 +88,27 @@ public class array_queue {
queue.Push(4);
Console.WriteLine("キュー queue = " + string.Join(",", queue.ToArray()));
/* キュー先頭の要素にアクセス */
/* キューの先頭要素にアクセス */
int peek = queue.Peek();
Console.WriteLine("先頭要素 peek = " + peek);
Console.WriteLine("キューの先頭要素 peek = " + peek);
/* 要素をデキュー */
/* 要素をデキューする */
int pop = queue.Pop();
Console.WriteLine("デキューした要素 pop = " + pop + "、デキュー後の queue = " + string.Join(",", queue.ToArray()));
Console.WriteLine("デキューした要素 pop = " + pop + "、デキュー後 queue = " + string.Join(",", queue.ToArray()));
/* キューの長さを取得 */
int size = queue.Size();
Console.WriteLine("キューの長さ size = " + size);
/* キューが空かどうかを判定 */
/* キューが空か判定 */
bool isEmpty = queue.IsEmpty();
Console.WriteLine("キューが空かどうか = " + isEmpty);
Console.WriteLine("キューは空か = " + isEmpty);
/* 循環配列をテストする */
for (int i = 0; i < 10; i++) {
queue.Push(i);
queue.Pop();
Console.WriteLine("第 " + i + " 回のエンキュー + デキュー後 queue = " + string.Join(",", queue.ToArray()));
Console.WriteLine("第 " + i + " 回のエンキューとデキューの後 queue = " + string.Join(",", queue.ToArray()));
}
}
}
@@ -6,7 +6,7 @@
namespace hello_algo.chapter_stack_and_queue;
/* 配列ベースのスタック */
/* 配列で実装したスタック */
class ArrayStack {
List<int> stack;
public ArrayStack() {
@@ -14,12 +14,12 @@ class ArrayStack {
stack = [];
}
/* スタックの長さを取得 */
/* スタックの長さを取得する */
public int Size() {
return stack.Count;
}
/* スタックが空かどうかを判定 */
/* スタックが空かどうかを判定する */
public bool IsEmpty() {
return Size() == 0;
}
@@ -38,7 +38,7 @@ class ArrayStack {
return val;
}
/* スタックトップの要素にアクセス */
/* スタックの先頭要素にアクセスする */
public int Peek() {
if (IsEmpty())
throw new Exception();
@@ -54,10 +54,10 @@ class ArrayStack {
public class array_stack {
[Test]
public void Test() {
/* スタックを初期化 */
/* スタックを初期化する */
ArrayStack stack = new();
/* 要素をプッシュ */
/* 要素をプッシュする */
stack.Push(1);
stack.Push(3);
stack.Push(2);
@@ -65,20 +65,20 @@ public class array_stack {
stack.Push(4);
Console.WriteLine("スタック stack = " + string.Join(",", stack.ToArray()));
/* スタックトップの要素にアクセス */
/* スタックの先頭要素にアクセスする */
int peek = stack.Peek();
Console.WriteLine("スタックトップ要素 peek = " + peek);
Console.WriteLine("スタックの先頭要素 peek = " + peek);
/* 要素をポップ */
/* 要素をポップする */
int pop = stack.Pop();
Console.WriteLine("ポップした要素 pop = " + pop + "、ポップ後の stack = " + string.Join(",", stack.ToArray()));
Console.WriteLine("ポップした要素 pop = " + pop + "、ポップ後 stack = " + string.Join(",", stack.ToArray()));
/* スタックの長さを取得 */
/* スタックの長さを取得する */
int size = stack.Size();
Console.WriteLine("スタックの長さ size = " + size);
/* 空かどうかを判定 */
/* 空かどうかを判定する */
bool isEmpty = stack.IsEmpty();
Console.WriteLine("スタックが空かどうか = " + isEmpty);
Console.WriteLine("スタックは空か = " + isEmpty);
}
}
@@ -9,36 +9,36 @@ namespace hello_algo.chapter_stack_and_queue;
public class deque {
[Test]
public void Test() {
/* 両端キューを初期化 */
// C# では、LinkedList を両端キューとして使う
/* 両端キューを初期化する */
// C# では、連結リスト LinkedList を両端キューとして使う
LinkedList<int> deque = new();
/* 要素をエンキュー */
deque.AddLast(2); // 末尾に追加する
/* 要素をエンキューする */
deque.AddLast(2); // キューの末尾に追加する
deque.AddLast(5);
deque.AddLast(4);
deque.AddFirst(3); // 先頭に追加する
deque.AddFirst(3); // キューの先頭に追加する
deque.AddFirst(1);
Console.WriteLine("双方向キュー deque = " + string.Join(",", deque));
Console.WriteLine("両端キュー deque = " + string.Join(",", deque));
/* 要素にアクセス */
int? peekFirst = deque.First?.Value; // 先頭要素
Console.WriteLine("先頭要素 peekFirst = " + peekFirst);
int? peekLast = deque.Last?.Value; // 末尾要素
Console.WriteLine("末尾要素 peekLast = " + peekLast);
/* 要素にアクセスする */
int? peekFirst = deque.First?.Value; // キューの先頭要素
Console.WriteLine("キューの先頭要素 peekFirst = " + peekFirst);
int? peekLast = deque.Last?.Value; // キューの末尾要素
Console.WriteLine("キューの末尾要素 peekLast = " + peekLast);
/* 要素をデキュー */
deque.RemoveFirst(); // 先頭要素を取り出す
/* 要素をデキューする */
deque.RemoveFirst(); // キューの先頭要素をデキューする
Console.WriteLine("先頭要素をデキューした後 deque = " + string.Join(",", deque));
deque.RemoveLast(); // 末尾要素を取り出す
deque.RemoveLast(); // キューの末尾要素をデキューする
Console.WriteLine("末尾要素をデキューした後 deque = " + string.Join(",", deque));
/* 両端キューの長さを取得 */
/* 両端キューの長さを取得する */
int size = deque.Count;
Console.WriteLine("双方向キューの長さ size = " + size);
Console.WriteLine("両端キューの長さ size = " + size);
/* 両端キューが空かどうかを判定 */
/* 両端キューが空かどうかを判定する */
bool isEmpty = deque.Count == 0;
Console.WriteLine("双方向キューが空かどうか = " + isEmpty);
Console.WriteLine("両端キューは空か = " + isEmpty);
}
}
@@ -6,14 +6,14 @@
namespace hello_algo.chapter_stack_and_queue;
/* 双方向連結リストノード */
/* 双方向連結リストのノード */
public class ListNode(int val) {
public int val = val; // ノード値
public int val = val; // ノードの値
public ListNode? next = null; // 後続ノードへの参照
public ListNode? prev = null; // 前駆ノードへの参照
public ListNode? prev = null; // 前のノードへの参照
}
/* 双方向連結リストベースの両端キュー */
/* 双方向連結リストで実装した両端キュー */
public class LinkedListDeque {
ListNode? front, rear; // 先頭ノード front、末尾ノード rear
int queSize = 0; // 両端キューの長さ
@@ -23,12 +23,12 @@ public class LinkedListDeque {
rear = null;
}
/* 両端キューの長さを取得 */
/* 両端キューの長さを取得する */
public int Size() {
return queSize;
}
/* 両端キューが空かどうかを判定 */
/* 両端キューが空かどうかを判定する */
public bool IsEmpty() {
return Size() == 0;
}
@@ -36,35 +36,35 @@ public class LinkedListDeque {
/* エンキュー操作 */
void Push(int num, bool isFront) {
ListNode node = new(num);
// 連結リストが空なら、front と rear の両方を node に向ける
// 連結リストが空の場合、front と rear の両方が node を指すようにする
if (IsEmpty()) {
front = node;
rear = node;
}
// 先頭へのエンキュー操作
else if (isFront) {
// node を連結リストの先頭に追加
// node を連結リストの先頭に追加する
front!.prev = node;
node.next = front;
front = node; // 先頭ノードを更新する
front = node; // 先頭ノードを更新する
}
// 末尾へのエンキュー操作
else {
// node を連結リストの末尾に追加
// node を連結リストの末尾に追加する
rear!.next = node;
node.prev = rear;
rear = node; // 末尾ノードを更新する
}
queSize++; // キューの長さを更新
queSize++; // キューの長さを更新する
}
/* キュー先頭にエンキュー */
/* 先頭にエンキューする */
public void PushFirst(int num) {
Push(num, true);
}
/* キュー末尾にエンキュー */
/* 末尾にエンキューする */
public void PushLast(int num) {
Push(num, false);
}
@@ -74,60 +74,60 @@ public class LinkedListDeque {
if (IsEmpty())
throw new Exception();
int? val;
// 要素が1つの場合、先頭と末尾は同じノードを指す
// キューの長さが 1 のとき、先頭と末尾は同じノードを指す
if (queSize == 1) {
val = front!.val;
front = null;
rear = null;
}
// キュー先頭からの取り出し
// 先頭からのデキュー操作
else if (isFront) {
val = front!.val; // 先頭ノードの値を一時保存
// 先頭ノードを削除
val = front!.val; // 先頭ノードの値を一時保存する
// 先頭ノードを削除する
ListNode? fNext = front?.next;
fNext!.prev = null;
front.next = null;
front = fNext; // 先頭ノードを更新する
}
// キュー末尾からの取り出し
// 末尾からのデキュー操作
else {
val = rear!.val; // 末尾ノードの値を一時保存
// 末尾ノードを削除
val = rear!.val; // 末尾ノードの値を一時保存する
// 末尾ノードを削除する
ListNode? rPrev = rear?.prev;
rPrev!.next = null;
rear.prev = null;
rear = rPrev; // 末尾ノードを更新する
}
queSize--; // キューの長さを更新
queSize--; // キューの長さを更新する
return val;
}
/* キュー先頭からデキュー */
/* 先頭からデキューする */
public int? PopFirst() {
return Pop(true);
}
/* キュー末尾からデキュー */
/* 末尾からデキューする */
public int? PopLast() {
return Pop(false);
}
/* キュー先頭の要素にアクセス */
/* キューの先頭要素にアクセス */
public int? PeekFirst() {
if (IsEmpty())
throw new Exception();
return front?.val;
}
/* キュー末尾の要素にアクセス */
/* キューの末尾要素にアクセスする */
public int? PeekLast() {
if (IsEmpty())
throw new Exception();
return rear?.val;
}
/* 出力用の配列を返す */
/* 表示用の配列を返す */
public int?[] ToArray() {
ListNode? node = front;
int?[] res = new int?[Size()];
@@ -143,37 +143,37 @@ public class LinkedListDeque {
public class linkedlist_deque {
[Test]
public void Test() {
/* 両端キューを初期化 */
/* 両端キューを初期化する */
LinkedListDeque deque = new();
deque.PushLast(3);
deque.PushLast(2);
deque.PushLast(5);
Console.WriteLine("双方向キュー deque = " + string.Join(" ", deque.ToArray()));
Console.WriteLine("両端キュー deque = " + string.Join(" ", deque.ToArray()));
/* 要素にアクセス */
/* 要素にアクセスする */
int? peekFirst = deque.PeekFirst();
Console.WriteLine("先頭要素 peekFirst = " + peekFirst);
Console.WriteLine("キューの先頭要素 peekFirst = " + peekFirst);
int? peekLast = deque.PeekLast();
Console.WriteLine("末尾要素 peekLast = " + peekLast);
Console.WriteLine("キューの末尾要素 peekLast = " + peekLast);
/* 要素をエンキュー */
/* 要素をエンキューする */
deque.PushLast(4);
Console.WriteLine("要素 4 を末尾にエンキューした後 deque = " + string.Join(" ", deque.ToArray()));
deque.PushFirst(1);
Console.WriteLine("要素 1 を先頭にエンキューした後 deque = " + string.Join(" ", deque.ToArray()));
/* 要素をデキュー */
/* 要素をデキューする */
int? popLast = deque.PopLast();
Console.WriteLine("末尾からデキューした要素 = " + popLast + "、末尾からデキューした後 deque = " + string.Join(" ", deque.ToArray()));
int? popFirst = deque.PopFirst();
Console.WriteLine("先頭からデキューした要素 = " + popFirst + "、先頭からデキューした後 deque = " + string.Join(" ", deque.ToArray()));
/* 両端キューの長さを取得 */
/* 両端キューの長さを取得する */
int size = deque.Size();
Console.WriteLine("双方向キューの長さ size = " + size);
Console.WriteLine("両端キューの長さ size = " + size);
/* 両端キューが空かどうかを判定 */
/* 両端キューが空かどうかを判定する */
bool isEmpty = deque.IsEmpty();
Console.WriteLine("双方向キューが空かどうか = " + isEmpty);
Console.WriteLine("両端キューは空か = " + isEmpty);
}
}
@@ -6,9 +6,9 @@
namespace hello_algo.chapter_stack_and_queue;
/* 連結リストベースのキュー */
/* 連結リストで実装したキュー */
class LinkedListQueue {
ListNode? front, rear; // 先頭ノード front、末尾ノード rear
ListNode? front, rear; // 先頭ノード front 、末尾ノード rear
int queSize = 0;
public LinkedListQueue() {
@@ -21,20 +21,20 @@ class LinkedListQueue {
return queSize;
}
/* キューが空かどうかを判定 */
/* キューが空か判定 */
public bool IsEmpty() {
return Size() == 0;
}
/* エンキュー */
public void Push(int num) {
// 末尾ノードの後ろに num を追加
// 末尾ノードの後ろに num を追加する
ListNode node = new(num);
// キューが空なら、先頭・末尾ノードをともにそのノードに設定
// キューが空の場合、先頭と末尾の両方がこのノードを指すようにする
if (front == null) {
front = node;
rear = node;
// キューが空でなければ、そのノードを末尾ノードの後ろに追加
// キューが空でない場合、このノードを末尾ノードの後ろに追加する
} else if (rear != null) {
rear.next = node;
rear = node;
@@ -45,13 +45,13 @@ class LinkedListQueue {
/* デキュー */
public int Pop() {
int num = Peek();
// 先頭ノードを削除
// 先頭ノードを削除する
front = front?.next;
queSize--;
return num;
}
/* キュー先頭の要素にアクセス */
/* キューの先頭要素にアクセス */
public int Peek() {
if (IsEmpty())
throw new Exception();
@@ -76,10 +76,10 @@ class LinkedListQueue {
public class linkedlist_queue {
[Test]
public void Test() {
/* キューを初期化 */
/* キューを初期化する */
LinkedListQueue queue = new();
/* 要素をエンキュー */
/* 要素をエンキューする */
queue.Push(1);
queue.Push(3);
queue.Push(2);
@@ -87,20 +87,20 @@ public class linkedlist_queue {
queue.Push(4);
Console.WriteLine("キュー queue = " + string.Join(",", queue.ToArray()));
/* キュー先頭の要素にアクセス */
/* キューの先頭要素にアクセス */
int peek = queue.Peek();
Console.WriteLine("先頭要素 peek = " + peek);
Console.WriteLine("キューの先頭要素 peek = " + peek);
/* 要素をデキュー */
/* 要素をデキューする */
int pop = queue.Pop();
Console.WriteLine("デキューした要素 pop = " + pop + "、デキュー後の queue = " + string.Join(",", queue.ToArray()));
Console.WriteLine("デキューした要素 pop = " + pop + "、デキュー後 queue = " + string.Join(",", queue.ToArray()));
/* キューの長さを取得 */
int size = queue.Size();
Console.WriteLine("キューの長さ size = " + size);
/* キューが空かどうかを判定 */
/* キューが空か判定 */
bool isEmpty = queue.IsEmpty();
Console.WriteLine("キューが空かどうか = " + isEmpty);
Console.WriteLine("キューは空か = " + isEmpty);
}
}
@@ -6,21 +6,21 @@
namespace hello_algo.chapter_stack_and_queue;
/* 連結リストベースのスタック */
/* 連結リストで実装したスタック */
class LinkedListStack {
ListNode? stackPeek; // 先頭ノードをスタックトップとする
ListNode? stackPeek; // 先頭ノードをスタックの先頭とする
int stkSize = 0; // スタックの長さ
public LinkedListStack() {
stackPeek = null;
}
/* スタックの長さを取得 */
/* スタックの長さを取得する */
public int Size() {
return stkSize;
}
/* スタックが空かどうかを判定 */
/* スタックが空かどうかを判定する */
public bool IsEmpty() {
return Size() == 0;
}
@@ -42,7 +42,7 @@ class LinkedListStack {
return num;
}
/* スタックトップの要素にアクセス */
/* スタックの先頭要素にアクセスする */
public int Peek() {
if (IsEmpty())
throw new Exception();
@@ -67,10 +67,10 @@ class LinkedListStack {
public class linkedlist_stack {
[Test]
public void Test() {
/* スタックを初期化 */
/* スタックを初期化する */
LinkedListStack stack = new();
/* 要素をプッシュ */
/* 要素をプッシュする */
stack.Push(1);
stack.Push(3);
stack.Push(2);
@@ -78,20 +78,20 @@ public class linkedlist_stack {
stack.Push(4);
Console.WriteLine("スタック stack = " + string.Join(",", stack.ToArray()));
/* スタックトップの要素にアクセス */
/* スタックの先頭要素にアクセスする */
int peek = stack.Peek();
Console.WriteLine("スタックトップ要素 peek = " + peek);
Console.WriteLine("スタックの先頭要素 peek = " + peek);
/* 要素をポップ */
/* 要素をポップする */
int pop = stack.Pop();
Console.WriteLine("ポップした要素 pop = " + pop + "、ポップ後の stack = " + string.Join(",", stack.ToArray()));
Console.WriteLine("ポップした要素 pop = " + pop + "、ポップ後 stack = " + string.Join(",", stack.ToArray()));
/* スタックの長さを取得 */
/* スタックの長さを取得する */
int size = stack.Size();
Console.WriteLine("スタックの長さ size = " + size);
/* 空かどうかを判定 */
/* 空かどうかを判定する */
bool isEmpty = stack.IsEmpty();
Console.WriteLine("スタックが空かどうか = " + isEmpty);
Console.WriteLine("スタックは空か = " + isEmpty);
}
}
@@ -9,10 +9,10 @@ namespace hello_algo.chapter_stack_and_queue;
public class queue {
[Test]
public void Test() {
/* キューを初期化 */
/* キューを初期化する */
Queue<int> queue = new();
/* 要素をエンキュー */
/* 要素をエンキューする */
queue.Enqueue(1);
queue.Enqueue(3);
queue.Enqueue(2);
@@ -20,20 +20,20 @@ public class queue {
queue.Enqueue(4);
Console.WriteLine("キュー queue = " + string.Join(",", queue));
/* キュー先頭の要素にアクセス */
/* キューの先頭要素にアクセス */
int peek = queue.Peek();
Console.WriteLine("先頭要素 peek = " + peek);
Console.WriteLine("キューの先頭要素 peek = " + peek);
/* 要素をデキュー */
/* 要素をデキューする */
int pop = queue.Dequeue();
Console.WriteLine("デキューした要素 pop = " + pop + "、デキュー後の queue = " + string.Join(",", queue));
Console.WriteLine("デキューした要素 pop = " + pop + "、デキュー後 queue = " + string.Join(",", queue));
/* キューの長さを取得 */
int size = queue.Count;
Console.WriteLine("キューの長さ size = " + size);
/* キューが空かどうかを判定 */
/* キューが空か判定 */
bool isEmpty = queue.Count == 0;
Console.WriteLine("キューが空かどうか = " + isEmpty);
Console.WriteLine("キューは空か = " + isEmpty);
}
}
@@ -9,32 +9,32 @@ namespace hello_algo.chapter_stack_and_queue;
public class stack {
[Test]
public void Test() {
/* スタックを初期化 */
/* スタックを初期化する */
Stack<int> stack = new();
/* 要素をプッシュ */
/* 要素をプッシュする */
stack.Push(1);
stack.Push(3);
stack.Push(2);
stack.Push(5);
stack.Push(4);
// 注意:stack.ToArray() で得られるのは逆順のシーケンスであり、インデックス 0 がスタックトップです
// stack.ToArray() が返す列は逆順であり、インデックス 0 がスタックの先頭になることに注意
Console.WriteLine("スタック stack = " + string.Join(",", stack));
/* スタックトップの要素にアクセス */
/* スタックの先頭要素にアクセスする */
int peek = stack.Peek();
Console.WriteLine("スタックトップ要素 peek = " + peek);
Console.WriteLine("スタックの先頭要素 peek = " + peek);
/* 要素をポップ */
/* 要素をポップする */
int pop = stack.Pop();
Console.WriteLine("ポップした要素 pop = " + pop + "、ポップ後の stack = " + string.Join(",", stack));
Console.WriteLine("ポップした要素 pop = " + pop + "、ポップ後 stack = " + string.Join(",", stack));
/* スタックの長さを取得 */
/* スタックの長さを取得する */
int size = stack.Count;
Console.WriteLine("スタックの長さ size = " + size);
/* 空かどうかを判定 */
/* 空かどうかを判定する */
bool isEmpty = stack.Count == 0;
Console.WriteLine("スタックが空かどうか = " + isEmpty);
Console.WriteLine("スタックは空か = " + isEmpty);
}
}