CS_learn/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-06-15 22:57:48 +08:00
Code Issues Packages Projects Releases Wiki Activity

Re-translate the Japanese version (#1871)

Browse Source 
* Retranslate Japanese docs with GPT-5.4

* Retranslate Japanese code with GPT-5.4
This commit is contained in:
Yudong Jin
2026-03-30 07:30:15 +08:00
committed by GitHub
parent fe6443235b
commit d7b2277d2b
1444 changed files with 83312 additions and 8363 deletions
Download Patch File Download Diff File Expand all files Collapse all files

76
ja/codes/java/chapter_stack_and_queue/array_deque.java
View File

@@ -8,10 +8,10 @@ package chapter_stack_and_queue;
import java.util.*;
/* 循環配列に基づく両端キュークラス */
/* 循環配列ベースの両端キュー */
class ArrayDeque {
private int[] nums; // 両端キューの要素を格納する配列
private int front; // 先頭ポインタ、先頭要素を指す
private int front; // 先頭ポインタ。先頭要素を指す
private int queSize; // 両端キューの長さ
/* コンストラクタ */
@@ -35,63 +35,65 @@ class ArrayDeque {
return queSize == 0;
}
/* 循環配列インデックスを計算 */
/* 循環配列のインデックスを計算 */
private int index(int i) {
// モジュロ演算により循環配列を実装
// i が配列の末尾を超える場合、先頭に戻る
// i が配列の先頭を超える場合、末尾に戻る
// 剰余演算により配列の先頭と末尾をつなげる
// i が配列の末尾を越えたら先頭に戻る
// i が配列の先頭を越えて前に出たら末尾に戻る
return (i + capacity()) % capacity();
}
/* 先頭エンキュー */
/* キュー先頭にエンキュー */
public void pushFirst(int num) {
if (queSize == capacity()) {
System.out.println("両端キューが満杯です");
System.out.println("双方向キューは満杯です");
return;
}
// 先頭ポインタを左に移動し、境界を越える場合は配列の末尾に回る
// 先頭ポインタを左に 1 つ移動する
// 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする
front = index(front - 1);
// 先頭に num を追加
// num をキュー先頭に追加
nums[front] = num;
queSize++;
}
/* 末尾エンキュー */
/* キュー末尾にエンキュー */
public void pushLast(int num) {
if (queSize == capacity()) {
System.out.println("両端キューが満杯です");
System.out.println("双方向キューは満杯です");
return;
}
// 末尾ポインタを計算し、末尾に要素を追加
// キュー末尾ポインタを計算し、末尾インデックス + 1 を指す
int rear = index(front + queSize);
// num をキュー末尾に追加
nums[rear] = num;
queSize++;
}
/* 先頭デキュー */
/* キュー先頭からデキュー */
public int popFirst() {
int num = peekFirst();
// 先頭ポインタを右に移動
// 先頭ポインタを 1 つ後ろへ進める
front = index(front + 1);
queSize--;
return num;
}
/* 末尾デキュー */
/* キュー末尾からデキュー */
public int popLast() {
int num = peekLast();
queSize--;
return num;
}
/* 先頭要素にアクセス */
/* キュー先頭の要素にアクセス */
public int peekFirst() {
if (isEmpty())
throw new IndexOutOfBoundsException();
return nums[front];
}
/* 末尾要素にアクセス */
/* キュー末尾の要素にアクセス */
public int peekLast() {
if (isEmpty())
throw new IndexOutOfBoundsException();
@@ -100,9 +102,9 @@ class ArrayDeque {
return nums[last];
}
/* 配列を返す */
/* 出力用の配列を返す */
public int[] toArray() {
// front から開始して queSize 個の要素のみをコピー
// 有効長の範囲内のリスト要素のみを変換
int[] res = new int[queSize];
for (int i = 0, j = front; i < queSize; i++, j++) {
res[i] = nums[index(j)];
@@ -114,38 +116,36 @@ class ArrayDeque {
public class array_deque {
public static void main(String[] args) {
/* 両端キューを初期化 */
int capacity = 10;
ArrayDeque deque = new ArrayDeque(capacity);
/* 末尾エンキュー */
ArrayDeque deque = new ArrayDeque(10);
deque.pushLast(3);
deque.pushLast(2);
deque.pushLast(5);
System.out.println("末尾エンキュー後 deque = " + Arrays.toString(deque.toArray()));
System.out.println("双方向キュー deque = " + Arrays.toString(deque.toArray()));
/* 先頭エンキュー */
deque.pushFirst(4);
deque.pushFirst(1);
System.out.println("先頭エンキュー後 deque = " + Arrays.toString(deque.toArray()));
/* 要素へのアクセス */
/* 要素にアクセス */
int peekFirst = deque.peekFirst();
System.out.println("先頭要素 peekFirst = " + peekFirst);
int peekLast = deque.peekLast();
System.out.println("末尾要素 peekLast = " + peekLast);
/* 要素デキュー */
int popFirst = deque.popFirst();
System.out.println("先頭デキュー要素 = " + popFirst + "、先頭デキュー後 deque = " + Arrays.toString(deque.toArray()));
/* 要素をエンキュー */
deque.pushLast(4);
System.out.println("要素 4 を末尾にエンキューした後の deque = " + Arrays.toString(deque.toArray()));
deque.pushFirst(1);
System.out.println("要素 1 を先頭にエンキューした後の deque = " + Arrays.toString(deque.toArray()));
/* 要素をデキュー */
int popLast = deque.popLast();
System.out.println("末尾デキュー要素 = " + popLast + "、末尾デキュー後 deque = " + Arrays.toString(deque.toArray()));
System.out.println("末尾からデキューした要素 = " + popLast + "、末尾からデキューした後の deque = " + Arrays.toString(deque.toArray()));
int popFirst = deque.popFirst();
System.out.println("先頭からデキューした要素 = " + popFirst + "、先頭からデキューした後の deque = " + Arrays.toString(deque.toArray()));
/* 両端キューの長さを取得 */
int size = deque.size();
System.out.println("両端キューの長さ size = " + size);
System.out.println("双方向キューの長さ size = " + size);
/* 両端キューが空かどうかを判定 */
boolean isEmpty = deque.isEmpty();
System.out.println("両端キューが空か = " + isEmpty);
System.out.println("双方向キューが空かどうか = " + isEmpty);
}
}
}

37
ja/codes/java/chapter_stack_and_queue/array_queue.java
View File

@@ -8,10 +8,10 @@ package chapter_stack_and_queue;
import java.util.*;
/* 配列に基づくキュークラス */
/* 循環配列ベースのキュー */
class ArrayQueue {
private int[] nums; // 要素を格納する配列
private int front; // キューヘッドポインタ、最初の要素を指す
private int[] nums; // キュー要素を格納する配列
private int front; // 先頭ポインタ。先頭要素を指す
private int queSize; // キューの長さ
public ArrayQueue(int capacity) {
@@ -37,13 +37,13 @@ class ArrayQueue {
/* エンキュー */
public void push(int num) {
if (queSize == capacity()) {
System.out.println("キューが満杯です");
System.out.println("キューは満杯です");
return;
}
// リアポインタを計算：front + queSize
// モジュロ操作により rear が配列の長さを超えることを回避
// 末尾ポインタを計算し、末尾インデックス + 1 を指す
// 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする
int rear = (front + queSize) % capacity();
// 要素をキューリアに追加
// num をキュー末尾に追加
nums[rear] = num;
queSize++;
}
@@ -51,13 +51,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 IndexOutOfBoundsException();
@@ -66,7 +66,7 @@ class ArrayQueue {
/* 配列を返す */
public int[] toArray() {
// front から開始して queSize 個の要素のみをコピー
// 有効長の範囲内のリスト要素のみを変換
int[] res = new int[queSize];
for (int i = 0, j = front; i < queSize; i++, j++) {
res[i] = nums[j % capacity()];
@@ -89,26 +89,27 @@ public class array_queue {
queue.push(4);
System.out.println("キュー queue = " + Arrays.toString(queue.toArray()));
/* キューヘッド要素にアクセス */
/* キュー先頭の要素にアクセス */
int peek = queue.peek();
System.out.println("キューヘッド要素 peek = " + peek);
System.out.println("先頭要素 peek = " + peek);
/* 要素をデキュー */
int pop = queue.pop();
System.out.println("デキューした要素 = " + pop + "、デキュー後 " + Arrays.toString(queue.toArray()));
System.out.println("デキューした要素 pop = " + pop + "、デキュー後の queue = " + Arrays.toString(queue.toArray()));
/* キューの長さを取得 */
int size = queue.size();
System.out.println("キューの長さ size = " + size);
/* 空かどうかを判定 */
/* キューが空かどうかを判定 */
boolean isEmpty = queue.isEmpty();
System.out.println("キューが空か = " + isEmpty);
System.out.println("キューが空かどうか = " + isEmpty);
/* 連続エンキューのテスト */
/* 循環配列をテストする */
for (int i = 0; i < 10; i++) {
queue.push(i);
queue.pop();
System.out.println("第 " + i + " ラウンドのエンキュー + デキュー後の queue = " + Arrays.toString(queue.toArray()));
}
System.out.println("連続エンキュー後 queue = " + Arrays.toString(queue.toArray()));
}
}
}

14
ja/codes/java/chapter_stack_and_queue/array_stack.java
View File

@@ -8,12 +8,12 @@ package chapter_stack_and_queue;
import java.util.*;
/* 配列に基づくスタッククラス */
/* 配列ベースのスタック */
class ArrayStack {
private ArrayList<Integer> stack;
public ArrayStack() {
// リスト（動的配列）を初期化
// リスト（動的配列）を初期化する
stack = new ArrayList<>();
}
@@ -39,7 +39,7 @@ class ArrayStack {
return stack.remove(size() - 1);
}
/* スタックトップ要素にアクセス */
/* スタックトップの要素にアクセス */
public int peek() {
if (isEmpty())
throw new IndexOutOfBoundsException();
@@ -65,13 +65,13 @@ public class array_stack {
stack.push(4);
System.out.println("スタック stack = " + Arrays.toString(stack.toArray()));
/* スタックトップ要素にアクセス */
/* スタックトップの要素にアクセス */
int peek = stack.peek();
System.out.println("スタックトップ要素 peek = " + peek);
/* 要素をポップ */
int pop = stack.pop();
System.out.println("ポップした要素 = " + pop + "、ポップ後 " + Arrays.toString(stack.toArray()));
System.out.println("ポップした要素 pop = " + pop + "、ポップ後の stack = " + Arrays.toString(stack.toArray()));
/* スタックの長さを取得 */
int size = stack.size();
@@ -79,6 +79,6 @@ public class array_stack {
/* 空かどうかを判定 */
boolean isEmpty = stack.isEmpty();
System.out.println("スタックが空か = " + isEmpty);
System.out.println("スタックが空かどうか = " + isEmpty);
}
}
}

22
ja/codes/java/chapter_stack_and_queue/deque.java
View File

@@ -15,32 +15,32 @@ public class deque {
deque.offerLast(3);
deque.offerLast(2);
deque.offerLast(5);
System.out.println("両端キュー deque = " + deque);
System.out.println("双方向キュー deque = " + deque);
/* 要素へのアクセス */
/* 要素にアクセス */
int peekFirst = deque.peekFirst();
System.out.println("先頭要素 peekFirst = " + peekFirst);
int peekLast = deque.peekLast();
System.out.println("末尾要素 peekLast = " + peekLast);
/* 要素のエンキュー */
/* 要素をエンキュー */
deque.offerLast(4);
System.out.println("要素4を末尾にエンキュー、deque = " + deque);
System.out.println("要素 4 を末尾にエンキューした後の deque = " + deque);
deque.offerFirst(1);
System.out.println("要素1を先頭にエンキュー、deque = " + deque);
System.out.println("要素 1 を先頭にエンキューした後の deque = " + deque);
/* 要素のデキュー */
/* 要素をデキュー */
int popLast = deque.pollLast();
System.out.println("両端キュー末尾要素 = " + popLast + "、末尾からデキュー後 " + deque);
System.out.println("末尾からデキューした要素 = " + popLast + "、末尾からデキューした後の deque = " + deque);
int popFirst = deque.pollFirst();
System.out.println("両端キュー先頭要素 = " + popFirst + "、先頭からデキュー後 " + deque);
System.out.println("先頭からデキューした要素 = " + popFirst + "、先頭からデキューした後の deque = " + deque);
/* 両端キューの長さを取得 */
int size = deque.size();
System.out.println("両端キューの長さ size = " + size);
System.out.println("双方向キューの長さ size = " + size);
/* 両端キューが空かどうかを判定 */
boolean isEmpty = deque.isEmpty();
System.out.println("両端キューが空か = " + isEmpty);
System.out.println("双方向キューが空かどうか = " + isEmpty);
}
}
}

83
ja/codes/java/chapter_stack_and_queue/linkedlist_deque.java
View File

@@ -12,7 +12,7 @@ import java.util.*;
class ListNode {
int val; // ノード値
ListNode next; // 後続ノードへの参照
ListNode prev; // 前任ノードへの参照
ListNode prev; // 前駆ノードへの参照
ListNode(int val) {
this.val = val;
@@ -20,7 +20,7 @@ class ListNode {
}
}
/* 双方向連結リストに基づく両端キュークラス */
/* 双方向連結リストベースの両端キュー */
class LinkedListDeque {
private ListNode front, rear; // 先頭ノード front、末尾ノード rear
private int queSize = 0; // 両端キューの長さ
@@ -42,31 +42,31 @@ class LinkedListDeque {
/* エンキュー操作 */
private void push(int num, boolean isFront) {
ListNode node = new ListNode(num);
// リストが空の場合、front と rear の両方を node に指す
// 連結リストが空なら、front と rear の両方を node に向ける
if (isEmpty())
front = rear = node;
// 先頭エンキュー操作
// 先頭へのエンキュー操作
else if (isFront) {
// node をリストの先頭に追加
// node を連結リストの先頭に追加
front.prev = node;
node.next = front;
front = node; // front を更新
// 末尾エンキュー操作
front = node; // 先頭ノードを更新する
// 末尾へのエンキュー操作
} else {
// node をリストの末尾に追加
// node を連結リストの末尾に追加
rear.next = node;
node.prev = rear;
rear = node; // rear を更新
rear = node; // 末尾ノードを更新する
}
queSize++; // 長さを更新
queSize++; // キューの長さを更新
}
/* 先頭エンキュー */
/* キュー先頭にエンキュー */
public void pushFirst(int num) {
push(num, true);
}
/* 末尾エンキュー */
/* キュー末尾にエンキュー */
public void pushLast(int num) {
push(num, false);
}
@@ -76,56 +76,56 @@ class LinkedListDeque {
if (isEmpty())
throw new IndexOutOfBoundsException();
int val;
// 先頭デキュー操作
// キュー先頭からの取り出し
if (isFront) {
val = front.val; // 一時的に先頭ノード値を保存
// 次のノードを削除
val = front.val; // 先頭ノードの値を一時保存
// 先頭ノードを削除
ListNode fNext = front.next;
if (fNext != null) {
fNext.prev = null;
front.next = null;
}
front = fNext; // front を更新
// 末尾デキュー操作
front = fNext; // 先頭ノードを更新する
// キュー末尾からの取り出し
} else {
val = rear.val; // 一時的に末尾ノード値を保存
// 前のノードを削除
val = rear.val; // 末尾ノードの値を一時保存
// 末尾ノードを削除
ListNode rPrev = rear.prev;
if (rPrev != null) {
rPrev.next = null;
rear.prev = null;
}
rear = rPrev; // rear を更新
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 IndexOutOfBoundsException();
return front.val;
}
/* 末尾要素にアクセス */
/* キュー末尾の要素にアクセス */
public int peekLast() {
if (isEmpty())
throw new IndexOutOfBoundsException();
return rear.val;
}
/* 配列を返す */
/* 出力用の配列を返す */
public int[] toArray() {
ListNode node = front;
int[] res = new int[size()];
@@ -141,36 +141,35 @@ public class linkedlist_deque {
public static void main(String[] args) {
/* 両端キューを初期化 */
LinkedListDeque deque = new LinkedListDeque();
/* 末尾エンキュー */
deque.pushLast(3);
deque.pushLast(2);
deque.pushLast(5);
System.out.println("末尾エンキュー後 deque = " + Arrays.toString(deque.toArray()));
System.out.println("双方向キュー deque = " + Arrays.toString(deque.toArray()));
/* 先頭エンキュー */
deque.pushFirst(4);
deque.pushFirst(1);
System.out.println("先頭エンキュー後 deque = " + Arrays.toString(deque.toArray()));
/* 要素へのアクセス */
/* 要素にアクセス */
int peekFirst = deque.peekFirst();
System.out.println("先頭要素 peekFirst = " + peekFirst);
int peekLast = deque.peekLast();
System.out.println("末尾要素 peekLast = " + peekLast);
/* 要素デキュー */
int popFirst = deque.popFirst();
System.out.println("先頭デキュー要素 = " + popFirst + "、先頭デキュー後 deque = " + Arrays.toString(deque.toArray()));
/* 要素をエンキュー */
deque.pushLast(4);
System.out.println("要素 4 を末尾にエンキューした後の deque = " + Arrays.toString(deque.toArray()));
deque.pushFirst(1);
System.out.println("要素 1 を先頭にエンキューした後の deque = " + Arrays.toString(deque.toArray()));
/* 要素をデキュー */
int popLast = deque.popLast();
System.out.println("末尾デキュー要素 = " + popLast + "、末尾デキュー後 deque = " + Arrays.toString(deque.toArray()));
System.out.println("末尾からデキューした要素 = " + popLast + "、末尾からデキューした後の deque = " + Arrays.toString(deque.toArray()));
int popFirst = deque.popFirst();
System.out.println("先頭からデキューした要素 = " + popFirst + "、先頭からデキューした後の deque = " + Arrays.toString(deque.toArray()));
/* 両端キューの長さを取得 */
int size = deque.size();
System.out.println("両端キューの長さ size = " + size);
System.out.println("双方向キューの長さ size = " + size);
/* 両端キューが空かどうかを判定 */
boolean isEmpty = deque.isEmpty();
System.out.println("両端キューが空か = " + isEmpty);
System.out.println("双方向キューが空かどうか = " + isEmpty);
}
}
}

18
ja/codes/java/chapter_stack_and_queue/linkedlist_queue.java
View File

@@ -8,7 +8,7 @@ package chapter_stack_and_queue;
import java.util.*;
/* 連結リストに基づくキュークラス */
/* 連結リストベースのキュー */
class LinkedListQueue {
private ListNode front, rear; // 先頭ノード front、末尾ノード rear
private int queSize = 0;
@@ -32,11 +32,11 @@ class LinkedListQueue {
public void push(int num) {
// 末尾ノードの後ろに num を追加
ListNode node = new ListNode(num);
// キューが空の場合、先頭と末尾ノードの両方をそのノードにポイント
// キューが空なら、先頭・末尾ノードをともにそのノードに設定
if (front == null) {
front = node;
rear = node;
// キューが空でない場合、そのノードを末尾ノードの後ろに追加
// キューが空でなければ、そのノードを末尾ノードの後ろに追加
} else {
rear.next = node;
rear = node;
@@ -53,14 +53,14 @@ class LinkedListQueue {
return num;
}
/* 先頭要素にアクセス */
/* キュー先頭の要素にアクセス */
public int peek() {
if (isEmpty())
throw new IndexOutOfBoundsException();
return front.val;
}
/* 連結リストを配列に変換して返す */
/* 連結リストを Array に変換して返す */
public int[] toArray() {
ListNode node = front;
int[] res = new int[size()];
@@ -85,13 +85,13 @@ public class linkedlist_queue {
queue.push(4);
System.out.println("キュー queue = " + Arrays.toString(queue.toArray()));
/* 先頭要素にアクセス */
/* キュー先頭の要素にアクセス */
int peek = queue.peek();
System.out.println("先頭要素 peek = " + peek);
/* 要素をデキュー */
int pop = queue.pop();
System.out.println("デキューした要素 = " + pop + "、デキュー後 " + Arrays.toString(queue.toArray()));
System.out.println("デキューした要素 pop = " + pop + "、デキュー後の queue = " + Arrays.toString(queue.toArray()));
/* キューの長さを取得 */
int size = queue.size();
@@ -99,6 +99,6 @@ public class linkedlist_queue {
/* キューが空かどうかを判定 */
boolean isEmpty = queue.isEmpty();
System.out.println("キューが空か = " + isEmpty);
System.out.println("キューが空かどうか = " + isEmpty);
}
}
}

14
ja/codes/java/chapter_stack_and_queue/linkedlist_stack.java
View File

@@ -9,9 +9,9 @@ package chapter_stack_and_queue;
import java.util.*;
import utils.*;
/* 連結リストに基づくスタッククラス */
/* 連結リストベースのスタック */
class LinkedListStack {
private ListNode stackPeek; // ヘッドノードをスタックトップとして使用
private ListNode stackPeek; // 先頭ノードをスタックトップとする
private int stkSize = 0; // スタックの長さ
public LinkedListStack() {
@@ -44,7 +44,7 @@ class LinkedListStack {
return num;
}
/* スタックトップ要素にアクセス */
/* スタックトップの要素にアクセス */
public int peek() {
if (isEmpty())
throw new IndexOutOfBoundsException();
@@ -76,13 +76,13 @@ public class linkedlist_stack {
stack.push(4);
System.out.println("スタック stack = " + Arrays.toString(stack.toArray()));
/* スタックトップ要素にアクセス */
/* スタックトップの要素にアクセス */
int peek = stack.peek();
System.out.println("スタックトップ要素 peek = " + peek);
/* 要素をポップ */
int pop = stack.pop();
System.out.println("ポップした要素 = " + pop + "、ポップ後 " + Arrays.toString(stack.toArray()));
System.out.println("ポップした要素 pop = " + pop + "、ポップ後の stack = " + Arrays.toString(stack.toArray()));
/* スタックの長さを取得 */
int size = stack.size();
@@ -90,6 +90,6 @@ public class linkedlist_stack {
/* 空かどうかを判定 */
boolean isEmpty = stack.isEmpty();
System.out.println("スタックが空か = " + isEmpty);
System.out.println("スタックが空かどうか = " + isEmpty);
}
}
}

8
ja/codes/java/chapter_stack_and_queue/queue.java
View File

@@ -21,13 +21,13 @@ public class queue {
queue.offer(4);
System.out.println("キュー queue = " + queue);
/* 先頭要素にアクセス */
/* キュー先頭の要素にアクセス */
int peek = queue.peek();
System.out.println("先頭要素 peek = " + peek);
/* 要素をデキュー */
int pop = queue.poll();
System.out.println("デキューした要素 = " + pop + "、デキュー後 " + queue);
System.out.println("デキューした要素 pop = " + pop + "、デキュー後の queue = " + queue);
/* キューの長さを取得 */
int size = queue.size();
@@ -35,6 +35,6 @@ public class queue {
/* キューが空かどうかを判定 */
boolean isEmpty = queue.isEmpty();
System.out.println("キューが空か = " + isEmpty);
System.out.println("キューが空かどうか = " + isEmpty);
}
}
}

8
ja/codes/java/chapter_stack_and_queue/stack.java
View File

@@ -21,13 +21,13 @@ public class stack {
stack.push(4);
System.out.println("スタック stack = " + stack);
/* スタックトップ要素にアクセス */
/* スタックトップの要素にアクセス */
int peek = stack.peek();
System.out.println("スタックトップ要素 peek = " + peek);
/* 要素をポップ */
int pop = stack.pop();
System.out.println("ポップした要素 = " + pop + "、ポップ後 " + stack);
System.out.println("ポップした要素 pop = " + pop + "、ポップ後の stack = " + stack);
/* スタックの長さを取得 */
int size = stack.size();
@@ -35,6 +35,6 @@ public class stack {
/* 空かどうかを判定 */
boolean isEmpty = stack.isEmpty();
System.out.println("スタックが空か = " + isEmpty);
System.out.println("スタックが空かどうか = " + isEmpty);
}
}
}