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

1
ja/codes/java/.gitignore vendored Normal file
View File

@@ -0,0 +1 @@
build

52
ja/codes/java/chapter_array_and_linkedlist/array.java
View File

@@ -10,20 +10,20 @@ import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
public class array {
/* 要素へのランダムアクセス */
/* 要素へランダムアクセス */
static int randomAccess(int[] nums) {
// 区間 [0, nums.length) からランダムに数を選択
// 区間 [0, nums.length) からランダムに 1 つの数を選ぶ
int randomIndex = ThreadLocalRandom.current().nextInt(0, nums.length);
// ランダム要素を取得して返す
// ランダムな要素を取得して返す
int randomNum = nums[randomIndex];
return randomNum;
}
/* 配列長の拡張 */
/* 配列長を拡張する */
static int[] extend(int[] nums, int enlarge) {
// 拡張された長さの配列を初期化
// 拡張後の長さを持つ配列を初期化する
int[] res = new int[nums.length + enlarge];
// 元の配列のすべての要素を新しい配列にコピー
// 元の配列の全要素を新しい配列にコピー
for (int i = 0; i < nums.length; i++) {
res[i] = nums[i];
}
@@ -31,19 +31,19 @@ public class array {
return res;
}
/* `index` に要素 num を挿入 */
/* 配列の index 番目に要素 num を挿入 */
static void insert(int[] nums, int num, int index) {
// `index` より後のすべての要素を1つ後ろに移動
// インデックス index 以降の全要素を 1 つ後ろへ移動する
for (int i = nums.length - 1; i > index; i--) {
nums[i] = nums[i - 1];
}
// index の要素に num を代入
// index の要素に num を代入する
nums[index] = num;
}
/* `index` の要素を削除 */
/* index の要素を削除する */
static void remove(int[] nums, int index) {
// `index` より後のすべての要素を1つ前に移動
// インデックス index より後ろの全要素を 1 つ前へ移動する
for (int i = index; i < nums.length - 1; i++) {
nums[i] = nums[i + 1];
}
@@ -52,17 +52,17 @@ public class array {
/* 配列を走査 */
static void traverse(int[] nums) {
int count = 0;
// インデックスによる配列の走査
// インデックスで配列を走査
for (int i = 0; i < nums.length; i++) {
count += nums[i];
}
// 配列要素の走査
// 配列要素を直接走査
for (int num : nums) {
count += num;
}
}
/* 配列内で指定された要素を検索 */
/* 配列内で指定要素を探す */
static int find(int[] nums, int target) {
for (int i = 0; i < nums.length; i++) {
if (nums[i] == target)
@@ -71,7 +71,7 @@ public class array {
return -1;
}
/* ドライバーコード */
/* Driver Code */
public static void main(String[] args) {
/* 配列を初期化 */
int[] arr = new int[5];
@@ -81,25 +81,25 @@ public class array {
/* ランダムアクセス */
int randomNum = randomAccess(nums);
System.out.println("nums からランダム要素を取得 = " + randomNum);
System.out.println("nums からランダムな要素を取得 " + randomNum);
/* 長さの拡張 */
/* 長さを拡張 */
nums = extend(nums, 3);
System.out.println("配列の長さを8に拡張し、nums = " + Arrays.toString(nums));
System.out.println("配列の長さを 8 に拡張し、nums = " + Arrays.toString(nums));
/* 要素の挿入 */
/* 要素を挿入する */
insert(nums, 6, 3);
System.out.println("インデックス3に数値6を挿入し、nums = " + Arrays.toString(nums));
System.out.println("インデックス 3 に数値 6 を挿入し、nums = " + Arrays.toString(nums));
/* 要素の削除 */
/* 要素を削除 */
remove(nums, 2);
System.out.println("インデックス2の要素を削除し、nums = " + Arrays.toString(nums));
System.out.println("インデックス 2 の要素を削除し、nums = " + Arrays.toString(nums));
/* 配列の走査 */
/* 配列を走査 */
traverse(nums);
/* 要素の検索 */
/* 要素を探索する */
int index = find(nums, 3);
System.out.println("nums で要素3を見つけ、インデックス = " + index);
System.out.println("nums 内で要素 3 を検索し、インデックス = " + index);
}
}
}

30
ja/codes/java/chapter_array_and_linkedlist/linked_list.java
View File

@@ -9,14 +9,14 @@ package chapter_array_and_linkedlist;
import utils.*;
public class linked_list {
/* 連結リストでノード n0 の後にノード P を挿入 */
/* 連結リストでノード n0 の後ろにノード P を挿入する */
static void insert(ListNode n0, ListNode P) {
ListNode n1 = n0.next;
P.next = n1;
n0.next = P;
}
/* 連結リストでノード n0 の後の最初のノードを削除 */
/* 連結リストでノード n0 の直後のノードを削除する */
static void remove(ListNode n0) {
if (n0.next == null)
return;
@@ -26,7 +26,7 @@ public class linked_list {
n0.next = n1;
}
/* 連結リストの `index` のノードにアクセス */
/* 連結リスト内で index 番目のノードにアクセス */
static ListNode access(ListNode head, int index) {
for (int i = 0; i < index; i++) {
if (head == null)
@@ -36,7 +36,7 @@ public class linked_list {
return head;
}
/* 連結リストで値 target を持つ最初のノードを検索 */
/* 連結リストで値が target の最初のノードを探す */
static int find(ListNode head, int target) {
int index = 0;
while (head != null) {
@@ -48,39 +48,39 @@ public class linked_list {
return -1;
}
/* ドライバーコード */
/* Driver Code */
public static void main(String[] args) {
/* 連結リストの初期化 */
/* 連結リストを初期化 */
// 各ノードを初期化
ListNode n0 = new ListNode(1);
ListNode n1 = new ListNode(3);
ListNode n2 = new ListNode(2);
ListNode n3 = new ListNode(5);
ListNode n4 = new ListNode(4);
// ノード間の参照を構築
// ノード間の参照を構築する
n0.next = n1;
n1.next = n2;
n2.next = n3;
n3.next = n4;
System.out.println("初期化された連結リストは");
System.out.println("初期化した連結リストは");
PrintUtil.printLinkedList(n0);
/* ノードの挿入 */
/* ノードを挿入 */
insert(n0, new ListNode(0));
System.out.println("ノード挿入後の連結リストは");
PrintUtil.printLinkedList(n0);
/* ノードの削除 */
/* ノードを削除 */
remove(n0);
System.out.println("ノード削除後の連結リストは");
PrintUtil.printLinkedList(n0);
/* ノードへのアクセス */
/* ノードにアクセス */
ListNode node = access(n0, 3);
System.out.println("連結リストのインデックス3のノードの値 = " + node.val);
System.out.println("連結リストのインデックス 3 にあるノードの値 = " + node.val);
/* ノードの検索 */
/* ノードを探索 */
int index = find(n0, 2);
System.out.println("連結リストで値2を持つノードのインデックス = " + index);
System.out.println("連結リスト内で値 2 のノードのインデックス = " + index);
}
}
}

38
ja/codes/java/chapter_array_and_linkedlist/list.java
View File

@@ -10,23 +10,23 @@ import java.util.*;
public class list {
public static void main(String[] args) {
/* リストの初期化 */
// 配列の要素型は Integer[]、int のラッパークラス
/* リストを初期化 */
// 配列の要素型は `int[]` のラッパークラスである `Integer[]` である点に注意
Integer[] numbers = new Integer[] { 1, 3, 2, 5, 4 };
List<Integer> nums = new ArrayList<>(Arrays.asList(numbers));
System.out.println("リスト nums = " + nums);
/* 要素へのアクセス */
/* 要素にアクセス */
int num = nums.get(1);
System.out.println("インデックス1の要素にアクセス、取得した num = " + num);
System.out.println("インデックス 1 の要素にアクセスし、num = " + num);
/* 要素の更新 */
/* 要素を更新 */
nums.set(1, 0);
System.out.println("インデックス1の要素を0に更新し、nums = " + nums);
System.out.println("インデックス 1 の要素を 0 に更新し、nums = " + nums);
/* リストのクリア */
/* リストを空にする */
nums.clear();
System.out.println("リストをクリアした後、nums = " + nums);
System.out.println("リストを空にした後 nums = " + nums);
/* 末尾に要素を追加 */
nums.add(1);
@@ -34,33 +34,33 @@ public class list {
nums.add(2);
nums.add(5);
nums.add(4);
System.out.println("要素を追加した後、nums = " + nums);
System.out.println("要素追加後 nums = " + nums);
/* 中間に要素を挿入 */
nums.add(3, 6);
System.out.println("インデックス3に数値6を挿入し、nums = " + nums);
System.out.println("インデックス 3 に数値 6 を挿入し、nums = " + nums);
/* 要素の削除 */
/* 要素を削除 */
nums.remove(3);
System.out.println("インデックス3の要素を削除し、nums = " + nums);
System.out.println("インデックス 3 の要素を削除し、nums = " + nums);
/* インデックスによるリストの走査 */
/* インデックスでリストを走査 */
int count = 0;
for (int i = 0; i < nums.size(); i++) {
count += nums.get(i);
}
/* リスト要素の走査 */
/* リスト要素を直接走査 */
for (int x : nums) {
count += x;
}
/* 2つのリストの連結 */
/* 2 つのリストを連結する */
List<Integer> nums1 = new ArrayList<>(Arrays.asList(new Integer[] { 6, 8, 7, 10, 9 }));
nums.addAll(nums1);
System.out.println("リスト nums1 を nums に連結し、nums = " + nums);
System.out.println("リスト nums1 を nums の後ろに連結し、nums = " + nums);
/* リストのソート */
/* リストをソート */
Collections.sort(nums);
System.out.println("リストをソートした後、nums = " + nums);
System.out.println("リストをソートした後 nums = " + nums);
}
}
}

64
ja/codes/java/chapter_array_and_linkedlist/my_list.java
View File

@@ -12,33 +12,33 @@ import java.util.*;
class MyList {
private int[] arr; // 配列（リスト要素を格納）
private int capacity = 10; // リスト容量
private int size = 0; // リスト長（現在の要素数）
private int extendRatio = 2; // リストの各拡張倍率
private int size = 0; // リストの長さ（現在の要素数）
private int extendRatio = 2; // リスト拡張時の増加倍率
/* コンストラクタ */
public MyList() {
arr = new int[capacity];
}
/* リスト長を取得（現在の要素数） */
/* リストの長さを取得（現在の要素数） */
public int size() {
return size;
}
/* リスト容量を取得 */
/* リスト容量を取得する */
public int capacity() {
return capacity;
}
/* 要素へのアクセス */
/* 要素にアクセス */
public int get(int index) {
// インデックスが範囲外の場合、以下のように例外をスロー
// インデックスが範囲外なら例外を送出する。以下同様
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException("インデックスが範囲外です");
return arr[index];
}
/* 要素の更新 */
/* 要素を更新 */
public void set(int index, int num) {
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException("インデックスが範囲外です");
@@ -47,7 +47,7 @@ class MyList {
/* 末尾に要素を追加 */
public void add(int num) {
// 要素数が容量を超える場合、拡張メカニズムを実行
// 要素数が容量を超えると、拡張機構が発動する
if (size == capacity())
extendCapacity();
arr[size] = num;
@@ -59,10 +59,10 @@ class MyList {
public void insert(int index, int num) {
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException("インデックスが範囲外です");
// 要素数が容量を超える場合、拡張メカニズムを実行
// 要素数が容量を超えると、拡張機構が発動する
if (size == capacity())
extendCapacity();
// `index` より後のすべての要素を1つ後ろに移動
// index 以降の要素をすべて 1 つ後ろへずらす
for (int j = size - 1; j >= index; j--) {
arr[j + 1] = arr[j];
}
@@ -71,12 +71,12 @@ class MyList {
size++;
}
/* 要素の削除 */
/* 要素を削除 */
public int remove(int index) {
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException("インデックスが範囲外です");
int num = arr[index];
// `index` より後のすべての要素を1つ前に移動
// インデックス index より後の要素をすべて 1 つ前に移動する
for (int j = index; j < size - 1; j++) {
arr[j] = arr[j + 1];
}
@@ -86,18 +86,18 @@ class MyList {
return num;
}
/* リストを拡張 */
/* リストの拡張 */
public void extendCapacity() {
// 元の配列の長さを extendRatio 倍した新しい配列を作成し、元の配列を新しい配列にコピー
// 元の配列の extendRatio 倍の長さを持つ新しい配列を作成し、元の配列をコピーする
arr = Arrays.copyOf(arr, capacity() * extendRatio);
// リスト容量を更新
// リストの容量を更新
capacity = arr.length;
}
/* リストを配列に変換 */
/* リストを配列に変換する */
public int[] toArray() {
int size = size();
// 有効な長さ範囲内の要素のみを変換
// 有効長の範囲内のリスト要素のみを変換
int[] arr = new int[size];
for (int i = 0; i < size; i++) {
arr[i] = get(i);
@@ -107,9 +107,9 @@ class MyList {
}
public class my_list {
/* ドライバーコード */
/* Driver Code */
public static void main(String[] args) {
/* リストの初期化 */
/* リストを初期化 */
MyList nums = new MyList();
/* 末尾に要素を追加 */
nums.add(1);
@@ -118,30 +118,30 @@ public class my_list {
nums.add(5);
nums.add(4);
System.out.println("リスト nums = " + Arrays.toString(nums.toArray()) +
", 容量 = " + nums.capacity() + ", 長さ = " + nums.size());
" 、容量 = " + nums.capacity() + " 、長さ = " + nums.size());
/* 中間に要素を挿入 */
nums.insert(3, 6);
System.out.println("インデックス3に数値6を挿入し、nums = " + Arrays.toString(nums.toArray()));
System.out.println("インデックス 3 に数値 6 を挿入すると、nums = " + Arrays.toString(nums.toArray()));
/* 要素の削除 */
/* 要素を削除 */
nums.remove(3);
System.out.println("インデックス3の要素を削除し、nums = " + Arrays.toString(nums.toArray()));
System.out.println("インデックス 3 の要素を削除すると、nums = " + Arrays.toString(nums.toArray()));
/* 要素へのアクセス */
/* 要素にアクセス */
int num = nums.get(1);
System.out.println("インデックス1の要素にアクセス、取得した num = " + num);
System.out.println("インデックス 1 の要素にアクセスし、num = " + num);
/* 要素の更新 */
/* 要素を更新 */
nums.set(1, 0);
System.out.println("インデックス1の要素を0に更新し、nums = " + Arrays.toString(nums.toArray()));
System.out.println("インデックス 1 の要素を 0 に更新すると、nums = " + Arrays.toString(nums.toArray()));
/* 拡張メカニズムのテスト */
/* 拡張機構をテストする */
for (int i = 0; i < 10; i++) {
// i = 5 の時、リスト長がリスト容量を超え、この時点で拡張メカニズムが実行される
// i = 5 のとき、リスト長が容量を超えるため、この時点で拡張機構が発動する
nums.add(i);
}
System.out.println("拡張後、リスト nums = " + Arrays.toString(nums.toArray()) +
", 容量 = " + nums.capacity() + ", 長さ = " + nums.size());
System.out.println("拡張後のリスト nums = " + Arrays.toString(nums.toArray()) +
" 、容量 = " + nums.capacity() + " 、長さ = " + nums.size());
}
}
}

30
ja/codes/java/chapter_backtracking/n_queens.java
View File

@@ -9,10 +9,10 @@ package chapter_backtracking;
import java.util.*;
public class n_queens {
/* バックトラッキングアルゴリズム：n クイーン */
/* バックトラッキング：N クイーン */
public static void backtrack(int row, int n, List<List<String>> state, List<List<List<String>>> res,
boolean[] cols, boolean[] diags1, boolean[] diags2) {
// すべての行が配置されたら、解を記録
// すべての行への配置が完了したら、解を記録する
if (row == n) {
List<List<String>> copyState = new ArrayList<>();
for (List<String> sRow : state) {
@@ -23,26 +23,26 @@ public class n_queens {
}
// すべての列を走査
for (int col = 0; col < n; col++) {
// セルに対応する主対角線と副対角線を計算
// このマスに対応する主対角線と副対角線を計算
int diag1 = row - col + n - 1;
int diag2 = row + col;
// 剪定：セルの列、主対角線、副対角線にクイーンを配置することを許可しない
// 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない
if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
// 試行：セルにクイーンを配置
// 試行：そのマスにクイーンを置く
state.get(row).set(col, "Q");
cols[col] = diags1[diag1] = diags2[diag2] = true;
// 次の行を配置
// 次の行に配置する
backtrack(row + 1, n, state, res, cols, diags1, diags2);
// 回退：セルを空のスポットに復元
// 戻す：そのマスを空きマスに戻す
state.get(row).set(col, "#");
cols[col] = diags1[diag1] = diags2[diag2] = false;
}
}
}
/* n クイーンを解く */
/* N クイーンを解く */
public static List<List<List<String>>> nQueens(int n) {
// n*n サイズのチェスボードを初期化、'Q' はクイーンを表し、'#' は空のスポットを表す
// n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す
List<List<String>> state = new ArrayList<>();
for (int i = 0; i < n; i++) {
List<String> row = new ArrayList<>();
@@ -51,9 +51,9 @@ public class n_queens {
}
state.add(row);
}
boolean[] cols = new boolean[n]; // クイーンのある列を記録
boolean[] diags1 = new boolean[2 * n - 1]; // クイーンのある主対角線を記録
boolean[] diags2 = new boolean[2 * n - 1]; // クイーンのある副対角線を記録
boolean[] cols = new boolean[n]; // 列にクイーンがあるか記録
boolean[] diags1 = new boolean[2 * n - 1]; // 主対角線にクイーンがあるかを記録
boolean[] diags2 = new boolean[2 * n - 1]; // 副対角線にクイーンがあるかを記録
List<List<List<String>>> res = new ArrayList<>();
backtrack(0, n, state, res, cols, diags1, diags2);
@@ -65,8 +65,8 @@ public class n_queens {
int n = 4;
List<List<List<String>>> res = nQueens(n);
System.out.println("チェスボードの次元を " + n + " として入力");
System.out.println("クイーン配置解の総数 = " + res.size());
System.out.println("盤面の縦横サイズは " + n);
System.out.println("クイーンの配置方法は全部で " + res.size() + " 通り");
for (List<List<String>> state : res) {
System.out.println("--------------------");
for (List<String> row : state) {
@@ -74,4 +74,4 @@ public class n_queens {
}
}
}
}
}

16
ja/codes/java/chapter_backtracking/permutations_i.java
View File

@@ -9,9 +9,9 @@ package chapter_backtracking;
import java.util.*;
public class permutations_i {
/* バックトラッキングアルゴリズム：順列 I */
/* バックトラッキング：順列 I */
public static void backtrack(List<Integer> state, int[] choices, boolean[] selected, List<List<Integer>> res) {
// 状態の長さが要素数と等しくなったら、解を記録
// 状態の長さが要素数に等しければ、解を記録
if (state.size() == choices.length) {
res.add(new ArrayList<Integer>(state));
return;
@@ -19,21 +19,21 @@ public class permutations_i {
// すべての選択肢を走査
for (int i = 0; i < choices.length; i++) {
int choice = choices[i];
// 剪定：要素の重複選択を許可しない
// 枝刈り：要素の重複選択を許可しない
if (!selected[i]) {
// 試行：選択を行い、状態を更新
// 試行: 選択を行い、状態を更新
selected[i] = true;
state.add(choice);
// 次のラウンドの選択に進む
// 次の選択へ進む
backtrack(state, choices, selected, res);
// 回退：選択を取り消し、前の状態に復元
// バックトラック：選択を取り消し、前の状態に戻す
selected[i] = false;
state.remove(state.size() - 1);
}
}
}
/* 順列 I */
/* 全順列 I */
static List<List<Integer>> permutationsI(int[] nums) {
List<List<Integer>> res = new ArrayList<List<Integer>>();
backtrack(new ArrayList<Integer>(), nums, new boolean[nums.length], res);
@@ -48,4 +48,4 @@ public class permutations_i {
System.out.println("入力配列 nums = " + Arrays.toString(nums));
System.out.println("すべての順列 res = " + res);
}
}
}

18
ja/codes/java/chapter_backtracking/permutations_ii.java
View File

@@ -9,9 +9,9 @@ package chapter_backtracking;
import java.util.*;
public class permutations_ii {
/* バックトラッキングアルゴリズム：順列 II */
/* バックトラッキング：順列 II */
static void backtrack(List<Integer> state, int[] choices, boolean[] selected, List<List<Integer>> res) {
// 状態の長さが要素数と等しくなったら、解を記録
// 状態の長さが要素数に等しければ、解を記録
if (state.size() == choices.length) {
res.add(new ArrayList<Integer>(state));
return;
@@ -20,22 +20,22 @@ public class permutations_ii {
Set<Integer> duplicated = new HashSet<Integer>();
for (int i = 0; i < choices.length; i++) {
int choice = choices[i];
// 剪定：要素の重複選択を許可せず、等しい要素の重複選択も許可しない
// 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない
if (!selected[i] && !duplicated.contains(choice)) {
// 試行：選択を行い、状態を更新
duplicated.add(choice); // 選択された要素値を記録
// 試行: 選択を行い、状態を更新
duplicated.add(choice); // 選択済みの要素値を記録
selected[i] = true;
state.add(choice);
// 次のラウンドの選択に進む
// 次の選択へ進む
backtrack(state, choices, selected, res);
// 回退：選択を取り消し、前の状態に復元
// バックトラック：選択を取り消し、前の状態に戻す
selected[i] = false;
state.remove(state.size() - 1);
}
}
}
/* 順列 II */
/* 全順列 II */
static List<List<Integer>> permutationsII(int[] nums) {
List<List<Integer>> res = new ArrayList<List<Integer>>();
backtrack(new ArrayList<Integer>(), nums, new boolean[nums.length], res);
@@ -50,4 +50,4 @@ public class permutations_ii {
System.out.println("入力配列 nums = " + Arrays.toString(nums));
System.out.println("すべての順列 res = " + res);
}
}
}

8
ja/codes/java/chapter_backtracking/preorder_traversal_i_compact.java
View File

@@ -12,7 +12,7 @@ import java.util.*;
public class preorder_traversal_i_compact {
static List<TreeNode> res;
/* 前順走査：例１ */
/* 前順走査：例題 1 */
static void preOrder(TreeNode root) {
if (root == null) {
return;
@@ -30,15 +30,15 @@ public class preorder_traversal_i_compact {
System.out.println("\n二分木を初期化");
PrintUtil.printTree(root);
// 前順走査
// 先行順走査
res = new ArrayList<>();
preOrder(root);
System.out.println("\n値7のノードをすべて出力");
System.out.println("\n値が 7 のノードをすべて出力");
List<Integer> vals = new ArrayList<>();
for (TreeNode node : res) {
vals.add(node.val);
}
System.out.println(vals);
}
}
}

12
ja/codes/java/chapter_backtracking/preorder_traversal_ii_compact.java
View File

@@ -13,12 +13,12 @@ public class preorder_traversal_ii_compact {
static List<TreeNode> path;
static List<List<TreeNode>> res;
/* 前順走査：例２ */
/* 前順走査：例題 2 */
static void preOrder(TreeNode root) {
if (root == null) {
return;
}
// 試行
// 試す
path.add(root);
if (root.val == 7) {
// 解を記録
@@ -26,7 +26,7 @@ public class preorder_traversal_ii_compact {
}
preOrder(root.left);
preOrder(root.right);
// 回退
// バックトラック
path.remove(path.size() - 1);
}
@@ -35,12 +35,12 @@ public class preorder_traversal_ii_compact {
System.out.println("\n二分木を初期化");
PrintUtil.printTree(root);
// 前順走査
// 先行順走査
path = new ArrayList<>();
res = new ArrayList<>();
preOrder(root);
System.out.println("\nルートからノード7までのすべてのパスを出力");
System.out.println("\n根ノードからノード 7 までのすべての経路を出力");
for (List<TreeNode> path : res) {
List<Integer> vals = new ArrayList<>();
for (TreeNode node : path) {
@@ -49,4 +49,4 @@ public class preorder_traversal_ii_compact {
System.out.println(vals);
}
}
}
}

14
ja/codes/java/chapter_backtracking/preorder_traversal_iii_compact.java
View File

@@ -13,13 +13,13 @@ public class preorder_traversal_iii_compact {
static List<TreeNode> path;
static List<List<TreeNode>> res;
/* 前順走査：例３ */
/* 前順走査：例題 3 */
static void preOrder(TreeNode root) {
// 剪定
// 枝刈り
if (root == null || root.val == 3) {
return;
}
// 試行
// 試す
path.add(root);
if (root.val == 7) {
// 解を記録
@@ -27,7 +27,7 @@ public class preorder_traversal_iii_compact {
}
preOrder(root.left);
preOrder(root.right);
// 回退
// バックトラック
path.remove(path.size() - 1);
}
@@ -36,12 +36,12 @@ public class preorder_traversal_iii_compact {
System.out.println("\n二分木を初期化");
PrintUtil.printTree(root);
// 前順走査
// 先行順走査
path = new ArrayList<>();
res = new ArrayList<>();
preOrder(root);
System.out.println("\nルートからノード7までのすべてのパスを出力、値3のノードは含まない");
System.out.println("\n根ノードからノード 7 までのすべての経路を出力し、経路には値が 3 のノードを含めない");
for (List<TreeNode> path : res) {
List<Integer> vals = new ArrayList<>();
for (TreeNode node : path) {
@@ -50,4 +50,4 @@ public class preorder_traversal_iii_compact {
System.out.println(vals);
}
}
}
}

22
ja/codes/java/chapter_backtracking/preorder_traversal_iii_template.java
View File

@@ -20,7 +20,7 @@ public class preorder_traversal_iii_template {
res.add(new ArrayList<>(state));
}
/* 現在の状態下で選択が合法かどうかを判定 */
/* 現在の状態で、この選択が有効かどうかを判定 */
static boolean isValid(List<TreeNode> state, TreeNode choice) {
return choice != null && choice.val != 3;
}
@@ -30,27 +30,27 @@ public class preorder_traversal_iii_template {
state.add(choice);
}
/* 状態を復元 */
/* 状態を元に戻す */
static void undoChoice(List<TreeNode> state, TreeNode choice) {
state.remove(state.size() - 1);
}
/* バックトラッキングアルゴリズム：例３ */
/* バックトラッキング：例題 3 */
static void backtrack(List<TreeNode> state, List<TreeNode> choices, List<List<TreeNode>> res) {
// 解かどうかをチェック
// 解かどうかを確認
if (isSolution(state)) {
// 解を記録
recordSolution(state, res);
}
// すべての選択肢を走査
for (TreeNode choice : choices) {
// 剪定：選択が合法かどうかをチェック
// 枝刈り：選択が妥当かを確認する
if (isValid(state, choice)) {
// 試行：選択を行い、状態を更新
// 試行: 選択を行い、状態を更新
makeChoice(state, choice);
// 次のラウンドの選択に進む
// 次の選択へ進む
backtrack(state, Arrays.asList(choice.left, choice.right), res);
// 回退：選択を取り消し、前の状態に復元
// バックトラック：選択を取り消し、前の状態に戻す
undoChoice(state, choice);
}
}
@@ -61,11 +61,11 @@ public class preorder_traversal_iii_template {
System.out.println("\n二分木を初期化");
PrintUtil.printTree(root);
// バックトラッキングアルゴリズム
// バックトラッキング法
List<List<TreeNode>> res = new ArrayList<>();
backtrack(new ArrayList<>(), Arrays.asList(root), res);
System.out.println("\nルートからノード7までのすべてのパスを出力、パスには値3のノードを含まないことが要求される");
System.out.println("\n根ノードからノード 7 までのすべての経路を出力し、経路に値が 3 のノードを含まないことを条件とする");
for (List<TreeNode> path : res) {
List<Integer> vals = new ArrayList<>();
for (TreeNode node : path) {
@@ -74,4 +74,4 @@ public class preorder_traversal_iii_template {
System.out.println(vals);
}
}
}
}

26
ja/codes/java/chapter_backtracking/subset_sum_i.java
View File

@@ -9,36 +9,36 @@ package chapter_backtracking;
import java.util.*;
public class subset_sum_i {
/* バックトラッキングアルゴリズム：部分集合和 I */
/* バックトラッキング：部分和 I */
static void backtrack(List<Integer> state, int target, int[] choices, int start, List<List<Integer>> res) {
// 部分集合の和がtargetと等しいとき、解を記録
// 部分集合の和が target に等しければ、解を記録
if (target == 0) {
res.add(new ArrayList<>(state));
return;
}
// すべての選択肢を走査
// 剪定二：startから走査を開始し、重複する部分集合の生成を回避
// 枝刈り 2: start から走査し、重複する部分集合の生成を避ける
for (int i = start; i < choices.length; i++) {
// 剪定一：部分集合の和がtargetを超えた場合、即座にループを終了
// 配列がソートされているため、後の要素はさらに大きく、部分集合の和は必ずtargetを超える
// 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する
// 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため
if (target - choices[i] < 0) {
break;
}
// 試行：選択を行い、target、startを更新
// 試す：選択を行い、target と start を更新
state.add(choices[i]);
// 次のラウンドの選択に進む
// 次の選択へ進む
backtrack(state, target - choices[i], choices, i, res);
// 回退：選択を取り消し、前の状態に復元
// バックトラック：選択を取り消し、前の状態に戻す
state.remove(state.size() - 1);
}
}
/* 部分集合和 I を解く */
/* 部分和 I を解く */
static List<List<Integer>> subsetSumI(int[] nums, int target) {
List<Integer> state = new ArrayList<>(); // 状態（部分集合）
Arrays.sort(nums); // nums をソート
int start = 0; // 走査の開始点
List<List<Integer>> res = new ArrayList<>(); // 結果リスト（部分集合リスト）
int start = 0; // 開始点を走査
List<List<Integer>> res = new ArrayList<>(); // 結果リスト（部分集合のリスト）
backtrack(state, target, nums, start, res);
return res;
}
@@ -50,6 +50,6 @@ public class subset_sum_i {
List<List<Integer>> res = subsetSumI(nums, target);
System.out.println("入力配列 nums = " + Arrays.toString(nums) + ", target = " + target);
System.out.println("和が " + target + " のすべての部分集合 res = " + res);
System.out.println("和が " + target + " に等しいすべての部分集合 res = " + res);
}
}
}

24
ja/codes/java/chapter_backtracking/subset_sum_i_naive.java
View File

@@ -9,33 +9,33 @@ package chapter_backtracking;
import java.util.*;
public class subset_sum_i_naive {
/* バックトラッキングアルゴリズム：部分集合和 I */
/* バックトラッキング：部分和 I */
static void backtrack(List<Integer> state, int target, int total, int[] choices, List<List<Integer>> res) {
// 部分集合の和がtargetと等しいとき、解を記録
// 部分集合の和が target に等しければ、解を記録
if (total == target) {
res.add(new ArrayList<>(state));
return;
}
// すべての選択肢を走査
for (int i = 0; i < choices.length; i++) {
// 剪定：部分集合の和がtargetを超えた場合、その選択をスキップ
// 枝刈り：部分和が target を超える場合はその選択をスキップする
if (total + choices[i] > target) {
continue;
}
// 試行：選択を行い、要素とtotalを更新
// 試行：選択を行い、要素と total を更新する
state.add(choices[i]);
// 次のラウンドの選択に進む
// 次の選択へ進む
backtrack(state, target, total + choices[i], choices, res);
// 回退：選択を取り消し、前の状態に復元
// バックトラック：選択を取り消し、前の状態に戻す
state.remove(state.size() - 1);
}
}
/* 部分集合和 I を解く（重複する部分集合を含む） */
/* 部分和 I を解く（重複部分集合を含む） */
static List<List<Integer>> subsetSumINaive(int[] nums, int target) {
List<Integer> state = new ArrayList<>(); // 状態（部分集合）
int total = 0; // 部分集合の和
List<List<Integer>> res = new ArrayList<>(); // 結果リスト（部分集合リスト）
int total = 0; // 部分和
List<List<Integer>> res = new ArrayList<>(); // 結果リスト（部分集合のリスト）
backtrack(state, target, total, nums, res);
return res;
}
@@ -47,7 +47,7 @@ public class subset_sum_i_naive {
List<List<Integer>> res = subsetSumINaive(nums, target);
System.out.println("入力配列 nums = " + Arrays.toString(nums) + ", target = " + target);
System.out.println("和が " + target + " のすべての部分集合 res = " + res);
System.out.println("この方法の結果には重複する集合が含まれています");
System.out.println("和が " + target + " に等しいすべての部分集合 res = " + res);
System.out.println("注意: この方法の出力結果には重複した集合が含まれます");
}
}
}

30
ja/codes/java/chapter_backtracking/subset_sum_ii.java
View File

@@ -9,41 +9,41 @@ package chapter_backtracking;
import java.util.*;
public class subset_sum_ii {
/* バックトラッキングアルゴリズム：部分集合和 II */
/* バックトラッキング：部分和 II */
static void backtrack(List<Integer> state, int target, int[] choices, int start, List<List<Integer>> res) {
// 部分集合の和がtargetと等しいとき、解を記録
// 部分集合の和が target に等しければ、解を記録
if (target == 0) {
res.add(new ArrayList<>(state));
return;
}
// すべての選択肢を走査
// 剪定二：startから走査を開始し、重複する部分集合の生成を回避
// 剪定三：startから走査を開始し、同じ要素の繰り返し選択を回避
// 枝刈り 2: start から走査し、重複する部分集合の生成を避ける
// 枝刈り 3: start から走査し、同じ要素の重複選択を避ける
for (int i = start; i < choices.length; i++) {
// 剪定一：部分集合の和がtargetを超えた場合、即座にループを終了
// 配列がソートされているため、後の要素はさらに大きく、部分集合の和は必ずtargetを超える
// 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する
// 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため
if (target - choices[i] < 0) {
break;
}
// 剪定四：要素が左の要素と等しい場合、検索ブランチの重複を示すのでスキップ
// 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする
if (i > start && choices[i] == choices[i - 1]) {
continue;
}
// 試行：選択を行い、target、startを更新
// 試す：選択を行い、target と start を更新
state.add(choices[i]);
// 次のラウンドの選択に進む
// 次の選択へ進む
backtrack(state, target - choices[i], choices, i + 1, res);
// 回退：選択を取り消し、前の状態に復元
// バックトラック：選択を取り消し、前の状態に戻す
state.remove(state.size() - 1);
}
}
/* 部分集合和 II を解く */
/* 部分和 II を解く */
static List<List<Integer>> subsetSumII(int[] nums, int target) {
List<Integer> state = new ArrayList<>(); // 状態（部分集合）
Arrays.sort(nums); // nums をソート
int start = 0; // 走査の開始点
List<List<Integer>> res = new ArrayList<>(); // 結果リスト（部分集合リスト）
int start = 0; // 開始点を走査
List<List<Integer>> res = new ArrayList<>(); // 結果リスト（部分集合のリスト）
backtrack(state, target, nums, start, res);
return res;
}
@@ -55,6 +55,6 @@ public class subset_sum_ii {
List<List<Integer>> res = subsetSumII(nums, target);
System.out.println("入力配列 nums = " + Arrays.toString(nums) + ", target = " + target);
System.out.println("和が " + target + " のすべての部分集合 res = " + res);
System.out.println("和が " + target + " に等しいすべての部分集合 res = " + res);
}
}
}

30
ja/codes/java/chapter_computational_complexity/iteration.java
View File

@@ -10,7 +10,7 @@ public class iteration {
/* for ループ */
static int forLoop(int n) {
int res = 0;
// 1, 2, ..., n-1, n の合計をループ計算
// 1, 2, ..., n-1, n を順に加算する
for (int i = 1; i <= n; i++) {
res += i;
}
@@ -20,35 +20,35 @@ public class iteration {
/* while ループ */
static int whileLoop(int n) {
int res = 0;
int i = 1; // 条件変数を初期化
// 1, 2, ..., n-1, n の合計をループ計算
int i = 1; // 条件変数を初期化する
// 1, 2, ..., n-1, n を順に加算する
while (i <= n) {
res += i;
i++; // 条件変数を更新
i++; // 条件変数を更新する
}
return res;
}
/* while ループ（2つの更新） */
/* while ループ（2回更新） */
static int whileLoopII(int n) {
int res = 0;
int i = 1; // 条件変数を初期化
// 1, 4, 10, ... の合計をループ計算
int i = 1; // 条件変数を初期化する
// 1, 4, 10, ... を順に加算する
while (i <= n) {
res += i;
// 条件変数を更新
// 条件変数を更新する
i++;
i *= 2;
}
return res;
}
/* 2重 for ループ */
/* 二重 for ループ */
static String nestedForLoop(int n) {
StringBuilder res = new StringBuilder();
// ループ i = 1, 2, ..., n-1, n
// i = 1, 2, ..., n-1, n とループする
for (int i = 1; i <= n; i++) {
// ループ j = 1, 2, ..., n-1, n
// j = 1, 2, ..., n-1, n とループする
for (int j = 1; j <= n; j++) {
res.append("(" + i + ", " + j + "), ");
}
@@ -56,7 +56,7 @@ public class iteration {
return res.toString();
}
/* ドライバーコード */
/* Driver Code */
public static void main(String[] args) {
int n = 5;
int res;
@@ -68,9 +68,9 @@ public class iteration {
System.out.println("\nwhile ループの合計結果 res = " + res);
res = whileLoopII(n);
System.out.println("\nwhile ループ（2つの更新）の合計結果 res = " + res);
System.out.println("\nwhile ループ（2 回更新）の合計結果 res = " + res);
String resStr = nestedForLoop(n);
System.out.println("\n2重 for ループ走査の結果 = " + resStr);
System.out.println("\n二重 for ループの走査結果 " + resStr);
}
}
}

22
ja/codes/java/chapter_computational_complexity/recursion.java
View File

@@ -16,23 +16,23 @@ public class recursion {
return 1;
// 再帰：再帰呼び出し
int res = recur(n - 1);
// 戻り値：結果を返す
// 帰りがけ：結果を返す
return n + res;
}
/* 反復で再帰をシミュレート */
/* 反復で再帰を模擬する */
static int forLoopRecur(int n) {
// 明示的なスタックを使用してシステムコールスタックをシミュレート
// 明示的なスタックを使ってシステムコールスタックを模擬する
Stack<Integer> stack = new Stack<>();
int res = 0;
// 再帰：再帰呼び出し
for (int i = n; i > 0; i--) {
// 「スタックへのプッシュ」で「再帰」をシミュレート
// 「スタックへのプッシュ」で「再帰」を模擬する
stack.push(i);
}
// 戻り値：結果を返す
// 帰りがけ：結果を返す
while (!stack.isEmpty()) {
// 「スタックからのポップ」で「戻り値」をシミュレート
// 「スタックから取り出す操作」で「帰り」をシミュレート
res += stack.pop();
}
// res = 1+2+3+...+n
@@ -53,13 +53,13 @@ public class recursion {
// 終了条件 f(1) = 0, f(2) = 1
if (n == 1 || n == 2)
return n - 1;
// 再帰呼び出し f(n) = f(n-1) + f(n-2)
// f(n) = f(n-1) + f(n-2) を再帰的に呼び出す
int res = fib(n - 1) + fib(n - 2);
// 結果 f(n) を返す
return res;
}
/* ドライバーコード */
/* Driver Code */
public static void main(String[] args) {
int n = 5;
int res;
@@ -68,12 +68,12 @@ public class recursion {
System.out.println("\n再帰関数の合計結果 res = " + res);
res = forLoopRecur(n);
System.out.println("\n反復を使用して再帰をシミュレートした合計結果 res = " + res);
System.out.println("\n反復による再帰シミュレーションの合計結果 res = " + res);
res = tailRecur(n, 0);
System.out.println("\n末尾再帰関数の合計結果 res = " + res);
res = fib(n);
System.out.println("\nフィボナッチ数列の第 " + n + " 番目の数は " + res);
System.out.println("\nフィボナッチ数列の第 " + n + " 項は " + res);
}
}
}

46
ja/codes/java/chapter_computational_complexity/space_complexity.java
View File

@@ -12,44 +12,44 @@ import java.util.*;
public class space_complexity {
/* 関数 */
static int function() {
// 何らかの操作を実行
// 何らかの処理を行う
return 0;
}
/* 定数計算量 */
/* 定数階 */
static void constant(int n) {
// 定数、変数、オブジェクトは O(1) 空間を占める
// 定数、変数、オブジェクトは O(1) の空間を占める
final int a = 0;
int b = 0;
int[] nums = new int[10000];
ListNode node = new ListNode(0);
// ループ内の変数は O(1) 空間を占める
// ループ内の変数は O(1) の空間を占める
for (int i = 0; i < n; i++) {
int c = 0;
}
// ループ内の関数は O(1) 空間を占める
// ループ内の関数は O(1) の空間を占める
for (int i = 0; i < n; i++) {
function();
}
}
/* 線形計算量 */
/* 線形階 */
static void linear(int n) {
// 長さ n の配列は O(n) 空間を占める
// 長さ n の配列は O(n) の空間を使用
int[] nums = new int[n];
// 長さ n のリストは O(n) 空間を占める
// 長さ n のリストは O(n) の空間を使用
List<ListNode> nodes = new ArrayList<>();
for (int i = 0; i < n; i++) {
nodes.add(new ListNode(i));
}
// 長さ n のハッシュテーブルは O(n) 空間を占める
// 長さ n のハッシュテーブルは O(n) の空間を使用
Map<Integer, String> map = new HashMap<>();
for (int i = 0; i < n; i++) {
map.put(i, String.valueOf(i));
}
}
/* 線形計算量（再帰実装） */
/* 線形時間（再帰実装） */
static void linearRecur(int n) {
System.out.println("再帰 n = " + n);
if (n == 1)
@@ -57,11 +57,11 @@ public class space_complexity {
linearRecur(n - 1);
}
/* 二次計算量 */
/* 二乗階 */
static void quadratic(int n) {
// 行列は O(n^2) 空間を占める
// 行列は O(n^2) の空間を使用する
int[][] numMatrix = new int[n][n];
// 二次元リストは O(n^2) 空間を占める
// 二次元リストは O(n^2) の空間を使用
List<List<Integer>> numList = new ArrayList<>();
for (int i = 0; i < n; i++) {
List<Integer> tmp = new ArrayList<>();
@@ -72,17 +72,17 @@ public class space_complexity {
}
}
/* 二次計算量（再帰実装） */
/* 二次時間（再帰実装） */
static int quadraticRecur(int n) {
if (n <= 0)
return 0;
// 配列 nums の長さ = n, n-1, ..., 2, 1
// 配列 nums の長さは n, n-1, ..., 2, 1
int[] nums = new int[n];
System.out.println("再帰 n = " + n + " の nums の長さ = " + nums.length);
System.out.println("再帰 n = " + n + " における nums の長さ = " + nums.length);
return quadraticRecur(n - 1);
}
/* 指数計算量（完全二分木の構築） */
/* 指数時間（完全二分木の構築） */
static TreeNode buildTree(int n) {
if (n == 0)
return null;
@@ -92,19 +92,19 @@ public class space_complexity {
return root;
}
/* ドライバーコード */
/* Driver Code */
public static void main(String[] args) {
int n = 5;
// 定数計算量
// 定数階
constant(n);
// 線形計算量
// 線形階
linear(n);
linearRecur(n);
// 二次計算量
// 二乗階
quadratic(n);
quadraticRecur(n);
// 指数計算量
// 指数オーダー
TreeNode root = buildTree(n);
PrintUtil.printTree(root);
}
}
}

68
ja/codes/java/chapter_computational_complexity/time_complexity.java
View File

@@ -7,7 +7,7 @@
package chapter_computational_complexity;
public class time_complexity {
/* 定数計算量 */
/* 定数階 */
static int constant(int n) {
int count = 0;
int size = 100000;
@@ -16,7 +16,7 @@ public class time_complexity {
return count;
}
/* 線形計算量 */
/* 線形階 */
static int linear(int n) {
int count = 0;
for (int i = 0; i < n; i++)
@@ -24,20 +24,20 @@ public class time_complexity {
return count;
}
/* 線形計算量（配列の走査） */
/* 線形時間（配列を走査） */
static int arrayTraversal(int[] nums) {
int count = 0;
// ループ回数は配列の長さに比例
// ループ回数は配列長に比例する
for (int num : nums) {
count++;
}
return count;
}
/* 二次計算量 */
/* 二乗階 */
static int quadratic(int n) {
int count = 0;
// ループ回数はデータサイズ n の二乗に比例
// ループ回数はデータサイズ n の二乗に比例する
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
count++;
@@ -46,29 +46,29 @@ public class time_complexity {
return count;
}
/* 二次計算量（バブルソート） */
/* 二次時間（バブルソート） */
static int bubbleSort(int[] nums) {
int count = 0; // カウンター
// 外側ループ：未ソート範囲は [0, i]
int count = 0; // カウンタ
// 外側のループ：未ソート区間は [0, i]
for (int i = nums.length - 1; i > 0; i--) {
// 内側ループ：未ソート範囲 [0, i] の最大要素を範囲の右端にスワップ
// 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換
for (int j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// nums[j] と nums[j + 1] をスワップ
// nums[j] と nums[j + 1] を交換
int tmp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = tmp;
count += 3; // 要素のスワップには3つの個別操作が含まれる
count += 3; // 要素交換には 3 回の単位操作が含まれる
}
}
}
return count;
}
/* 指数計算量（ループ実装） */
/* 指数時間（ループ実装） */
static int exponential(int n) {
int count = 0, base = 1;
// セルは毎ラウンド2つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成
// 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する
for (int i = 0; i < n; i++) {
for (int j = 0; j < base; j++) {
count++;
@@ -79,14 +79,14 @@ public class time_complexity {
return count;
}
/* 指数計算量（再帰実装） */
/* 指数時間（再帰実装） */
static int expRecur(int n) {
if (n == 1)
return 1;
return expRecur(n - 1) + expRecur(n - 1) + 1;
}
/* 対数計算量（ループ実装） */
/* 対数時間（ループ実装） */
static int logarithmic(int n) {
int count = 0;
while (n > 1) {
@@ -96,14 +96,14 @@ public class time_complexity {
return count;
}
/* 対数計算量（再帰実装） */
/* 対数時間（再帰実装） */
static int logRecur(int n) {
if (n <= 1)
return 0;
return logRecur(n / 2) + 1;
}
/* 線形対数計算量 */
/* 線形対数時間 */
static int linearLogRecur(int n) {
if (n <= 1)
return 1;
@@ -114,54 +114,54 @@ public class time_complexity {
return count;
}
/* 階乗計算量（再帰実装） */
/* 階乗時間（再帰実装） */
static int factorialRecur(int n) {
if (n == 0)
return 1;
int count = 0;
// 1から n に分裂
// 1個から n 個に分裂
for (int i = 0; i < n; i++) {
count += factorialRecur(n - 1);
}
return count;
}
/* ドライバーコード */
/* Driver Code */
public static void main(String[] args) {
// n を変更して、さまざまな計算量での操作回数の変化傾向を体験可能
// n を変えて実行し、各計算量で操作回数がどう変化するかを確認できる
int n = 8;
System.out.println("入力データサイズ n = " + n);
int count = constant(n);
System.out.println("定数計算量の操作回数 = " + count);
System.out.println("定数時間の操作回数 = " + count);
count = linear(n);
System.out.println("線形計算量の操作回数 = " + count);
System.out.println("線形時間の操作回数 = " + count);
count = arrayTraversal(new int[n]);
System.out.println("線形計算量の操作回数（配列走査） = " + count);
System.out.println("線形時間（配列走査）の操作回数 = " + count);
count = quadratic(n);
System.out.println("二次計算量の操作回数 = " + count);
System.out.println("2 次時間の操作回数 = " + count);
int[] nums = new int[n];
for (int i = 0; i < n; i++)
nums[i] = n - i; // [n,n-1,...,2,1]
count = bubbleSort(nums);
System.out.println("二次計算量の操作回数（バブルソート） = " + count);
System.out.println("2 次時間（バブルソート）の操作回数 = " + count);
count = exponential(n);
System.out.println("指数計算量の操作回数（ループ実装） = " + count);
System.out.println("指数時間（ループ実装）の操作回数 = " + count);
count = expRecur(n);
System.out.println("指数計算量の操作回数（再帰実装） = " + count);
System.out.println("指数時間（再帰実装）の操作回数 = " + count);
count = logarithmic(n);
System.out.println("対数計算量の操作回数（ループ実装） = " + count);
System.out.println("対数時間（ループ実装）の操作回数 = " + count);
count = logRecur(n);
System.out.println("対数計算量の操作回数（再帰実装） = " + count);
System.out.println("対数時間（再帰実装）の操作回数 = " + count);
count = linearLogRecur(n);
System.out.println("線形対数計算量の操作回数（再帰実装） = " + count);
System.out.println("線形対数時間（再帰実装）の操作回数 = " + count);
count = factorialRecur(n);
System.out.println("階乗計算量の操作回数（再帰実装） = " + count);
System.out.println("階乗時間（再帰実装）の操作回数 = " + count);
}
}
}

16
ja/codes/java/chapter_computational_complexity/worst_best_time_complexity.java
View File

@@ -9,7 +9,7 @@ package chapter_computational_complexity;
import java.util.*;
public class worst_best_time_complexity {
/* 要素 {1, 2, ..., n} をランダムにシャッフルした配列を生成 */
/* 要素が { 1, 2, ..., n } で、順序がシャッフルされた配列を生成 */
static int[] randomNumbers(int n) {
Integer[] nums = new Integer[n];
// 配列 nums = { 1, 2, 3, ..., n } を生成
@@ -26,25 +26,25 @@ public class worst_best_time_complexity {
return res;
}
/* 配列 nums で数値1のインデックスを見つける */
/* 配列 nums 内で数値 1 のインデックスを探す */
static int findOne(int[] nums) {
for (int i = 0; i < nums.length; i++) {
// 要素1が配列の先頭にある場合、最良時間計算量 O(1) を達成
// 要素1が配列の末尾にある場合、最悪時間計算量 O(n) を達成
// 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる
// 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる
if (nums[i] == 1)
return i;
}
return -1;
}
/* ドライバーコード */
/* Driver Code */
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
int n = 100;
int[] nums = randomNumbers(n);
int index = findOne(nums);
System.out.println("\n配列 [ 1, 2, ..., n ] をシャッフル後 = " + Arrays.toString(nums));
System.out.println("数値1のインデックスは " + index);
System.out.println("\n配列 [ 1, 2, ..., n ] をシャッフルした後 = " + Arrays.toString(nums));
System.out.println("数字 1 のインデックスは " + index);
}
}
}
}

16
ja/codes/java/chapter_divide_and_conquer/binary_search_recur.java
View File

@@ -9,20 +9,20 @@ package chapter_divide_and_conquer;
public class binary_search_recur {
/* 二分探索：問題 f(i, j) */
static int dfs(int[] nums, int target, int i, int j) {
// 区間が空の場合、対象要素が存在しないことを示すため、-1 を返す
// 区間が空なら対象要素は存在しないので -1 を返す
if (i > j) {
return -1;
}
// 中点インデックス m を計算
int m = i + (j - i) / 2;
int m = (i + j) / 2;
if (nums[m] < target) {
// 再帰的な部分問題 f(m+1, j)
// 部分問題 f(m+1, j) を再帰的に解く
return dfs(nums, target, m + 1, j);
} else if (nums[m] > target) {
// 再帰的な部分問題 f(i, m-1)
// 部分問題 f(i, m-1) を再帰的に解く
return dfs(nums, target, i, m - 1);
} else {
// 対象要素が見つかったため、そのインデックスを返す
// 目標要素が見つかったらそのインデックスを返す
return m;
}
}
@@ -38,8 +38,8 @@ public class binary_search_recur {
int target = 6;
int[] nums = { 1, 3, 6, 8, 12, 15, 23, 26, 31, 35 };
// 二分探索（両端閉区間）
// 二分探索（両閉区間）
int index = binarySearch(nums, target);
System.out.println("対象要素 6 のインデックス =" + index);
System.out.println("対象要素 6 のインデックス = " + index);
}
}
}

24
ja/codes/java/chapter_divide_and_conquer/build_tree.java
View File

@@ -10,26 +10,26 @@ import utils.*;
import java.util.*;
public class build_tree {
/* 二分木の構築：分割統治 */
/* 二分木を構築：分割統治 */
static TreeNode dfs(int[] preorder, Map<Integer, Integer> inorderMap, int i, int l, int r) {
// 部分木の区間が空の場合に終了
// 部分木区間が空なら終了する
if (r - l < 0)
return null;
// ルートノードを初期化
// ルートノードを初期化する
TreeNode root = new TreeNode(preorder[i]);
// m を問い合わせて左右の部分木を分割
// m を求めて左右部分木を分割する
int m = inorderMap.get(preorder[i]);
// 部分問題：左の部分木を構築
// 部分問題：左部分木を構築する
root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);
// 部分問題：右の部分木を構築
// 部分問題：右部分木を構築する
root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
// ルートノードを返す
// 根ノードを返す
return root;
}
/* 二分木の構築 */
/* 二分木を構築 */
static TreeNode buildTree(int[] preorder, int[] inorder) {
// ハッシュテーブルを初期化し、中間順序の要素からインデックスへのマッピングを格納
// inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する
Map<Integer, Integer> inorderMap = new HashMap<>();
for (int i = 0; i < inorder.length; i++) {
inorderMap.put(inorder[i], i);
@@ -42,10 +42,10 @@ public class build_tree {
int[] preorder = { 3, 9, 2, 1, 7 };
int[] inorder = { 9, 3, 1, 2, 7 };
System.out.println("前順走査 = " + Arrays.toString(preorder));
System.out.println("中間順序走査 = " + Arrays.toString(inorder));
System.out.println("中順走査 = " + Arrays.toString(inorder));
TreeNode root = buildTree(preorder, inorder);
System.out.println("構築された二分木:");
System.out.println("構築した二分木は：");
PrintUtil.printTree(root);
}
}
}

28
ja/codes/java/chapter_divide_and_conquer/hanota.java
View File

@@ -9,51 +9,51 @@ package chapter_divide_and_conquer;
import java.util.*;
public class hanota {
/* 円盤を移動 */
/* 円盤を 1 枚移動 */
static void move(List<Integer> src, List<Integer> tar) {
// src の最上部から円盤を取り出す
// src の上から円盤を1枚取り出す
Integer pan = src.remove(src.size() - 1);
// 円盤を tar の最上部に配置
// 円盤を tar の上に置く
tar.add(pan);
}
/* ハノイの塔問題 f(i) を解く */
/* ハノイの塔の問題 f(i) を解く */
static void dfs(int i, List<Integer> src, List<Integer> buf, List<Integer> tar) {
// src に円盤が1つだけ残っている場合、それを tar に移動
// src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す
if (i == 1) {
move(src, tar);
return;
}
// 部分問題 f(i-1)：tar の助けを借りて、上位 i-1 個の円盤を src から buf に移動
// 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す
dfs(i - 1, src, tar, buf);
// 部分問題 f(1)：残りの1つの円盤を src から tar に移動
// 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す
move(src, tar);
// 部分問題 f(i-1)：src の助けを借りて、上位 i-1 個の円盤を buf から tar に移動
// 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す
dfs(i - 1, buf, src, tar);
}
/* ハノイの塔問題を解く */
/* ハノイの塔を解く */
static void solveHanota(List<Integer> A, List<Integer> B, List<Integer> C) {
int n = A.size();
// B の助けを借りて、上位 n 個の円盤を A から C に移動
// A の上から n 枚の円盤を B を介して C へ移す
dfs(n, A, B, C);
}
public static void main(String[] args) {
// リストの末尾が柱の最上部
// リスト末尾が柱の頂上
List<Integer> A = new ArrayList<>(Arrays.asList(5, 4, 3, 2, 1));
List<Integer> B = new ArrayList<>();
List<Integer> C = new ArrayList<>();
System.out.println("初期状態:");
System.out.println("初期状態：");
System.out.println("A = " + A);
System.out.println("B = " + B);
System.out.println("C = " + C);
solveHanota(A, B, C);
System.out.println("円盤移動後:");
System.out.println("円盤の移動完了後：");
System.out.println("A = " + A);
System.out.println("B = " + B);
System.out.println("C = " + C);
}
}
}

18
ja/codes/java/chapter_dynamic_programming/climbing_stairs_backtrack.java
View File

@@ -11,26 +11,26 @@ import java.util.*;
public class climbing_stairs_backtrack {
/* バックトラッキング */
public static void backtrack(List<Integer> choices, int state, int n, List<Integer> res) {
// n段目に到達したとき、解の数に1を加える
// 第 n 段に到達したら、方法数を 1 増やす
if (state == n)
res.set(0, res.get(0) + 1);
// すべての選択肢を走査
for (Integer choice : choices) {
// 剪定：n段を超えて登ることを許可しない
// 枝刈り: 第 n 段を超えないようにする
if (state + choice > n)
continue;
// 試行：選択を行い、状態を更新
// 試行: 選択を行い、状態を更新
backtrack(choices, state + choice, n, res);
// 撤回
// バックトラック
}
}
/* 階段登り：バックトラッキング */
public static int climbingStairsBacktrack(int n) {
List<Integer> choices = Arrays.asList(1, 2); // 1段または2段登ることを選択可能
int state = 0; // 0段目から登り始める
List<Integer> choices = Arrays.asList(1, 2); // 1 段または 2 段上ることを選べる
int state = 0; // 第 0 段から上り始める
List<Integer> res = new ArrayList<>();
res.add(0); // res[0] を使用して解の数を記録
res.add(0); // res[0] を使って方法数を記録する
backtrack(choices, state, n, res);
return res.get(0);
}
@@ -39,6 +39,6 @@ public class climbing_stairs_backtrack {
int n = 9;
int res = climbingStairsBacktrack(n);
System.out.println(String.format("%d段の階段を登る解は%d通りです", n, res));
System.out.println(String.format("%d 段の階段の登り方は全部で %d 通り", n, res));
}
}
}

12
ja/codes/java/chapter_dynamic_programming/climbing_stairs_constraint_dp.java
View File

@@ -7,19 +7,19 @@
package chapter_dynamic_programming;
public class climbing_stairs_constraint_dp {
/* 制約付き階段登り：動的プログラミング */
/* 制約付き階段登り：動的計画法 */
static int climbingStairsConstraintDP(int n) {
if (n == 1 || n == 2) {
return 1;
}
// DPテーブルを初期化し、部分問題の解を格納するために使用
// 部分問題の解を保存するために dp テーブルを初期化
int[][] dp = new int[n + 1][3];
// 初期状態：最小の部分問題の解を事前設定
// 初期状態：最小部分問題の解をあらかじめ設定
dp[1][1] = 1;
dp[1][2] = 0;
dp[2][1] = 0;
dp[2][2] = 1;
// 状態遷移：小さな問題から大きな部分問題を段階的に解く
// 状態遷移：小さい部分問題から大きい部分問題へ順に解く
for (int i = 3; i <= n; i++) {
dp[i][1] = dp[i - 1][2];
dp[i][2] = dp[i - 2][1] + dp[i - 2][2];
@@ -31,6 +31,6 @@ public class climbing_stairs_constraint_dp {
int n = 9;
int res = climbingStairsConstraintDP(n);
System.out.println(String.format("%d段の階段を登る解は%d通りです", n, res));
System.out.println(String.format("%d 段の階段の登り方は全部で %d 通り", n, res));
}
}
}

8
ja/codes/java/chapter_dynamic_programming/climbing_stairs_dfs.java
View File

@@ -7,9 +7,9 @@
package chapter_dynamic_programming;
public class climbing_stairs_dfs {
/* 探索 */
/* 検索 */
public static int dfs(int i) {
// 既知の dp[1] と dp[2] を返す
// dp[1] と dp[2] は既知なので返す
if (i == 1 || i == 2)
return i;
// dp[i] = dp[i-1] + dp[i-2]
@@ -26,6 +26,6 @@ public class climbing_stairs_dfs {
int n = 9;
int res = climbingStairsDFS(n);
System.out.println(String.format("%d段の階段を登る解は%d通りです", n, res));
System.out.println(String.format("%d 段の階段の登り方は全部で %d 通り", n, res));
}
}
}

10
ja/codes/java/chapter_dynamic_programming/climbing_stairs_dfs_mem.java
View File

@@ -11,22 +11,22 @@ import java.util.Arrays;
public class climbing_stairs_dfs_mem {
/* メモ化探索 */
public static int dfs(int i, int[] mem) {
// 既知の dp[1] と dp[2] を返す
// dp[1] と dp[2] は既知なので返す
if (i == 1 || i == 2)
return i;
// dp[i] の記録がある場合、それを返す
// dp[i] の記録があれば、それをそのまま返す
if (mem[i] != -1)
return mem[i];
// dp[i] = dp[i-1] + dp[i-2]
int count = dfs(i - 1, mem) + dfs(i - 2, mem);
// dp[i] を記録
// dp[i] を記録する
mem[i] = count;
return count;
}
/* 階段登り：メモ化探索 */
public static int climbingStairsDFSMem(int n) {
// mem[i] は i 段目に登る総解数を記録、-1 は記録なしを意味する
// mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す
int[] mem = new int[n + 1];
Arrays.fill(mem, -1);
return dfs(n, mem);
@@ -36,6 +36,6 @@ public class climbing_stairs_dfs_mem {
int n = 9;
int res = climbingStairsDFSMem(n);
System.out.println(String.format("%d段の階段を登る解は%d通りです", n, res));
System.out.println(String.format("%d 段の階段の登り方は全部で %d 通り", n, res));
}
}

16
ja/codes/java/chapter_dynamic_programming/climbing_stairs_dp.java
View File

@@ -7,23 +7,23 @@
package chapter_dynamic_programming;
public class climbing_stairs_dp {
/* 階段登り：動的プログラミング */
/* 階段登り：動的計画法 */
public static int climbingStairsDP(int n) {
if (n == 1 || n == 2)
return n;
// DPテーブルを初期化し、部分問題の解を格納するために使用
// 部分問題の解を保存するために dp テーブルを初期化
int[] dp = new int[n + 1];
// 初期状態：最小の部分問題の解を事前設定
// 初期状態：最小部分問題の解をあらかじめ設定
dp[1] = 1;
dp[2] = 2;
// 状態遷移：小さな問題から大きな部分問題を段階的に解く
// 状態遷移：小さい部分問題から大きい部分問題へ順に解く
for (int i = 3; i <= n; i++) {
dp[i] = dp[i - 1] + dp[i - 2];
}
return dp[n];
}
/* 階段登り：空間最適化動的プログラミング */
/* 階段登り：空間最適化した動的計画法 */
public static int climbingStairsDPComp(int n) {
if (n == 1 || n == 2)
return n;
@@ -40,9 +40,9 @@ public class climbing_stairs_dp {
int n = 9;
int res = climbingStairsDP(n);
System.out.println(String.format("%d段の階段を登る解は%d通りです", n, res));
System.out.println(String.format("%d 段の階段の登り方は全部で %d 通り", n, res));
res = climbingStairsDPComp(n);
System.out.println(String.format("%d段の階段を登る解は%d通りです", n, res));
System.out.println(String.format("%d 段の階段の登り方は全部で %d 通り", n, res));
}
}
}

30
ja/codes/java/chapter_dynamic_programming/coin_change.java
View File

@@ -9,24 +9,24 @@ package chapter_dynamic_programming;
import java.util.Arrays;
public class coin_change {
/* 硬貨両替：動的プログラミング */
/* コイン両替：動的計画法 */
static int coinChangeDP(int[] coins, int amt) {
int n = coins.length;
int MAX = amt + 1;
// DPテーブルを初期化
// dp テーブルを初期化
int[][] dp = new int[n + 1][amt + 1];
// 状態遷移：最初の行と最初の列
// 状態遷移：先頭行と先頭列
for (int a = 1; a <= amt; a++) {
dp[0][a] = MAX;
}
// 状態遷移：残りの行と列
// 状態遷移: 残りの行と列
for (int i = 1; i <= n; i++) {
for (int a = 1; a <= amt; a++) {
if (coins[i - 1] > a) {
// 目標金額を超える場合、硬貨 i を選択しない
// 目標金額を超えるなら硬貨 i は選ばない
dp[i][a] = dp[i - 1][a];
} else {
// 選択しない場合と硬貨 i を選択する場合のより小さい値
// 硬貨 i を選ばない場合と選ぶ場合の小さい方
dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);
}
}
@@ -34,11 +34,11 @@ public class coin_change {
return dp[n][amt] != MAX ? dp[n][amt] : -1;
}
/* 硬貨両替：空間最適化動的プログラミング */
/* コイン交換：空間最適化後の動的計画法 */
static int coinChangeDPComp(int[] coins, int amt) {
int n = coins.length;
int MAX = amt + 1;
// DPテーブルを初期化
// dp テーブルを初期化
int[] dp = new int[amt + 1];
Arrays.fill(dp, MAX);
dp[0] = 0;
@@ -46,10 +46,10 @@ public class coin_change {
for (int i = 1; i <= n; i++) {
for (int a = 1; a <= amt; a++) {
if (coins[i - 1] > a) {
// 目標金額を超える場合、硬貨 i を選択しない
// 目標金額を超えるなら硬貨 i は選ばない
dp[a] = dp[a];
} else {
// 選択しない場合と硬貨 i を選択する場合のより小さい値
// 硬貨 i を選ばない場合と選ぶ場合の小さい方
dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);
}
}
@@ -61,12 +61,12 @@ public class coin_change {
int[] coins = { 1, 2, 5 };
int amt = 4;
// 動的プログラミング
// 動的計画法
int res = coinChangeDP(coins, amt);
System.out.println("目標金額を作るのに必要な最小硬貨数は " + res + " です");
System.out.println("目標金額に必要な最小硬貨枚数は " + res);
// 空間最適化動的プログラミング
// 空間最適化後の動的計画法
res = coinChangeDPComp(coins, amt);
System.out.println("目標金額を作るのに必要な最小硬貨数は " + res + " です");
System.out.println("目標金額に必要な最小硬貨枚数は " + res);
}
}
}

28
ja/codes/java/chapter_dynamic_programming/coin_change_ii.java
View File

@@ -7,12 +7,12 @@
package chapter_dynamic_programming;
public class coin_change_ii {
/* 硬貨両替 II：動的プログラミング */
/* コイン両替 II：動的計画法 */
static int coinChangeIIDP(int[] coins, int amt) {
int n = coins.length;
// DPテーブルを初期化
// dp テーブルを初期化
int[][] dp = new int[n + 1][amt + 1];
// 最初の列を初期化
// 先頭列を初期化する
for (int i = 0; i <= n; i++) {
dp[i][0] = 1;
}
@@ -20,10 +20,10 @@ public class coin_change_ii {
for (int i = 1; i <= n; i++) {
for (int a = 1; a <= amt; a++) {
if (coins[i - 1] > a) {
// 目標金額を超える場合、硬貨 i を選択しない
// 目標金額を超えるなら硬貨 i は選ばない
dp[i][a] = dp[i - 1][a];
} else {
// 選択しない場合と硬貨 i を選択する場合の2つの選択肢の合計
// コイン i を選ばない場合と選ぶ場合の和
dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];
}
}
@@ -31,20 +31,20 @@ public class coin_change_ii {
return dp[n][amt];
}
/* 硬貨両替 II：空間最適化動的プログラミング */
/* コイン両替 II：空間最適化した動的計画法 */
static int coinChangeIIDPComp(int[] coins, int amt) {
int n = coins.length;
// DPテーブルを初期化
// dp テーブルを初期化
int[] dp = new int[amt + 1];
dp[0] = 1;
// 状態遷移
for (int i = 1; i <= n; i++) {
for (int a = 1; a <= amt; a++) {
if (coins[i - 1] > a) {
// 目標金額を超える場合、硬貨 i を選択しない
// 目標金額を超えるなら硬貨 i は選ばない
dp[a] = dp[a];
} else {
// 選択しない場合と硬貨 i を選択する場合の2つの選択肢の合計
// コイン i を選ばない場合と選ぶ場合の和
dp[a] = dp[a] + dp[a - coins[i - 1]];
}
}
@@ -56,12 +56,12 @@ public class coin_change_ii {
int[] coins = { 1, 2, 5 };
int amt = 5;
// 動的プログラミング
// 動的計画法
int res = coinChangeIIDP(coins, amt);
System.out.println("目標金額を作る硬貨の組み合わせ数は " + res + " です");
System.out.println("目標金額を作る硬貨の組み合わせ数は " + res);
// 空間最適化動的プログラミング
// 空間最適化後の動的計画法
res = coinChangeIIDPComp(coins, amt);
System.out.println("目標金額を作る硬貨の組み合わせ数は " + res + " です");
System.out.println("目標金額を作る硬貨の組み合わせ数は " + res);
}
}
}

68
ja/codes/java/chapter_dynamic_programming/edit_distance.java
View File

@@ -9,73 +9,73 @@ package chapter_dynamic_programming;
import java.util.Arrays;
public class edit_distance {
/* 編集距離：ブルートフォース探索 */
/* 編集距離：総当たり探索 */
static int editDistanceDFS(String s, String t, int i, int j) {
// s と t の両方が空の場合、0 を返す
// s と t がともに空なら 0 を返す
if (i == 0 && j == 0)
return 0;
// s が空の場合、t の長さを返す
// s が空なら t の長さを返す
if (i == 0)
return j;
// t が空の場合、s の長さを返す
// t が空なら s の長さを返す
if (j == 0)
return i;
// 2つの文字が等しい場合、これら2つの文字をスキップ
// 2 つの文字が等しければ、その 2 文字をそのままスキップする
if (s.charAt(i - 1) == t.charAt(j - 1))
return editDistanceDFS(s, t, i - 1, j - 1);
// 最小編集数 = 3つの操作（挿入、削除、置換）からの最小編集数 + 1
// 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1
int insert = editDistanceDFS(s, t, i, j - 1);
int delete = editDistanceDFS(s, t, i - 1, j);
int replace = editDistanceDFS(s, t, i - 1, j - 1);
// 最小編集数を返す
// 最小編集回数を返す
return Math.min(Math.min(insert, delete), replace) + 1;
}
/* 編集距離：メモ化探索 */
static int editDistanceDFSMem(String s, String t, int[][] mem, int i, int j) {
// s と t の両方が空の場合、0 を返す
// s と t がともに空なら 0 を返す
if (i == 0 && j == 0)
return 0;
// s が空の場合、t の長さを返す
// s が空なら t の長さを返す
if (i == 0)
return j;
// t が空の場合、s の長さを返す
// t が空なら s の長さを返す
if (j == 0)
return i;
// 記録がある場合、それを返す
// 記録済みなら、それをそのまま返す
if (mem[i][j] != -1)
return mem[i][j];
// 2つの文字が等しい場合、これら2つの文字をスキップ
// 2 つの文字が等しければ、その 2 文字をそのままスキップする
if (s.charAt(i - 1) == t.charAt(j - 1))
return editDistanceDFSMem(s, t, mem, i - 1, j - 1);
// 最小編集数 = 3つの操作（挿入、削除、置換）からの最小編集数 + 1
// 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1
int insert = editDistanceDFSMem(s, t, mem, i, j - 1);
int delete = editDistanceDFSMem(s, t, mem, i - 1, j);
int replace = editDistanceDFSMem(s, t, mem, i - 1, j - 1);
// 最小編集数を記録して返す
// 最小編集回数を記録して返す
mem[i][j] = Math.min(Math.min(insert, delete), replace) + 1;
return mem[i][j];
}
/* 編集距離：動的プログラミング */
/* 編集距離：動的計画法 */
static int editDistanceDP(String s, String t) {
int n = s.length(), m = t.length();
int[][] dp = new int[n + 1][m + 1];
// 状態遷移：最初の行と最初の列
// 状態遷移：先頭行と先頭列
for (int i = 1; i <= n; i++) {
dp[i][0] = i;
}
for (int j = 1; j <= m; j++) {
dp[0][j] = j;
}
// 状態遷移：残りの行と列
// 状態遷移: 残りの行と列
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (s.charAt(i - 1) == t.charAt(j - 1)) {
// 2つの文字が等しい場合、これら2つの文字をスキップ
// 2 つの文字が等しければ、その 2 文字をそのままスキップする
dp[i][j] = dp[i - 1][j - 1];
} else {
// 最小編集数 = 3つの操作（挿入、削除、置換）からの最小編集数 + 1
// 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1
dp[i][j] = Math.min(Math.min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;
}
}
@@ -83,30 +83,30 @@ public class edit_distance {
return dp[n][m];
}
/* 編集距離：空間最適化動的プログラミング */
/* 編集距離：空間最適化した動的計画法 */
static int editDistanceDPComp(String s, String t) {
int n = s.length(), m = t.length();
int[] dp = new int[m + 1];
// 状態遷移：最初の行
// 状態遷移：先頭行
for (int j = 1; j <= m; j++) {
dp[j] = j;
}
// 状態遷移：残りの行
for (int i = 1; i <= n; i++) {
// 状態遷移：最初の列
int leftup = dp[0]; // dp[i-1, j-1] を一時的に格納
// 状態遷移：先頭列
int leftup = dp[0]; // dp[i-1, j-1] を一時保存する
dp[0] = i;
// 状態遷移：残りの列
for (int j = 1; j <= m; j++) {
int temp = dp[j];
if (s.charAt(i - 1) == t.charAt(j - 1)) {
// 2つの文字が等しい場合、これら2つの文字をスキップ
// 2 つの文字が等しければ、その 2 文字をそのままスキップする
dp[j] = leftup;
} else {
// 最小編集数 = 3つの操作（挿入、削除、置換）からの最小編集数 + 1
// 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1
dp[j] = Math.min(Math.min(dp[j - 1], dp[j]), leftup) + 1;
}
leftup = temp; // 次のラウンドの dp[i-1, j-1] のために更新
leftup = temp; // 次の反復の dp[i-1, j-1] に更新する
}
}
return dp[m];
@@ -117,23 +117,23 @@ public class edit_distance {
String t = "pack";
int n = s.length(), m = t.length();
// ブルートフォース探索
// 全探索
int res = editDistanceDFS(s, t, n, m);
System.out.println(s + " を " + t + " に変更するには最低 " + res + " 回の編集が必要です");
System.out.println(s + " を " + t + " に変更するには、最小で " + res + " 回の編集が必要");
// メモ化探索
int[][] mem = new int[n + 1][m + 1];
for (int[] row : mem)
Arrays.fill(row, -1);
res = editDistanceDFSMem(s, t, mem, n, m);
System.out.println(s + " を " + t + " に変更するには最低 " + res + " 回の編集が必要です");
System.out.println(s + " を " + t + " に変更するには、最小で " + res + " 回の編集が必要");
// 動的プログラミング
// 動的計画法
res = editDistanceDP(s, t);
System.out.println(s + " を " + t + " に変更するには最低 " + res + " 回の編集が必要です");
System.out.println(s + " を " + t + " に変更するには、最小で " + res + " 回の編集が必要");
// 空間最適化動的プログラミング
// 空間最適化後の動的計画法
res = editDistanceDPComp(s, t);
System.out.println(s + " を " + t + " に変更するには最低 " + res + " 回の編集が必要です");
System.out.println(s + " を " + t + " に変更するには、最小で " + res + " 回の編集が必要");
}
}
}

52
ja/codes/java/chapter_dynamic_programming/knapsack.java
View File

@@ -10,58 +10,58 @@ import java.util.Arrays;
public class knapsack {
/* 0-1 ナップサック：ブルートフォース探索 */
/* 0-1 ナップサック：総当たり探索 */
static int knapsackDFS(int[] wgt, int[] val, int i, int c) {
// すべてのアイテムが選択されたか、ナップサックに残り容量がない場合、値 0 を返す
// すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す
if (i == 0 || c == 0) {
return 0;
}
// ナップサックの容量を超える場合、ナップサックに入れないことしか選択できない
// ナップサック容量を超える場合は、入れない選択しかできない
if (wgt[i - 1] > c) {
return knapsackDFS(wgt, val, i - 1, c);
}
// アイテム i を入れない場合と入れる場合の最大値を計算
// 品物 i を入れない場合と入れる場合の最大価値を計算する
int no = knapsackDFS(wgt, val, i - 1, c);
int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];
// 2つの選択肢のより大きい値を返す
// 2つの案のうち価値が大きいほうを返す
return Math.max(no, yes);
}
/* 0-1 ナップサック：メモ化探索 */
static int knapsackDFSMem(int[] wgt, int[] val, int[][] mem, int i, int c) {
// すべてのアイテムが選択されたか、ナップサックに残り容量がない場合、値 0 を返す
// すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す
if (i == 0 || c == 0) {
return 0;
}
// 記録がある場合、それを返す
// 既に記録があればそのまま返す
if (mem[i][c] != -1) {
return mem[i][c];
}
// ナップサックの容量を超える場合、ナップサックに入れないことしか選択できない
// ナップサック容量を超える場合は、入れない選択しかできない
if (wgt[i - 1] > c) {
return knapsackDFSMem(wgt, val, mem, i - 1, c);
}
// アイテム i を入れない場合と入れる場合の最大値を計算
// 品物 i を入れない場合と入れる場合の最大価値を計算する
int no = knapsackDFSMem(wgt, val, mem, i - 1, c);
int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];
// 2つの選択肢のより大きい値を記録して返す
// 2 つの案のうち価値が大きい方を記録して返す
mem[i][c] = Math.max(no, yes);
return mem[i][c];
}
/* 0-1 ナップサック：動的プログラミング */
/* 0-1 ナップサック：動的計画法 */
static int knapsackDP(int[] wgt, int[] val, int cap) {
int n = wgt.length;
// DPテーブルを初期化
// dp テーブルを初期化
int[][] dp = new int[n + 1][cap + 1];
// 状態遷移
for (int i = 1; i <= n; i++) {
for (int c = 1; c <= cap; c++) {
if (wgt[i - 1] > c) {
// ナップサックの容量を超える場合、アイテム i を選択しない
// ナップサック容量を超えるなら品物 i は選ばない
dp[i][c] = dp[i - 1][c];
} else {
// 選択しない場合とアイテム i を選択する場合のより大きい値
// 品物 i を選ばない場合と選ぶ場合の大きい方
dp[i][c] = Math.max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);
}
}
@@ -69,17 +69,17 @@ public class knapsack {
return dp[n][cap];
}
/* 0-1 ナップサック：空間最適化動的プログラミング */
/* 0-1 ナップサック：空間最適化後の動的計画法 */
static int knapsackDPComp(int[] wgt, int[] val, int cap) {
int n = wgt.length;
// DPテーブルを初期化
// dp テーブルを初期化
int[] dp = new int[cap + 1];
// 状態遷移
for (int i = 1; i <= n; i++) {
// 逆順で走査
// 逆順に走査する
for (int c = cap; c >= 1; c--) {
if (wgt[i - 1] <= c) {
// 選択しない場合とアイテム i を選択する場合のより大きい値
// 品物 i を選ばない場合と選ぶ場合の大きい方
dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
}
}
@@ -93,9 +93,9 @@ public class knapsack {
int cap = 50;
int n = wgt.length;
// ブルートフォース探索
// 全探索
int res = knapsackDFS(wgt, val, n, cap);
System.out.println("ナップサック容量内での最大値は " + res + " です");
System.out.println("ナップサック容量を超えない最大価値は " + res);
// メモ化探索
int[][] mem = new int[n + 1][cap + 1];
@@ -103,14 +103,14 @@ public class knapsack {
Arrays.fill(row, -1);
}
res = knapsackDFSMem(wgt, val, mem, n, cap);
System.out.println("ナップサック容量内での最大値は " + res + " です");
System.out.println("ナップサック容量を超えない最大価値は " + res);
// 動的プログラミング
// 動的計画法
res = knapsackDP(wgt, val, cap);
System.out.println("ナップサック容量内での最大値は " + res + " です");
System.out.println("ナップサック容量を超えない最大価値は " + res);
// 空間最適化動的プログラミング
// 空間最適化後の動的計画法
res = knapsackDPComp(wgt, val, cap);
System.out.println("ナップサック容量内での最大値は " + res + " です");
System.out.println("ナップサック容量を超えない最大価値は " + res);
}
}
}

18
ja/codes/java/chapter_dynamic_programming/min_cost_climbing_stairs_dp.java
View File

@@ -9,24 +9,24 @@ package chapter_dynamic_programming;
import java.util.Arrays;
public class min_cost_climbing_stairs_dp {
/* 最小コスト階段登り：動的プログラミング */
/* 階段登りの最小コスト：動的計画法 */
public static int minCostClimbingStairsDP(int[] cost) {
int n = cost.length - 1;
if (n == 1 || n == 2)
return cost[n];
// DPテーブルを初期化し、部分問題の解を格納するために使用
// 部分問題の解を保存するために dp テーブルを初期化
int[] dp = new int[n + 1];
// 初期状態：最小の部分問題の解を事前設定
// 初期状態：最小部分問題の解をあらかじめ設定
dp[1] = cost[1];
dp[2] = cost[2];
// 状態遷移：小さな問題から大きな部分問題を段階的に解く
// 状態遷移：小さい部分問題から大きい部分問題へ順に解く
for (int i = 3; i <= n; i++) {
dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];
}
return dp[n];
}
/* 最小コスト階段登り：空間最適化動的プログラミング */
/* 階段昇りの最小コスト：空間最適化後の動的計画法 */
public static int minCostClimbingStairsDPComp(int[] cost) {
int n = cost.length - 1;
if (n == 1 || n == 2)
@@ -42,12 +42,12 @@ public class min_cost_climbing_stairs_dp {
public static void main(String[] args) {
int[] cost = { 0, 1, 10, 1, 1, 1, 10, 1, 1, 10, 1 };
System.out.println(String.format("階段のコストリストを %s として入力", Arrays.toString(cost)));
System.out.println(String.format("入力された階段コストのリストは %s", Arrays.toString(cost)));
int res = minCostClimbingStairsDP(cost);
System.out.println(String.format("階段を登るための最小コスト %d", res));
System.out.println(String.format("階段を上り切る最小コストは %d", res));
res = minCostClimbingStairsDPComp(cost);
System.out.println(String.format("階段を登るための最小コスト %d", res));
System.out.println(String.format("階段を上り切る最小コストは %d", res));
}
}
}

56
ja/codes/java/chapter_dynamic_programming/min_path_sum.java
View File

@@ -9,60 +9,60 @@ package chapter_dynamic_programming;
import java.util.Arrays;
public class min_path_sum {
/* 最小パス和：ブルートフォース探索 */
/* 最小経路和：全探索 */
static int minPathSumDFS(int[][] grid, int i, int j) {
// 左上のセルの場合、探索を終了
// 左上のセルなら探索を終了する
if (i == 0 && j == 0) {
return grid[0][0];
}
// 行または列のインデックスが範囲外の場合、+∞ のコストを返す
// 行または列のインデックスが範囲外なら、コスト +∞ を返す
if (i < 0 || j < 0) {
return Integer.MAX_VALUE;
}
// 左上から (i-1, j) と (i, j-1) への最小パスコストを計算
// 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する
int up = minPathSumDFS(grid, i - 1, j);
int left = minPathSumDFS(grid, i, j - 1);
// 左上から (i, j) への最小パスコストを返す
// 左上隅から (i, j) までの最小経路コストを返す
return Math.min(left, up) + grid[i][j];
}
/* 最小パス和：メモ化探索 */
/* 最小経路和：メモ化探索 */
static int minPathSumDFSMem(int[][] grid, int[][] mem, int i, int j) {
// 左上のセルの場合、探索を終了
// 左上のセルなら探索を終了する
if (i == 0 && j == 0) {
return grid[0][0];
}
// 行または列のインデックスが範囲外の場合、+∞ のコストを返す
// 行または列のインデックスが範囲外なら、コスト +∞ を返す
if (i < 0 || j < 0) {
return Integer.MAX_VALUE;
}
// 記録がある場合、それを返す
// 既に記録があればそのまま返す
if (mem[i][j] != -1) {
return mem[i][j];
}
// 左と上のセルからの最小パスコスト
// 左と上のセルからの最小経路コスト
int up = minPathSumDFSMem(grid, mem, i - 1, j);
int left = minPathSumDFSMem(grid, mem, i, j - 1);
// 左上から (i, j) への最小パスコストを記録して返す
// 左上から (i, j) までの最小経路コストを記録して返す
mem[i][j] = Math.min(left, up) + grid[i][j];
return mem[i][j];
}
/* 最小パス和：動的プログラミング */
/* 最小経路和：動的計画法 */
static int minPathSumDP(int[][] grid) {
int n = grid.length, m = grid[0].length;
// DPテーブルを初期化
// dp テーブルを初期化
int[][] dp = new int[n][m];
dp[0][0] = grid[0][0];
// 状態遷移：最初の行
// 状態遷移：先頭行
for (int j = 1; j < m; j++) {
dp[0][j] = dp[0][j - 1] + grid[0][j];
}
// 状態遷移：最初の列
// 状態遷移：先頭列
for (int i = 1; i < n; i++) {
dp[i][0] = dp[i - 1][0] + grid[i][0];
}
// 状態遷移：残りの行と列
// 状態遷移: 残りの行と列
for (int i = 1; i < n; i++) {
for (int j = 1; j < m; j++) {
dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];
@@ -71,19 +71,19 @@ public class min_path_sum {
return dp[n - 1][m - 1];
}
/* 最小パス和：空間最適化動的プログラミング */
/* 最小経路和：空間最適化後の動的計画法 */
static int minPathSumDPComp(int[][] grid) {
int n = grid.length, m = grid[0].length;
// DPテーブルを初期化
// dp テーブルを初期化
int[] dp = new int[m];
// 状態遷移：最初の行
// 状態遷移：先頭行
dp[0] = grid[0][0];
for (int j = 1; j < m; j++) {
dp[j] = dp[j - 1] + grid[0][j];
}
// 状態遷移：残りの行
for (int i = 1; i < n; i++) {
// 状態遷移：最初の列
// 状態遷移：先頭列
dp[0] = dp[0] + grid[i][0];
// 状態遷移：残りの列
for (int j = 1; j < m; j++) {
@@ -102,9 +102,9 @@ public class min_path_sum {
};
int n = grid.length, m = grid[0].length;
// ブルートフォース探索
// 全探索
int res = minPathSumDFS(grid, n - 1, m - 1);
System.out.println("左上角から右下角への最小パス和は " + res + " です");
System.out.println("左上から右下までの最小経路和は " + res);
// メモ化探索
int[][] mem = new int[n][m];
@@ -112,14 +112,14 @@ public class min_path_sum {
Arrays.fill(row, -1);
}
res = minPathSumDFSMem(grid, mem, n - 1, m - 1);
System.out.println("左上角から右下角への最小パス和は " + res + " です");
System.out.println("左上から右下までの最小経路和は " + res);
// 動的プログラミング
// 動的計画法
res = minPathSumDP(grid);
System.out.println("左上角から右下角への最小パス和は " + res + " です");
System.out.println("左上から右下までの最小経路和は " + res);
// 空間最適化動的プログラミング
// 空間最適化後の動的計画法
res = minPathSumDPComp(grid);
System.out.println("左上角から右下角への最小パス和は " + res + " です");
System.out.println("左上から右下までの最小経路和は " + res);
}
}
}

26
ja/codes/java/chapter_dynamic_programming/unbounded_knapsack.java
View File

@@ -7,19 +7,19 @@
package chapter_dynamic_programming;
public class unbounded_knapsack {
/* 完全ナップサック：動的プログラミング */
/* 完全ナップサック問題：動的計画法 */
static int unboundedKnapsackDP(int[] wgt, int[] val, int cap) {
int n = wgt.length;
// DPテーブルを初期化
// dp テーブルを初期化
int[][] dp = new int[n + 1][cap + 1];
// 状態遷移
for (int i = 1; i <= n; i++) {
for (int c = 1; c <= cap; c++) {
if (wgt[i - 1] > c) {
// ナップサックの容量を超える場合、アイテム i を選択しない
// ナップサック容量を超えるなら品物 i は選ばない
dp[i][c] = dp[i - 1][c];
} else {
// 選択しない場合とアイテム i を選択する場合のより大きい値
// 品物 i を選ばない場合と選ぶ場合の大きい方
dp[i][c] = Math.max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);
}
}
@@ -27,19 +27,19 @@ public class unbounded_knapsack {
return dp[n][cap];
}
/* 完全ナップサック：空間最適化動的プログラミング */
/* 完全ナップサック問題：空間最適化後の動的計画法 */
static int unboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {
int n = wgt.length;
// DPテーブルを初期化
// dp テーブルを初期化
int[] dp = new int[cap + 1];
// 状態遷移
for (int i = 1; i <= n; i++) {
for (int c = 1; c <= cap; c++) {
if (wgt[i - 1] > c) {
// ナップサックの容量を超える場合、アイテム i を選択しない
// ナップサック容量を超えるなら品物 i は選ばない
dp[c] = dp[c];
} else {
// 選択しない場合とアイテム i を選択する場合のより大きい値
// 品物 i を選ばない場合と選ぶ場合の大きい方
dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
}
}
@@ -52,12 +52,12 @@ public class unbounded_knapsack {
int[] val = { 5, 11, 15 };
int cap = 4;
// 動的プログラミング
// 動的計画法
int res = unboundedKnapsackDP(wgt, val, cap);
System.out.println("ナップサック容量内での最大値は " + res + " です");
System.out.println("ナップサック容量を超えない最大価値は " + res);
// 空間最適化動的プログラミング
// 空間最適化後の動的計画法
res = unboundedKnapsackDPComp(wgt, val, cap);
System.out.println("ナップサック容量内での最大値は " + res + " です");
System.out.println("ナップサック容量を超えない最大価値は " + res);
}
}
}

26
ja/codes/java/chapter_graph/graph_adjacency_list.java
View File

@@ -11,7 +11,7 @@ import utils.*;
/* 隣接リストに基づく無向グラフクラス */
class GraphAdjList {
// 隣接リスト、キー: 頂点、値: その頂点のすべての隣接頂点
// 隣接リスト。key は頂点、value はその頂点に隣接する全頂点
Map<Vertex, List<Vertex>> adjList;
/* コンストラクタ */
@@ -52,7 +52,7 @@ class GraphAdjList {
public void addVertex(Vertex vet) {
if (adjList.containsKey(vet))
return;
// 隣接リストに新しい連結リストを追加
// 隣接リストに新しいリストを追加
adjList.put(vet, new ArrayList<>());
}
@@ -60,9 +60,9 @@ class GraphAdjList {
public void removeVertex(Vertex vet) {
if (!adjList.containsKey(vet))
throw new IllegalArgumentException();
// 隣接リストから頂点 vet に対応する連結リストを削除
// 隣接リストから頂点 vet に対応するリストを削除
adjList.remove(vet);
// 他の頂点の連結リストを走査し、vet を含むすべての辺を削除
// 他の頂点のリストを走査し、vet を含むすべての辺を削除
for (List<Vertex> list : adjList.values()) {
list.remove(vet);
}
@@ -87,31 +87,31 @@ public class graph_adjacency_list {
Vertex[][] edges = { { v[0], v[1] }, { v[0], v[3] }, { v[1], v[2] },
{ v[2], v[3] }, { v[2], v[4] }, { v[3], v[4] } };
GraphAdjList graph = new GraphAdjList(edges);
System.out.println("\n初期化後、グラフは");
System.out.println("\n初期化後のグラフ");
graph.print();
/* 辺を追加 */
// 頂点 1、2、すなわち v[0]、v[2]
// 頂点 1, 2 は v[0], v[2]
graph.addEdge(v[0], v[2]);
System.out.println("\n辺 1-2 を追加後、グラフは");
System.out.println("\n辺 1-2 を追加した後のグラフ");
graph.print();
/* 辺を削除 */
// 頂点 1、3、すなわち v[0]、v[1]
// 頂点 1, 3 は v[0], v[1]
graph.removeEdge(v[0], v[1]);
System.out.println("\n辺 1-3 を削除後、グラフは");
System.out.println("\n辺 1-3 を削除した後のグラフ");
graph.print();
/* 頂点を追加 */
Vertex v5 = new Vertex(6);
graph.addVertex(v5);
System.out.println("\n頂点 6 を追加後、グラフは");
System.out.println("\n頂点 6 を追加した後のグラフ");
graph.print();
/* 頂点を削除 */
// 頂点 3、すなわち v[1]
// 頂点 3 は v[1]
graph.removeVertex(v[1]);
System.out.println("\n頂点 3 を削除後、グラフは");
System.out.println("\n頂点 3 を削除すると、グラフは");
graph.print();
}
}
}

46
ja/codes/java/chapter_graph/graph_adjacency_matrix.java
View File

@@ -11,8 +11,8 @@ import java.util.*;
/* 隣接行列に基づく無向グラフクラス */
class GraphAdjMat {
List<Integer> vertices; // 頂点リスト、要素は「頂点値」を表し、インデックスは「頂点インデックス」を表す
List<List<Integer>> adjMat; // 隣接行列、行と列のインデックスは「頂点インデックス」に対応
List<Integer> vertices; // 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す
List<List<Integer>> adjMat; // 隣接行列。行・列のインデックスは「頂点インデックス」に対応
/* コンストラクタ */
public GraphAdjMat(int[] vertices, int[][] edges) {
@@ -23,7 +23,7 @@ class GraphAdjMat {
addVertex(val);
}
// 辺を追加
// 辺の要素は頂点インデックスを表す
// 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する
for (int[] e : edges) {
addEdge(e[0], e[1]);
}
@@ -37,15 +37,15 @@ class GraphAdjMat {
/* 頂点を追加 */
public void addVertex(int val) {
int n = size();
// 頂点リストに新しい頂点値を追加
// 頂点リストに新しい頂点の値を追加
vertices.add(val);
// 隣接行列に行を追加
// 隣接行列に 1 行追加
List<Integer> newRow = new ArrayList<>(n);
for (int j = 0; j < n; j++) {
newRow.add(0);
}
adjMat.add(newRow);
// 隣接行列に列を追加
// 隣接行列に 1 列追加
for (List<Integer> row : adjMat) {
row.add(0);
}
@@ -55,31 +55,31 @@ class GraphAdjMat {
public void removeVertex(int index) {
if (index >= size())
throw new IndexOutOfBoundsException();
// 頂点リストから `index` の頂点を削除
// 頂点リストから index の頂点を削除する
vertices.remove(index);
// 隣接行列から `index` の行を削除
// 隣接行列で index 行を削除する
adjMat.remove(index);
// 隣接行列から `index` の列を削除
// 隣接行列で index 列を削除する
for (List<Integer> row : adjMat) {
row.remove(index);
}
}
/* 辺を追加 */
// パラメータ i、j は頂点要素のインデックスに対応
// 引数 i, j は vertices の要素インデックスに対応する
public void addEdge(int i, int j) {
// インデックスの範囲外と等価性を処理
// インデックスの範囲外と等値の処理
if (i < 0 || j < 0 || i >= size() || j >= size() || i == j)
throw new IndexOutOfBoundsException();
// 無向グラフでは、隣接行列は主対角線について対称、すなわち (i, j) == (j, i) を満たす
// 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす
adjMat.get(i).set(j, 1);
adjMat.get(j).set(i, 1);
}
/* 辺を削除 */
// パラメータ i、j は頂点要素のインデックスに対応
// 引数 i, j は vertices の要素インデックスに対応する
public void removeEdge(int i, int j) {
// インデックスの範囲外と等価性を処理
// インデックスの範囲外と等値の処理
if (i < 0 || j < 0 || i >= size() || j >= size() || i == j)
throw new IndexOutOfBoundsException();
adjMat.get(i).set(j, 0);
@@ -98,34 +98,34 @@ class GraphAdjMat {
public class graph_adjacency_matrix {
public static void main(String[] args) {
/* 無向グラフを初期化 */
// 辺の要素は頂点インデックスを表す
// edges の要素は頂点インデックス、すなわち vertices の要素インデックスに対応する点に注意
int[] vertices = { 1, 3, 2, 5, 4 };
int[][] edges = { { 0, 1 }, { 0, 3 }, { 1, 2 }, { 2, 3 }, { 2, 4 }, { 3, 4 } };
GraphAdjMat graph = new GraphAdjMat(vertices, edges);
System.out.println("\n初期化後、グラフは");
System.out.println("\n初期化後のグラフ");
graph.print();
/* 辺を追加 */
// 頂点 1、2 のインデックスはそれぞれ 0、2
// 頂点 1, 2 のインデックスはそれぞれ 0, 2
graph.addEdge(0, 2);
System.out.println("\n辺 1-2 を追加後、グラフは");
System.out.println("\n辺 1-2 を追加した後のグラフ");
graph.print();
/* 辺を削除 */
// 頂点 1、3 のインデックスはそれぞれ 0、1
// 頂点 1, 3 のインデックスはそれぞれ 0, 1
graph.removeEdge(0, 1);
System.out.println("\n辺 1-3 を削除後、グラフは");
System.out.println("\n辺 1-3 を削除した後のグラフ");
graph.print();
/* 頂点を追加 */
graph.addVertex(6);
System.out.println("\n頂点 6 を追加後、グラフは");
System.out.println("\n頂点 6 を追加した後のグラフ");
graph.print();
/* 頂点を削除 */
// 頂点 3 のインデックスは 1
graph.removeVertex(1);
System.out.println("\n頂点 3 を削除後、グラフは");
System.out.println("\n頂点 3 を削除すると、グラフは");
graph.print();
}
}
}

32
ja/codes/java/chapter_graph/graph_bfs.java
View File

@@ -10,30 +10,30 @@ import java.util.*;
import utils.*;
public class graph_bfs {
/* 幅優先走査 */
// 隣接リストを使用してグラフを表現し、指定した頂点のすべての隣接頂点を取得
/* 幅優先探索 */
// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする
static List<Vertex> graphBFS(GraphAdjList graph, Vertex startVet) {
// 頂点走査順序
// 頂点の走査順序
List<Vertex> res = new ArrayList<>();
// ハッシュセット、訪問済みの頂点を記録するために使用
// 訪問済み頂点を記録するためのハッシュ集合
Set<Vertex> visited = new HashSet<>();
visited.add(startVet);
// BFS を実装するために使用するキュー
// BFS の実装にキューを用いる
Queue<Vertex> que = new LinkedList<>();
que.offer(startVet);
// 頂点 vet から開始し、すべての頂点が訪問されるまでループ
// 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す
while (!que.isEmpty()) {
Vertex vet = que.poll(); // キューの先頭の頂点をデキュー
Vertex vet = que.poll(); // 先頭の頂点をデキュー
res.add(vet); // 訪問した頂点を記録
// その頂点のすべての隣接頂点を走査
// この頂点のすべての隣接頂点を走査
for (Vertex adjVet : graph.adjList.get(vet)) {
if (visited.contains(adjVet))
continue; // すでに訪問済みの頂点をスキップ
que.offer(adjVet); // 未訪問の頂点のみをエンキュー
visited.add(adjVet); // 頂点を訪問済みとしてマーク
continue; // 訪問済みの頂点をスキップ
que.offer(adjVet); // 未訪問の頂点のみをキューに追加
visited.add(adjVet); // この頂点を訪問済みにする
}
}
// 頂点走査順序を返す
// 頂点の走査順を返す
return res;
}
@@ -44,12 +44,12 @@ public class graph_bfs {
{ v[2], v[5] }, { v[3], v[4] }, { v[3], v[6] }, { v[4], v[5] },
{ v[4], v[7] }, { v[5], v[8] }, { v[6], v[7] }, { v[7], v[8] } };
GraphAdjList graph = new GraphAdjList(edges);
System.out.println("\n初期化後、グラフは");
System.out.println("\n初期化後のグラフ");
graph.print();
/* 幅優先走査 */
/* 幅優先探索 */
List<Vertex> res = graphBFS(graph, v[0]);
System.out.println("\n幅優先走査 (BFS) の頂点順序は");
System.out.println("\n幅優先探索（BFS）の頂点列は");
System.out.println(Vertex.vetsToVals(res));
}
}
}

22
ja/codes/java/chapter_graph/graph_dfs.java
View File

@@ -13,22 +13,22 @@ public class graph_dfs {
/* 深さ優先走査の補助関数 */
static void dfs(GraphAdjList graph, Set<Vertex> visited, List<Vertex> res, Vertex vet) {
res.add(vet); // 訪問した頂点を記録
visited.add(vet); // 頂点を訪問済みとしてマーク
// その頂点のすべての隣接頂点を走査
visited.add(vet); // この頂点を訪問済みにする
// この頂点のすべての隣接頂点を走査
for (Vertex adjVet : graph.adjList.get(vet)) {
if (visited.contains(adjVet))
continue; // すでに訪問済みの頂点をスキップ
continue; // 訪問済みの頂点をスキップ
// 隣接頂点を再帰的に訪問
dfs(graph, visited, res, adjVet);
}
}
/* 深さ優先走査 */
// 隣接リストを使用してグラフを表現し、指定した頂点のすべての隣接頂点を取得
/* 深さ優先探索 */
// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする
static List<Vertex> graphDFS(GraphAdjList graph, Vertex startVet) {
// 頂点走査順序
// 頂点の走査順序
List<Vertex> res = new ArrayList<>();
// ハッシュセット、訪問済みの頂点を記録するために使用
// 訪問済み頂点を記録するためのハッシュ集合
Set<Vertex> visited = new HashSet<>();
dfs(graph, visited, res, startVet);
return res;
@@ -40,12 +40,12 @@ public class graph_dfs {
Vertex[][] edges = { { v[0], v[1] }, { v[0], v[3] }, { v[1], v[2] },
{ v[2], v[5] }, { v[4], v[5] }, { v[5], v[6] } };
GraphAdjList graph = new GraphAdjList(edges);
System.out.println("\n初期化後、グラフは");
System.out.println("\n初期化後のグラフ");
graph.print();
/* 深さ優先走査 */
/* 深さ優先探索 */
List<Vertex> res = graphDFS(graph, v[0]);
System.out.println("\n深さ優先走査 (DFS) の頂点順序は");
System.out.println("\n深さ優先探索（DFS）の頂点列は");
System.out.println(Vertex.vetsToVals(res));
}
}
}

30
ja/codes/java/chapter_greedy/coin_change_greedy.java
View File

@@ -9,47 +9,47 @@ package chapter_greedy;
import java.util.Arrays;
public class coin_change_greedy {
/* 硬貨両替：貪欲法 */
/* コイン交換：貪欲法 */
static int coinChangeGreedy(int[] coins, int amt) {
// 硬貨リストが順序付けされていると仮定
// coins リストはソート済みと仮定する
int i = coins.length - 1;
int count = 0;
// 残り金額がなくなるまで貪欲選択をループ
// 残額がなくなるまで貪欲選択を繰り返す
while (amt > 0) {
// 残り金額に近く、それ以下の最小硬貨を見つける
// 残額以下で最も近い硬貨を見つける
while (i > 0 && coins[i] > amt) {
i--;
}
// coins[i] を選択
// coins[i] を選択する
amt -= coins[i];
count++;
}
// 実行可能な解が見つからない場合、-1 を返す
// 実行可能な解が見つからなければ -1 を返す
return amt == 0 ? count : -1;
}
public static void main(String[] args) {
// 貪欲法：大域最適解の発見を保証できる
// 貪欲法：大域最適解を保証できる
int[] coins = { 1, 5, 10, 20, 50, 100 };
int amt = 186;
int res = coinChangeGreedy(coins, amt);
System.out.println("\ncoins = " + Arrays.toString(coins) + ", amt = " + amt);
System.out.println(amt + " を作るのに必要な最小硬貨数は " + res + " です");
System.out.println("合計 " + amt + " に必要な最小硬貨枚数は " + res);
// 貪欲法：大域最適解の発見を保証できない
// 貪欲法：大域最適解を保証できない
coins = new int[] { 1, 20, 50 };
amt = 60;
res = coinChangeGreedy(coins, amt);
System.out.println("\ncoins = " + Arrays.toString(coins) + ", amt = " + amt);
System.out.println(amt + " を作るのに必要な最小硬貨数は " + res + " です");
System.out.println("実際には、最小必要数は 3 です。つまり、20 + 20 + 20");
System.out.println("合計 " + amt + " に必要な最小硬貨枚数は " + res);
System.out.println("実際に必要な最小枚数は 3、つまり 20 + 20 + 20");
// 貪欲法：大域最適解の発見を保証できない
// 貪欲法：大域最適解を保証できない
coins = new int[] { 1, 49, 50 };
amt = 98;
res = coinChangeGreedy(coins, amt);
System.out.println("\ncoins = " + Arrays.toString(coins) + ", amt = " + amt);
System.out.println(amt + " を作るのに必要な最小硬貨数は " + res + " です");
System.out.println("実際には、最小必要数は 2 です。つまり、49 + 49");
System.out.println("合計 " + amt + " に必要な最小硬貨枚数は " + res);
System.out.println("実際に必要な最小枚数は 2、つまり 49 + 49");
}
}
}

24
ja/codes/java/chapter_greedy/fractional_knapsack.java
View File

@@ -9,10 +9,10 @@ package chapter_greedy;
import java.util.Arrays;
import java.util.Comparator;
/* アイテム */
/* 品物 */
class Item {
int w; // アイテムの重量
int v; // アイテムの価値
int w; // 品物の重さ
int v; // 品物の価値
public Item(int w, int v) {
this.w = w;
@@ -23,24 +23,24 @@ class Item {
public class fractional_knapsack {
/* 分数ナップサック：貪欲法 */
static double fractionalKnapsack(int[] wgt, int[] val, int cap) {
// アイテムリストを作成、2つの属性を含む：重量、価値
// 重さと価値の 2 属性を持つ品物リストを作成
Item[] items = new Item[wgt.length];
for (int i = 0; i < wgt.length; i++) {
items[i] = new Item(wgt[i], val[i]);
}
// 単位価値 item.v / item.w で高い順にソート
// 単位価値 item.v / item.w の高い順にソートする
Arrays.sort(items, Comparator.comparingDouble(item -> -((double) item.v / item.w)));
// 貪欲選択をループ
// 貪欲選択を繰り返す
double res = 0;
for (Item item : items) {
if (item.w <= cap) {
// 残り容量が十分な場合、アイテム全体をナップサックに入れる
// 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる
res += item.v;
cap -= item.w;
} else {
// 残り容量が不十分な場合、アイテムの一部をナップサックに入れる
// 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる
res += (double) item.v / item.w * cap;
// 残り容量がなくなったため、ループを中断
// 残り容量がないため、ループを抜ける
break;
}
}
@@ -52,8 +52,8 @@ public class fractional_knapsack {
int[] val = { 50, 120, 150, 210, 240 };
int cap = 50;
// 貪欲アルゴリズム
// 貪欲法
double res = fractionalKnapsack(wgt, val, cap);
System.out.println("ナップサック容量内での最大値は " + res + " です");
System.out.println("ナップサック容量を超えない最大価値は " + res);
}
}
}

16
ja/codes/java/chapter_greedy/max_capacity.java
View File

@@ -9,16 +9,16 @@ package chapter_greedy;
public class max_capacity {
/* 最大容量：貪欲法 */
static int maxCapacity(int[] ht) {
// i、j を初期化し、配列の両端で分割させる
// i, j を初期化し、それぞれ配列の両端に置く
int i = 0, j = ht.length - 1;
// 初期最大容量は 0
// 初期の最大容量は 0
int res = 0;
// 2つの板が出会うまで貪欲選択をループ
// 2 枚の板が出会うまで貪欲選択を繰り返す
while (i < j) {
// 最大容量を更新
// 最大容量を更新する
int cap = Math.min(ht[i], ht[j]) * (j - i);
res = Math.max(res, cap);
// より短い板を内側に移動
// 短い方を内側へ動かす
if (ht[i] < ht[j]) {
i++;
} else {
@@ -31,8 +31,8 @@ public class max_capacity {
public static void main(String[] args) {
int[] ht = { 3, 8, 5, 2, 7, 7, 3, 4 };
// 貪欲アルゴリズム
// 貪欲法
int res = maxCapacity(ht);
System.out.println("最大容量は " + res + " です");
System.out.println("最大容量は " + res);
}
}
}

18
ja/codes/java/chapter_greedy/max_product_cutting.java
View File

@@ -9,32 +9,32 @@ package chapter_greedy;
import java.lang.Math;
public class max_product_cutting {
/* 最大積切断：貪欲法 */
/* 最大切断積：貪欲法 */
public static int maxProductCutting(int n) {
// n <= 3 の場合、1 を切り出す必要がある
// n <= 3 のときは、必ず 1 を切り出す
if (n <= 3) {
return 1 * (n - 1);
}
// 貪欲に 3 を切り出す。a は 3 の個数、b は余り
// 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする
int a = n / 3;
int b = n % 3;
if (b == 1) {
// 余りが 1 の場合、1 * 3 のペアを 2 * 2 に変換
// 余りが 1 のときは、1 * 3 を 2 * 2 に変える
return (int) Math.pow(3, a - 1) * 2 * 2;
}
if (b == 2) {
// 余りが 2 の場合、何もしない
// 余りが 2 のときは、そのままにする
return (int) Math.pow(3, a) * 2;
}
// 余りが 0 の場合、何もしない
// 余りが 0 のときは、そのままにする
return (int) Math.pow(3, a);
}
public static void main(String[] args) {
int n = 58;
// 貪欲アルゴリズム
// 貪欲法
int res = maxProductCutting(n);
System.out.println("分割の最大積は " + res + " です");
System.out.println("最大分割積は " + res);
}
}
}

46
ja/codes/java/chapter_hashing/array_hash_map.java
View File

@@ -8,7 +8,7 @@ package chapter_hashing;
import java.util.*;
/* キー値ペア */
/* キーと値の組 */
class Pair {
public int key;
public String val;
@@ -19,12 +19,12 @@ class Pair {
}
}
/* 配列実装に基づくハッシュテーブル */
/* 配列ベースのハッシュテーブル */
class ArrayHashMap {
private List<Pair> buckets;
public ArrayHashMap() {
// 100個のバケットを含む配列を初期化
// 100 個のバケットを含む配列を初期化
buckets = new ArrayList<>();
for (int i = 0; i < 100; i++) {
buckets.add(null);
@@ -37,7 +37,7 @@ class ArrayHashMap {
return index;
}
/* クエリ操作 */
/* 検索操作 */
public String get(int key) {
int index = hashFunc(key);
Pair pair = buckets.get(index);
@@ -56,11 +56,11 @@ class ArrayHashMap {
/* 削除操作 */
public void remove(int key) {
int index = hashFunc(key);
// nullに設定して削除を示す
// null に設定し、削除を表す
buckets.set(index, null);
}
/* すべてのキー値ペアを取得 */
/* すべてのキーと値のペアを取得 */
public List<Pair> pairSet() {
List<Pair> pairSet = new ArrayList<>();
for (Pair pair : buckets) {
@@ -90,7 +90,7 @@ class ArrayHashMap {
return valueSet;
}
/* ハッシュテーブルを印刷 */
/* ハッシュテーブルを出力 */
public void print() {
for (Pair kv : pairSet()) {
System.out.println(kv.key + " -> " + kv.val);
@@ -104,38 +104,38 @@ public class array_hash_map {
ArrayHashMap map = new ArrayHashMap();
/* 追加操作 */
// ハッシュテーブルにキー値ペア (key, value) を追加
map.put(12836, "Ha");
map.put(15937, "Luo");
map.put(16750, "Suan");
map.put(13276, "Fa");
map.put(10583, "Ya");
System.out.println("\n追加後のハッシュテーブル\nKey -> Value");
// ハッシュテーブルにキーと値のペア (key, value) を追加
map.put(12836, "シャオハー");
map.put(15937, "シャオルオ");
map.put(16750, "シャオスワン");
map.put(13276, "シャオファー");
map.put(10583, "シャオヤー");
System.out.println("\n追加後のハッシュ表は\nKey -> Value");
map.print();
/* クエリ操作 */
// ハッシュテーブルにキーを入力して値を取得
/* 検索操作 */
// キー key をハッシュテーブルに渡し、値 value を取得
String name = map.get(15937);
System.out.println("\n学生ID 15937を入力、名前 " + name + " を見つけました");
System.out.println("\n学籍番号 15937 を入力すると、氏名 " + name);
/* 削除操作 */
// ハッシュテーブルからキー値ペア (key, value) を削除
// ハッシュテーブルからキーと値のペア (key, value) を削除
map.remove(10583);
System.out.println("\n10583を削除後のハッシュテーブル\nKey -> Value");
System.out.println("\n10583 を削除すると、ハッシュ表は\nKey -> Value");
map.print();
/* ハッシュテーブルを走査 */
System.out.println("\nキー値ペアを走査 Key->Value");
System.out.println("\nキーと値の組 Key->Value を走査");
for (Pair kv : map.pairSet()) {
System.out.println(kv.key + " -> " + kv.val);
}
System.out.println("\nキーを個別に走査 Key");
System.out.println("\nキー Key のみを走査");
for (int key : map.keySet()) {
System.out.println(key);
}
System.out.println("\n値を個別に走査 Value");
System.out.println("\n値 Value のみを走査");
for (String val : map.valueSet()) {
System.out.println(val);
}
}
}
}

18
ja/codes/java/chapter_hashing/built_in_hash.java
View File

@@ -13,26 +13,26 @@ public class built_in_hash {
public static void main(String[] args) {
int num = 3;
int hashNum = Integer.hashCode(num);
System.out.println("整数 " + num + " のハッシュ値は " + hashNum + " です");
System.out.println("整数 " + num + " のハッシュ値は " + hashNum);
boolean bol = true;
int hashBol = Boolean.hashCode(bol);
System.out.println("ブール値 " + bol + " のハッシュ値は " + hashBol + " です");
System.out.println("真偽値 " + bol + " のハッシュ値は " + hashBol);
double dec = 3.14159;
int hashDec = Double.hashCode(dec);
System.out.println("小数 " + dec + " のハッシュ値は " + hashDec + " です");
System.out.println("小数 " + dec + " のハッシュ値は " + hashDec);
String str = "Hello algorithm";
String str = "Hello アルゴリズム";
int hashStr = str.hashCode();
System.out.println("文字列 " + str + " のハッシュ値は " + hashStr + " です");
System.out.println("文字列 " + str + " のハッシュ値は " + hashStr);
Object[] arr = { 12836, "Ha" };
Object[] arr = { 12836, "シャオハー" };
int hashTup = Arrays.hashCode(arr);
System.out.println("配列 " + Arrays.toString(arr) + " のハッシュ値は " + hashTup + " です");
System.out.println("配列 " + Arrays.toString(arr) + " のハッシュ値は " + hashTup);
ListNode obj = new ListNode(0);
int hashObj = obj.hashCode();
System.out.println("ノードオブジェクト " + obj + " のハッシュ値は " + hashObj + " です");
System.out.println("ノードオブジェクト " + obj + " のハッシュ値は " + hashObj);
}
}
}

32
ja/codes/java/chapter_hashing/hash_map.java
View File

@@ -15,38 +15,38 @@ public class hash_map {
Map<Integer, String> map = new HashMap<>();
/* 追加操作 */
// ハッシュテーブルにキー値ペア (key, value) を追加
map.put(12836, "Ha");
map.put(15937, "Luo");
map.put(16750, "Suan");
map.put(13276, "Fa");
map.put(10583, "Ya");
System.out.println("\n追加後、ハッシュテーブルは\nKey -> Value");
// ハッシュテーブルにキーと値のペア (key, value) を追加
map.put(12836, "シャオハー");
map.put(15937, "シャオルオ");
map.put(16750, "シャオスワン");
map.put(13276, "シャオファー");
map.put(10583, "シャオヤー");
System.out.println("\n追加後のハッシュ表は\nKey -> Value");
PrintUtil.printHashMap(map);
/* 検索操作 */
// ハッシュテーブルにキーを入力し、値を取得
// キー key をハッシュテーブルに渡し、値 value を取得
String name = map.get(15937);
System.out.println("\n学生番号 15937 を入力し、名前 " + name + " を見つけました");
System.out.println("\n学籍番号 15937 を入力すると、氏名 " + name);
/* 削除操作 */
// ハッシュテーブルからキー値ペア (key, value) を削除
// ハッシュテーブルからキーと値のペア (key, value) を削除
map.remove(10583);
System.out.println("\n10583 を削除後、ハッシュテーブルは\nKey -> Value");
System.out.println("\n10583 を削除すると、ハッシュ表は\nKey -> Value");
PrintUtil.printHashMap(map);
/* ハッシュテーブルの走査 */
System.out.println("\nキー値ペアを走査 Key->Value");
/* ハッシュテーブルを走査 */
System.out.println("\nキーと値の組 Key->Value を走査");
for (Map.Entry<Integer, String> kv : map.entrySet()) {
System.out.println(kv.getKey() + " -> " + kv.getValue());
}
System.out.println("\nキーを個別に走査 Key");
System.out.println("\nキー Key のみを走査");
for (int key : map.keySet()) {
System.out.println(key);
}
System.out.println("\n値を個別に走査 Value");
System.out.println("\n値 Value のみを走査");
for (String val : map.values()) {
System.out.println(val);
}
}
}
}

54
ja/codes/java/chapter_hashing/hash_map_chaining.java
View File

@@ -11,9 +11,9 @@ import java.util.List;
/* チェイン法ハッシュテーブル */
class HashMapChaining {
int size; // キー値ペアの数
int capacity; // ハッシュテーブルの容量
double loadThres; // 拡張をトリガーする負荷率の閾値
int size; // キーと値のペア数
int capacity; // ハッシュテーブル容量
double loadThres; // リサイズを発動する負荷率のしきい値
int extendRatio; // 拡張倍率
List<List<Pair>> buckets; // バケット配列
@@ -39,36 +39,36 @@ class HashMapChaining {
return (double) size / capacity;
}
/* クエリ操作 */
/* 検索操作 */
String get(int key) {
int index = hashFunc(key);
List<Pair> bucket = buckets.get(index);
// バケットを走査、キーが見つかった場合対応するvalを返す
// バケットを走査し、key が見つかれば対応する val を返す
for (Pair pair : bucket) {
if (pair.key == key) {
return pair.val;
}
}
// キーが見つからない場合、nullを返す
// key が見つからない場合は null を返す
return null;
}
/* 追加操作 */
void put(int key, String val) {
// 負荷率が閾値を超えた場合、拡張を実行
// 負荷率がしきい値を超えたら、リサイズを実行
if (loadFactor() > loadThres) {
extend();
}
int index = hashFunc(key);
List<Pair> bucket = buckets.get(index);
// バケットを走査、指定したキーに遭遇した場合、対応するvalを更新して戻る
// バケットを走査し、指定した key が見つかれば対応する val を更新して返す
for (Pair pair : bucket) {
if (pair.key == key) {
pair.val = val;
return;
}
}
// キーが見つからない場合、キー値ペアを末尾に追加
// その key が存在しなければ、キーと値のペアを末尾に追加
Pair pair = new Pair(key, val);
bucket.add(pair);
size++;
@@ -78,7 +78,7 @@ class HashMapChaining {
void remove(int key) {
int index = hashFunc(key);
List<Pair> bucket = buckets.get(index);
// バケットを走査、その中からキー値ペアを削除
// バケットを走査してキーと値のペアを削除
for (Pair pair : bucket) {
if (pair.key == key) {
bucket.remove(pair);
@@ -90,16 +90,16 @@ class HashMapChaining {
/* ハッシュテーブルを拡張 */
void extend() {
// 元のハッシュテーブルを一時的に保存
// 元のハッシュテーブルを一時保存
List<List<Pair>> bucketsTmp = buckets;
// 拡張された新しいハッシュテーブルを初期化
// リサイズ後の新しいハッシュテーブルを初期化
capacity *= extendRatio;
buckets = new ArrayList<>(capacity);
for (int i = 0; i < capacity; i++) {
buckets.add(new ArrayList<>());
}
size = 0;
// 元のハッシュテーブルから新しいハッシュテーブルにキー値ペアを移動
// キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す
for (List<Pair> bucket : bucketsTmp) {
for (Pair pair : bucket) {
put(pair.key, pair.val);
@@ -107,7 +107,7 @@ class HashMapChaining {
}
}
/* ハッシュテーブルを印刷 */
/* ハッシュテーブルを出力 */
void print() {
for (List<Pair> bucket : buckets) {
List<String> res = new ArrayList<>();
@@ -125,24 +125,24 @@ public class hash_map_chaining {
HashMapChaining map = new HashMapChaining();
/* 追加操作 */
// ハッシュテーブルにキー値ペア (key, value) を追加
map.put(12836, "Ha");
map.put(15937, "Luo");
map.put(16750, "Suan");
map.put(13276, "Fa");
map.put(10583, "Ya");
System.out.println("\n追加後のハッシュテーブル\nKey -> Value");
// ハッシュテーブルにキーと値のペア (key, value) を追加
map.put(12836, "シャオハー");
map.put(15937, "シャオルオ");
map.put(16750, "シャオスワン");
map.put(13276, "シャオファー");
map.put(10583, "シャオヤー");
System.out.println("\n追加後のハッシュ表は\nKey -> Value");
map.print();
/* クエリ操作 */
// ハッシュテーブルにキーを入力して値を取得
/* 検索操作 */
// キー key をハッシュテーブルに渡し、値 value を取得
String name = map.get(13276);
System.out.println("\n学生ID 13276を入力、名前 " + name + " を見つけました");
System.out.println("\n学籍番号 13276 を入力すると、氏名 " + name);
/* 削除操作 */
// ハッシュテーブルからキー値ペア (key, value) を削除
// ハッシュテーブルからキーと値のペア (key, value) を削除
map.remove(12836);
System.out.println("\n12836を削除後のハッシュテーブル\nKey -> Value");
System.out.println("\n12836 を削除すると、ハッシュ表は\nKey -> Value");
map.print();
}
}
}

78
ja/codes/java/chapter_hashing/hash_map_open_addressing.java
View File

@@ -8,12 +8,12 @@ package chapter_hashing;
/* オープンアドレス法ハッシュテーブル */
class HashMapOpenAddressing {
private int size; // キー値ペアの数
private int capacity = 4; // ハッシュテーブルの容量
private final double loadThres = 2.0 / 3.0; // 拡張をトリガーする負荷率の閾値
private int size; // キーと値のペア数
private int capacity = 4; // ハッシュテーブル容量
private final double loadThres = 2.0 / 3.0; // リサイズを発動する負荷率のしきい値
private final int extendRatio = 2; // 拡張倍率
private Pair[] buckets; // バケット配列
private final Pair TOMBSTONE = new Pair(-1, "-1"); // 削除マーク
private final Pair TOMBSTONE = new Pair(-1, "-1"); // 削除済みマーク
/* コンストラクタ */
public HashMapOpenAddressing() {
@@ -31,68 +31,68 @@ class HashMapOpenAddressing {
return (double) size / capacity;
}
/* keyに対応するバケットインデックスを検索 */
/* key に対応するバケットインデックスを探す */
private int findBucket(int key) {
int index = hashFunc(key);
int firstTombstone = -1;
// 線形探査、空のバケットに遭遇したら終了
// 線形プロービングを行い、空バケットに達したら終了
while (buckets[index] != null) {
// keyに遭遇した場合、対応するバケットインデックスを返す
// key が見つかったら、対応するバケットのインデックスを返す
if (buckets[index].key == key) {
// 以前に削除マークに遭遇していた場合、キー値ペアをそのインデックスに移動
// 以前に削除マークが見つかっていれば、そのインデックスへキーと値のペアを移動
if (firstTombstone != -1) {
buckets[firstTombstone] = buckets[index];
buckets[index] = TOMBSTONE;
return firstTombstone; // 移動後のバケットインデックスを返す
}
return index; // バケットインデックスを返す
return index; // バケットのインデックスを返す
}
// 最初に遭遇した削除マークを記録
// 最初に見つかった削除マークを記録
if (firstTombstone == -1 && buckets[index] == TOMBSTONE) {
firstTombstone = index;
}
// バケットインデックスを計算、末尾を超えた場合は先頭に戻る
// バケットのインデックスを計算し、末尾を越えたら先頭に戻る
index = (index + 1) % capacity;
}
// keyが存在しない場合、挿入ポイントのインデックスを返す
// key が存在しない場合は追加位置のインデックスを返す
return firstTombstone == -1 ? index : firstTombstone;
}
/* クエリ操作 */
/* 検索操作 */
public String get(int key) {
// keyに対応するバケットインデックスを検索
// key に対応するバケットインデックスを探す
int index = findBucket(key);
// キー値ペアが見つかった場合、対応するvalを返す
// キーと値の組が見つかったら、対応する val を返す
if (buckets[index] != null && buckets[index] != TOMBSTONE) {
return buckets[index].val;
}
// キー値ペアが存在しない場合、nullを返す
// キーと値の組が存在しなければ null を返す
return null;
}
/* 追加操作 */
public void put(int key, String val) {
// 負荷率が閾値を超えた場合、拡張を実行
// 負荷率がしきい値を超えたら、リサイズを実行
if (loadFactor() > loadThres) {
extend();
}
// keyに対応するバケットインデックスを検索
// key に対応するバケットインデックスを探す
int index = findBucket(key);
// キー値ペアが見つかった場合、valを上書きして戻る
// キーと値の組が見つかったら、val を上書きして返す
if (buckets[index] != null && buckets[index] != TOMBSTONE) {
buckets[index].val = val;
return;
}
// キー値ペアが存在しない場合、キー値ペアを追加
// キーと値の組が存在しない場合は、その組を追加する
buckets[index] = new Pair(key, val);
size++;
}
/* 削除操作 */
public void remove(int key) {
// keyに対応するバケットインデックスを検索
// key に対応するバケットインデックスを探す
int index = findBucket(key);
// キー値ペアが見つかった場合、削除マークで覆う
// キーと値の組が見つかったら、削除マーカーで上書きする
if (buckets[index] != null && buckets[index] != TOMBSTONE) {
buckets[index] = TOMBSTONE;
size--;
@@ -101,13 +101,13 @@ class HashMapOpenAddressing {
/* ハッシュテーブルを拡張 */
private void extend() {
// 元のハッシュテーブルを一時的に保存
// 元のハッシュテーブルを一時保存
Pair[] bucketsTmp = buckets;
// 拡張された新しいハッシュテーブルを初期化
// リサイズ後の新しいハッシュテーブルを初期化
capacity *= extendRatio;
buckets = new Pair[capacity];
size = 0;
// 元のハッシュテーブルから新しいハッシュテーブルにキー値ペアを移動
// キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す
for (Pair pair : bucketsTmp) {
if (pair != null && pair != TOMBSTONE) {
put(pair.key, pair.val);
@@ -115,7 +115,7 @@ class HashMapOpenAddressing {
}
}
/* ハッシュテーブルを印刷 */
/* ハッシュテーブルを出力 */
public void print() {
for (Pair pair : buckets) {
if (pair == null) {
@@ -135,24 +135,24 @@ public class hash_map_open_addressing {
HashMapOpenAddressing hashmap = new HashMapOpenAddressing();
// 追加操作
// ハッシュテーブルにキー値ペア (key, val) を追加
hashmap.put(12836, "Ha");
hashmap.put(15937, "Luo");
hashmap.put(16750, "Suan");
hashmap.put(13276, "Fa");
hashmap.put(10583, "Ya");
System.out.println("\n追加後のハッシュテーブル\nKey -> Value");
// ハッシュテーブルにキーと値の組 (key, val) を追加する
hashmap.put(12836, "シャオハー");
hashmap.put(15937, "シャオルオ");
hashmap.put(16750, "シャオスワン");
hashmap.put(13276, "シャオファー");
hashmap.put(10583, "シャオヤー");
System.out.println("\n追加後のハッシュ表は\nKey -> Value");
hashmap.print();
// クエリ操作
// ハッシュテーブルにキーを入力して値valを取得
// 検索操作
// ハッシュテーブルにキー key を入力し、値 val を得る
String name = hashmap.get(13276);
System.out.println("\n学生ID 13276を入力、名前 " + name + " を見つけました");
System.out.println("\n学籍番号 13276 を入力すると、氏名 " + name);
// 削除操作
// ハッシュテーブルからキー値ペア (key, val) を削除
// ハッシュテーブルからキーと値の組 (key, val) を削除する
hashmap.remove(16750);
System.out.println("\n16750を削除後のハッシュテーブル\nKey -> Value");
System.out.println("\n16750 を削除すると、ハッシュ表は\nKey -> Value");
hashmap.print();
}
}
}

14
ja/codes/java/chapter_hashing/simple_hash.java
View File

@@ -27,7 +27,7 @@ public class simple_hash {
return (int) hash;
}
/* XORハッシュ */
/* XOR ハッシュ */
static int xorHash(String key) {
int hash = 0;
final int MODULUS = 1000000007;
@@ -48,18 +48,18 @@ public class simple_hash {
}
public static void main(String[] args) {
String key = "Hello algorithm";
String key = "Hello アルゴリズム";
int hash = addHash(key);
System.out.println("加算ハッシュ値は " + hash + " です");
System.out.println("加算ハッシュ値は " + hash);
hash = mulHash(key);
System.out.println("乗算ハッシュ値は " + hash + " です");
System.out.println("乗算ハッシュ値は " + hash);
hash = xorHash(key);
System.out.println("XORハッシュ値は " + hash + " です");
System.out.println("XOR ハッシュ値は " + hash);
hash = rotHash(key);
System.out.println("回転ハッシュ値は " + hash + " です");
System.out.println("回転ハッシュ値は " + hash);
}
}
}

28
ja/codes/java/chapter_heap/heap.java
View File

@@ -11,14 +11,14 @@ import java.util.*;
public class heap {
public static void testPush(Queue<Integer> heap, int val) {
heap.offer(val); // 要素をヒープにプッシュ
System.out.format("\n要素 %d をヒープに追加後\n", val);
heap.offer(val); // 要素をヒープに追加
System.out.format("\n要素 %d をヒープに追加した後\n", val);
PrintUtil.printHeap(heap);
}
public static void testPop(Queue<Integer> heap) {
int val = heap.poll(); // ヒープの先頭要素をポップ
System.out.format("\n先頭要素 %d をヒープから削除後\n", val);
int val = heap.poll(); // ヒープ頂点の要素を取り出す
System.out.format("\nヒープトップ要素 %d を取り出した後\n", val);
PrintUtil.printHeap(heap);
}
@@ -26,23 +26,23 @@ public class heap {
/* ヒープを初期化 */
// 最小ヒープを初期化
Queue<Integer> minHeap = new PriorityQueue<>();
// 最大ヒープを初期化（必要に応じてラムダ式を使用してComparatorを変更）
// 最大ヒープを初期化する（lambda 式で Comparator を変更すればよい）
Queue<Integer> maxHeap = new PriorityQueue<>((a, b) -> b - a);
System.out.println("\n以下のテストケースは最大ヒープ用です");
System.out.println("\n以下のテストケースは最大ヒープ");
/* 要素をヒープにプッシュ */
/* 要素をヒープに追加 */
testPush(maxHeap, 1);
testPush(maxHeap, 3);
testPush(maxHeap, 2);
testPush(maxHeap, 5);
testPush(maxHeap, 4);
/* ヒープの先頭要素にアクセス */
/* ヒープ頂点の要素を取得 */
int peek = maxHeap.peek();
System.out.format("\nヒープの先頭要素は %d\n", peek);
System.out.format("\nヒープトップ要素は %d\n", peek);
/* ヒープの先頭要素をポップ */
/* ヒープ頂点の要素を取り出す */
testPop(maxHeap);
testPop(maxHeap);
testPop(maxHeap);
@@ -55,12 +55,12 @@ public class heap {
/* ヒープが空かどうかを判定 */
boolean isEmpty = maxHeap.isEmpty();
System.out.format("\nヒープは空ですか %b\n", isEmpty);
System.out.format("\nヒープが空かどうかは %b\n", isEmpty);
/* リストを入力してヒープを構築 */
// 時間計算量は O(n)、O(nlogn) ではない
// 時間計算量は O(n) であり、O(nlogn) ではない
minHeap = new PriorityQueue<>(Arrays.asList(1, 3, 2, 5, 4));
System.out.println("\nリストを入力して最小ヒープを構築");
System.out.println("\nリストを入力して最小ヒープを構築した後");
PrintUtil.printHeap(minHeap);
}
}
}

62
ja/codes/java/chapter_heap/my_heap.java
View File

@@ -11,32 +11,32 @@ import java.util.*;
/* 最大ヒープ */
class MaxHeap {
// リサイズの必要性を避けるため、配列の代わりにリストを使用
// 配列ではなくリストを使うことで、拡張を考慮する必要がない
private List<Integer> maxHeap;
/* コンストラクタ、入力リストに基づいてヒープを構築 */
/* コンストラクタ。入力リストに基づいてヒープを構築する */
public MaxHeap(List<Integer> nums) {
// すべてのリスト要素をヒープに追加
// リスト要素をそのままヒープに追加
maxHeap = new ArrayList<>(nums);
// 葉を除くすべてのノードをヒープ化
// 葉ノード以外のすべてのノードをヒープ化
for (int i = parent(size() - 1); i >= 0; i--) {
siftDown(i);
}
}
/* 左の子ノードのインデックスを取得 */
/* 左子ノードのインデックスを取得 */
private int left(int i) {
return 2 * i + 1;
}
/* 右の子ノードのインデックスを取得 */
/* 右子ノードのインデックスを取得 */
private int right(int i) {
return 2 * i + 2;
}
/* 親ノードのインデックスを取得 */
private int parent(int i) {
return (i - 1) / 2; // 整数除算で切り下げ
return (i - 1) / 2; // 切り捨て除算
}
/* 要素を交換 */
@@ -56,12 +56,12 @@ class MaxHeap {
return size() == 0;
}
/* ヒープの先頭要素にアクセス */
/* ヒープ先頭要素にアクセス */
public int peek() {
return maxHeap.get(0);
}
/* 要素をヒープにプッシュ */
/* 要素をヒープに追加 */
public void push(int val) {
// ノードを追加
maxHeap.add(val);
@@ -69,51 +69,51 @@ class MaxHeap {
siftUp(size() - 1);
}
/* ノード i から上向きにヒープ化を開始 */
/* ノード i から始めて、下から上へヒープ化 */
private void siftUp(int i) {
while (true) {
// ノード i の親ノードを取得
int p = parent(i);
// 「根ノードを越える」または「ノードが修復不要」の場合、ヒープ化を終了
// 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了
if (p < 0 || maxHeap.get(i) <= maxHeap.get(p))
break;
// 2つのノードを交換
// 2 つのノードを交換
swap(i, p);
// 上向きにヒープ化をループ
// ループで下から上へヒープ化
i = p;
}
}
/* 要素がヒープから退出 */
/* 要素をヒープから取り出す */
public int pop() {
// 空の処理
// 空判定の処理
if (isEmpty())
throw new IndexOutOfBoundsException();
// 根ノードを最も右の葉ノードと交換（最初の要素を最後の要素と交換）
// 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）
swap(0, size() - 1);
// ノードを削除
int val = maxHeap.remove(size() - 1);
// 上から下へヒープ化
siftDown(0);
// ヒープの先頭要素を返す
// ヒープ先頭要素を返す
return val;
}
/* ノード i から下向きにヒープ化を開始 */
/* ノード i から始めて、上から下へヒープ化 */
private void siftDown(int i) {
while (true) {
// i、l、r の中で最大のノードを決定し、ma とする
// ノード i, l, r のうち値が最大のノードを ma とする
int l = left(i), r = right(i), ma = i;
if (l < size() && maxHeap.get(l) > maxHeap.get(ma))
ma = l;
if (r < size() && maxHeap.get(r) > maxHeap.get(ma))
ma = r;
// ノード i が最大の場合、またはインデックス l、r が範囲外の場合、さらなるヒープ化は不要、終了
// ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける
if (ma == i)
break;
// 2つのノードを交換
// 2 つのノードを交換
swap(i, ma);
// 下向きにヒープ化をループ
// ループで上から下へヒープ化
i = ma;
}
}
@@ -130,22 +130,22 @@ public class my_heap {
public static void main(String[] args) {
/* 最大ヒープを初期化 */
MaxHeap maxHeap = new MaxHeap(Arrays.asList(9, 8, 6, 6, 7, 5, 2, 1, 4, 3, 6, 2));
System.out.println("\nリストを入力してヒープを構築");
System.out.println("\nリストを入力してヒープを構築した後");
maxHeap.print();
/* ヒープの先頭要素にアクセス */
/* ヒープ頂点の要素を取得 */
int peek = maxHeap.peek();
System.out.format("\nヒープの先頭要素は %d\n", peek);
System.out.format("\nヒープトップ要素は %d\n", peek);
/* 要素をヒープにプッシュ */
/* 要素をヒープに追加 */
int val = 7;
maxHeap.push(val);
System.out.format("\n要素 %d をヒープに追加後\n", val);
System.out.format("\n要素 %d をヒープに追加した後\n", val);
maxHeap.print();
/* ヒープの先頭要素をポップ */
/* ヒープ頂点の要素を取り出す */
peek = maxHeap.pop();
System.out.format("\n先頭要素 %d をヒープから削除後\n", peek);
System.out.format("\nヒープトップ要素 %d を取り出した後\n", peek);
maxHeap.print();
/* ヒープのサイズを取得 */
@@ -154,6 +154,6 @@ public class my_heap {
/* ヒープが空かどうかを判定 */
boolean isEmpty = maxHeap.isEmpty();
System.out.format("\nヒープは空ですか %b\n", isEmpty);
System.out.format("\nヒープが空かどうかは %b\n", isEmpty);
}
}
}

12
ja/codes/java/chapter_heap/top_k.java
View File

@@ -10,17 +10,17 @@ import utils.*;
import java.util.*;
public class top_k {
/* ヒープを使用して配列内の最大 k 個の要素を検索 */
/* ヒープに基づいて配列中の最大の k 個の要素を探す */
static Queue<Integer> topKHeap(int[] nums, int k) {
// 最小ヒープを初期化
Queue<Integer> heap = new PriorityQueue<Integer>();
// 配列の最初の k 個の要素をヒープに入力
// 配列の先頭 k 個の要素をヒープに追加
for (int i = 0; i < k; i++) {
heap.offer(nums[i]);
}
// k+1 番目の要素から、ヒープの長さを k に保つ
// k+1 番目の要素から開始し、ヒープ長を k に保つ
for (int i = k; i < nums.length; i++) {
// 現在の要素がヒープの先頭要素より大きい場合、ヒープの先頭要素を削除し、現在の要素をヒープに入力
// 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する
if (nums[i] > heap.peek()) {
heap.poll();
heap.offer(nums[i]);
@@ -34,7 +34,7 @@ public class top_k {
int k = 3;
Queue<Integer> res = topKHeap(nums, k);
System.out.println("最大 " + k + " 個の要素は");
System.out.println("最大の " + k + " 個の要素は");
PrintUtil.printHeap(res);
}
}
}

34
ja/codes/java/chapter_searching/binary_search.java
View File

@@ -7,39 +7,39 @@
package chapter_searching;
public class binary_search {
/* 二分探索（両端閉区間） */
/* 二分探索（両閉区間） */
static int binarySearch(int[] nums, int target) {
// 両端閉区間 [0, n-1] を初期化、すなわち i, j はそれぞれ配列の最初の要素と最後の要素を指す
// 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す
int i = 0, j = nums.length - 1;
// 探索区間が空になるまでループ（i > j のとき空）
// ループし、探索区間が空になったら終了する（i > j で空）
while (i <= j) {
int m = i + (j - i) / 2; // 中点インデックス m を計算
if (nums[m] < target) // この状況は target が区間 [m+1, j] にあることを示す
if (nums[m] < target) // この場合、target は区間 [m+1, j] にある
i = m + 1;
else if (nums[m] > target) // この状況は target が区間 [i, m-1] にあることを示す
else if (nums[m] > target) // この場合、target は区間 [i, m-1] にある
j = m - 1;
else // 目標要素を見つけたので、そのインデックスを返す
else // 目標要素が見つかったらそのインデックスを返す
return m;
}
// 目標要素を見つけられなかったので、-1 を返す
// 目標要素が見つからなければ -1 を返す
return -1;
}
/* 二分探索（左閉右開区間） */
static int binarySearchLCRO(int[] nums, int target) {
// 左閉右開区間 [0, n) を初期化、すなわち i, j はそれぞれ配列の最初の要素と最後の要素+1を指す
// 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す
int i = 0, j = nums.length;
// 探索区間が空になるまでループ（i = j のとき空）
// ループし、探索区間が空になったら終了する（i = j で空）
while (i < j) {
int m = i + (j - i) / 2; // 中点インデックス m を計算
if (nums[m] < target) // この状況は target が区間 [m+1, j) にあることを示す
if (nums[m] < target) // この場合、target は区間 [m+1, j) にある
i = m + 1;
else if (nums[m] > target) // この状況は target が区間 [i, m) にあることを示す
else if (nums[m] > target) // この場合、target は区間 [i, m) にある
j = m;
else // 目標要素を見つけたので、そのインデックスを返す
else // 目標要素が見つかったらそのインデックスを返す
return m;
}
// 目標要素を見つけられなかったので、-1 を返す
// 目標要素が見つからなければ -1 を返す
return -1;
}
@@ -47,12 +47,12 @@ public class binary_search {
int target = 6;
int[] nums = { 1, 3, 6, 8, 12, 15, 23, 26, 31, 35 };
/* 二分探索（両端閉区間） */
/* 二分探索（両閉区間） */
int index = binarySearch(nums, target);
System.out.println("目標要素 6 のインデックス = " + index);
System.out.println("対象要素 6 のインデックス = " + index);
/* 二分探索（左閉右開区間） */
index = binarySearchLCRO(nums, target);
System.out.println("目標要素 6 のインデックス = " + index);
System.out.println("対象要素 6 のインデックス = " + index);
}
}
}

20
ja/codes/java/chapter_searching/binary_search_edge.java
View File

@@ -9,27 +9,27 @@ package chapter_searching;
public class binary_search_edge {
/* 最も左の target を二分探索 */
static int binarySearchLeftEdge(int[] nums, int target) {
// target の挿入点を見つけることと等価
// target の挿入位置を探すのと等価
int i = binary_search_insertion.binarySearchInsertion(nums, target);
// target を見つけられなかったので、-1 を返す
// target が見つからなければ、-1 を返す
if (i == nums.length || nums[i] != target) {
return -1;
}
// target を見つけたので、インデックス i を返す
// target が見つかったら、インデックス i を返す
return i;
}
/* 最も右の target を二分探索 */
static int binarySearchRightEdge(int[] nums, int target) {
// 最も左の target + 1 を見つけることに変換
// 最左の target + 1 を探す問題に変換する
int i = binary_search_insertion.binarySearchInsertion(nums, target + 1);
// j は最も右の target を指し、i は target より大きい最初の要素を指す
int j = i - 1;
// target を見つけられなかったので、-1 を返す
// target が見つからなければ、-1 を返す
if (j == -1 || nums[j] != target) {
return -1;
}
// target を見つけたので、インデックス j を返す
// target が見つかったら、インデックス j を返す
return j;
}
@@ -38,12 +38,12 @@ public class binary_search_edge {
int[] nums = { 1, 3, 6, 6, 6, 6, 6, 10, 12, 15 };
System.out.println("\n配列 nums = " + java.util.Arrays.toString(nums));
// 左右の境界を二分探索
// 二分探索で左端と右端を探す
for (int target : new int[] { 6, 7 }) {
int index = binarySearchLeftEdge(nums, target);
System.out.println("要素 " + target + " の最も左のインデックスは " + index);
System.out.println("一番左の要素 " + target + " のインデックスは " + index);
index = binarySearchRightEdge(nums, target);
System.out.println("要素 " + target + " の最も右のインデックスは " + index);
System.out.println("一番右の要素 " + target + " のインデックスは " + index);
}
}
}
}

26
ja/codes/java/chapter_searching/binary_search_insertion.java
View File

@@ -7,9 +7,9 @@
package chapter_searching;
class binary_search_insertion {
/* 挿入点の二分探索（重複要素なし） */
/* 二分探索で挿入位置を探す（重複要素なし） */
static int binarySearchInsertionSimple(int[] nums, int target) {
int i = 0, j = nums.length - 1; // 両端閉区間 [0, n-1] を初期化
int i = 0, j = nums.length - 1; // 両閉区間 [0, n-1] を初期化
while (i <= j) {
int m = i + (j - i) / 2; // 中点インデックス m を計算
if (nums[m] < target) {
@@ -17,16 +17,16 @@ class binary_search_insertion {
} else if (nums[m] > target) {
j = m - 1; // target は区間 [i, m-1] にある
} else {
return m; // target を見つけたので、挿入点 m を返す
return m; // target が見つかったら、挿入位置 m を返す
}
}
// target を見つけられなかったので、挿入点 i を返す
// target が見つからなければ、挿入位置 i を返す
return i;
}
/* 挿入点の二分探索（重複要素あり） */
/* 二分探索で挿入位置を探す（重複要素あり） */
static int binarySearchInsertion(int[] nums, int target) {
int i = 0, j = nums.length - 1; // 両端閉区間 [0, n-1] を初期化
int i = 0, j = nums.length - 1; // 両閉区間 [0, n-1] を初期化
while (i <= j) {
int m = i + (j - i) / 2; // 中点インデックス m を計算
if (nums[m] < target) {
@@ -37,7 +37,7 @@ class binary_search_insertion {
j = m - 1; // target より小さい最初の要素は区間 [i, m-1] にある
}
}
// 挿入点 i を返す
// 挿入位置 i を返す
return i;
}
@@ -45,19 +45,19 @@ class binary_search_insertion {
// 重複要素のない配列
int[] nums = { 1, 3, 6, 8, 12, 15, 23, 26, 31, 35 };
System.out.println("\n配列 nums = " + java.util.Arrays.toString(nums));
// 挿入点の二分探索
// 二分探索で挿入位置を探す
for (int target : new int[] { 6, 9 }) {
int index = binarySearchInsertionSimple(nums, target);
System.out.println("要素 " + target + " の挿入点インデックスは " + index);
System.out.println("要素 " + target + " の挿入位置のインデックスは " + index);
}
// 重複要素のある配列
// 重複要素を含む配列
nums = new int[] { 1, 3, 6, 6, 6, 6, 6, 10, 12, 15 };
System.out.println("\n配列 nums = " + java.util.Arrays.toString(nums));
// 挿入点の二分探索
// 二分探索で挿入位置を探す
for (int target : new int[] { 2, 6, 20 }) {
int index = binarySearchInsertion(nums, target);
System.out.println("要素 " + target + " の挿入点インデックスは " + index);
System.out.println("要素 " + target + " の挿入位置のインデックスは " + index);
}
}
}
}

18
ja/codes/java/chapter_searching/hashing_search.java
View File

@@ -12,15 +12,15 @@ import java.util.*;
public class hashing_search {
/* ハッシュ探索（配列） */
static int hashingSearchArray(Map<Integer, Integer> map, int target) {
// ハッシュテーブルのキー: 目標要素、値: インデックス
// ハッシュテーブルにこのキーが含まれていない場合、-1 を返す
// ハッシュテーブルの key: 目標要素、value: インデックス
// ハッシュテーブルにこの key がなければ -1 を返す
return map.getOrDefault(target, -1);
}
/* ハッシュ探索（連結リスト） */
static ListNode hashingSearchLinkedList(Map<Integer, ListNode> map, int target) {
// ハッシュテーブルのキー: 目標ノードの値、値: ノードオブジェクト
// キーがハッシュテーブルにない場合、null を返す
// ハッシュテーブルの key: 目標ノード値、value: ノードオブジェクト
// ハッシュテーブルにこの key がなければ null を返す
return map.getOrDefault(target, null);
}
@@ -32,20 +32,20 @@ public class hashing_search {
// ハッシュテーブルを初期化
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
map.put(nums[i], i); // キー: 要素、値: インデックス
map.put(nums[i], i); // key: 要素、value: インデックス
}
int index = hashingSearchArray(map, target);
System.out.println("目標要素 3 のインデックスは " + index);
System.out.println("対象要素 3 のインデックス = " + index);
/* ハッシュ探索（連結リスト） */
ListNode head = ListNode.arrToLinkedList(nums);
// ハッシュテーブルを初期化
Map<Integer, ListNode> map1 = new HashMap<>();
while (head != null) {
map1.put(head.val, head); // キー: ノードの値、値: ノード
map1.put(head.val, head); // key: ノード値、value: ノード
head = head.next;
}
ListNode node = hashingSearchLinkedList(map1, target);
System.out.println("目標ノード値 3 に対応するノードオブジェクトは " + node);
System.out.println("対象ノード値 3 に対応するノードオブジェクトは " + node);
}
}
}

20
ja/codes/java/chapter_searching/linear_search.java
View File

@@ -13,38 +13,38 @@ public class linear_search {
static int linearSearchArray(int[] nums, int target) {
// 配列を走査
for (int i = 0; i < nums.length; i++) {
// 目標要素を見つけたので、そのインデックスを返す
// 目標要素が見つかったらそのインデックスを返す
if (nums[i] == target)
return i;
}
// 目標要素を見つけられなかったので、-1 を返す
// 目標要素が見つからなければ -1 を返す
return -1;
}
/* 線形探索（連結リスト） */
static ListNode linearSearchLinkedList(ListNode head, int target) {
// リストを走査
// 連結リストを走査
while (head != null) {
// 目標ノードを見つけたので、それを返す
// 対象ノードが見つかったら、それを返す
if (head.val == target)
return head;
head = head.next;
}
// 目標ノードが見つからない場合、null を返す
// 対象ノードが見つからない場合は null を返す
return null;
}
public static void main(String[] args) {
int target = 3;
/* 配列で線形探索を実行 */
/* 配列で線形探索を行う */
int[] nums = { 1, 5, 3, 2, 4, 7, 5, 9, 10, 8 };
int index = linearSearchArray(nums, target);
System.out.println("目標要素 3 のインデックスは " + index);
System.out.println("対象要素 3 のインデックス = " + index);
/* 連結リストで線形探索を実行 */
/* 連結リストで線形探索を行う */
ListNode head = ListNode.arrToLinkedList(nums);
ListNode node = linearSearchLinkedList(head, target);
System.out.println("目標ノード値 3 に対応するノードオブジェクトは " + node);
System.out.println("対象ノード値 3 に対応するノードオブジェクトは " + node);
}
}
}

24
ja/codes/java/chapter_searching/two_sum.java
View File

@@ -9,10 +9,10 @@ package chapter_searching;
import java.util.*;
public class two_sum {
/* 方法一: 暴力列挙 */
/* 方法 1：総当たり列挙 */
static int[] twoSumBruteForce(int[] nums, int target) {
int size = nums.length;
// 二重ループ、時間計算量は O(n^2)
// 2重ループのため、時間計算量は O(n^2)
for (int i = 0; i < size - 1; i++) {
for (int j = i + 1; j < size; j++) {
if (nums[i] + nums[j] == target)
@@ -22,12 +22,12 @@ public class two_sum {
return new int[0];
}
/* 方法二: 補助ハッシュテーブル */
/* 方法 2：補助ハッシュテーブル */
static int[] twoSumHashTable(int[] nums, int target) {
int size = nums.length;
// 補助ハッシュテーブル、空間計算量は O(n)
// 補助ハッシュテーブルを使用し、空間計算量は O(n)
Map<Integer, Integer> dic = new HashMap<>();
// 単一層ループ、時間計算量は O(n)
// 単一ループで、時間計算量は O(n)
for (int i = 0; i < size; i++) {
if (dic.containsKey(target - nums[i])) {
return new int[] { dic.get(target - nums[i]), i };
@@ -38,16 +38,16 @@ public class two_sum {
}
public static void main(String[] args) {
// ======= テストケース =======
// ======= Test Case =======
int[] nums = { 2, 7, 11, 15 };
int target = 13;
// ====== ドライバーコード ======
// 方法一
// ====== Driver Code ======
// 方法 1
int[] res = twoSumBruteForce(nums, target);
System.out.println("方法一 res = " + Arrays.toString(res));
// 方法二
System.out.println("方法1 res = " + Arrays.toString(res));
// 方法 2
res = twoSumHashTable(nums, target);
System.out.println("方法二 res = " + Arrays.toString(res));
System.out.println("方法2 res = " + Arrays.toString(res));
}
}
}

22
ja/codes/java/chapter_sorting/bubble_sort.java
View File

@@ -11,9 +11,9 @@ import java.util.*;
public class bubble_sort {
/* バブルソート */
static void bubbleSort(int[] nums) {
// 外側ループ: 未ソート範囲は [0, i]
// 外側のループ：未ソート区間は [0, i]
for (int i = nums.length - 1; i > 0; i--) {
// 内側ループ: 未ソート範囲 [0, i] の最大要素を範囲の右端に交換
// 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換
for (int j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// nums[j] と nums[j + 1] を交換
@@ -25,33 +25,33 @@ public class bubble_sort {
}
}
/* バブルソート（フラグによる最適化） */
/* バブルソート（フラグ最適化） */
static void bubbleSortWithFlag(int[] nums) {
// 外側ループ: 未ソート範囲は [0, i]
// 外側のループ：未ソート区間は [0, i]
for (int i = nums.length - 1; i > 0; i--) {
boolean flag = false; // フラグを初期化
// 内側ループ: 未ソート範囲 [0, i] の最大要素を範囲の右端に交換
boolean flag = false; // フラグを初期化する
// 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換
for (int j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// nums[j] と nums[j + 1] を交換
int tmp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = tmp;
flag = true; // 交換された要素を記録
flag = true; // 交換する要素を記録
}
}
if (!flag)
break; // この「バブリング」ラウンドで要素が交換されなかった場合、終了
break; // このバブル処理で要素交換が一度もなければそのまま終了
}
}
public static void main(String[] args) {
int[] nums = { 4, 1, 3, 1, 5, 2 };
bubbleSort(nums);
System.out.println("バブルソート後、nums = " + Arrays.toString(nums));
System.out.println("バブルソート完了後の nums = " + Arrays.toString(nums));
int[] nums1 = { 4, 1, 3, 1, 5, 2 };
bubbleSortWithFlag(nums1);
System.out.println("バブルソート後、nums1 = " + Arrays.toString(nums1));
System.out.println("バブルソート完了後の nums1 = " + Arrays.toString(nums1));
}
}
}

18
ja/codes/java/chapter_sorting/bucket_sort.java
View File

@@ -11,25 +11,25 @@ import java.util.*;
public class bucket_sort {
/* バケットソート */
static void bucketSort(float[] nums) {
// k = n/2 個のバケットを初期化、各バケットに期待される要素数は 2 個
// k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする
int k = nums.length / 2;
List<List<Float>> buckets = new ArrayList<>();
for (int i = 0; i < k; i++) {
buckets.add(new ArrayList<>());
}
// 1. 配列要素を各バケットに分散
// 1. 配列要素を各バケットに振り分ける
for (float num : nums) {
// 入力データ範囲は [0, 1)、num * k を使ってインデックス範囲 [0, k-1] にマッピング
// 入力データの範囲は [0, 1) であり、num * k を用いてインデックス範囲 [0, k-1] に写像する
int i = (int) (num * k);
// num をバケット i に追加
buckets.get(i).add(num);
}
// 2. 各バケットをソート
// 2. 各バケットをソートする
for (List<Float> bucket : buckets) {
// 組み込みソート関数を使用、他のソートアルゴリズムに置き換えることも可能
// 組み込みのソート関数を使う。他のソートアルゴリズムに置き換えてもよい
Collections.sort(bucket);
}
// 3. バケットを走査して結果をマージ
// 3. バケットを走査して結果を結合
int i = 0;
for (List<Float> bucket : buckets) {
for (float num : bucket) {
@@ -39,9 +39,9 @@ public class bucket_sort {
}
public static void main(String[] args) {
// 入力データが浮動小数点、範囲 [0, 1) と仮定
// 入力データは範囲 [0, 1) の浮動小数点数とする
float[] nums = { 0.49f, 0.96f, 0.82f, 0.09f, 0.57f, 0.43f, 0.91f, 0.75f, 0.15f, 0.37f };
bucketSort(nums);
System.out.println("バケットソート後、nums = " + Arrays.toString(nums));
System.out.println("バケットソート完了後の nums = " + Arrays.toString(nums));
}
}
}

32
ja/codes/java/chapter_sorting/counting_sort.java
View File

@@ -10,20 +10,20 @@ import java.util.*;
public class counting_sort {
/* 計数ソート */
// 簡単な実装、オブジェクトのソートには使用できない
// 簡易実装のため、オブジェクトのソートには使えない
static void countingSortNaive(int[] nums) {
// 1. 配列の最大要素 m を統計
// 1. 配列の最大要素 m を求める
int m = 0;
for (int num : nums) {
m = Math.max(m, num);
}
// 2. 各数字の出現回数を統計
// 2. 各数値の出現回数を数える
// counter[num] は num の出現回数を表す
int[] counter = new int[m + 1];
for (int num : nums) {
counter[num]++;
}
// 3. counter を走査し、各要素を元の配列 nums に戻す
// 3. counter を走査し、各要素を元の配列 nums に書き戻す
int i = 0;
for (int num = 0; num < m + 1; num++) {
for (int j = 0; j < counter[num]; j++, i++) {
@@ -33,34 +33,34 @@ public class counting_sort {
}
/* 計数ソート */
// 完全な実装、オブジェクトをソートでき、安定ソート
// 完全な実装で、オブジェクトをソートでき、かつ安定ソートである
static void countingSort(int[] nums) {
// 1. 配列の最大要素 m を統計
// 1. 配列の最大要素 m を求める
int m = 0;
for (int num : nums) {
m = Math.max(m, num);
}
// 2. 各数字の出現回数を統計
// 2. 各数値の出現回数を数える
// counter[num] は num の出現回数を表す
int[] counter = new int[m + 1];
for (int num : nums) {
counter[num]++;
}
// 3. counter の累積和を計算し、「出現回数」を「尻尾インデックス」に変換
// counter[num]-1 は res 内で num が出現する最後のインデックス
// 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する
// つまり counter[num]-1 は、num が res に最後に現れるインデックス
for (int i = 0; i < m; i++) {
counter[i + 1] += counter[i];
}
// 4. nums を逆順に走査し、各要素を結果配列 res に配置
// 結果を記録する配列 res を初期化
// 4. nums を逆順に走査し、各要素を結果配列 res に格納する
// 結果を記録するための配列 res を初期化
int n = nums.length;
int[] res = new int[n];
for (int i = n - 1; i >= 0; i--) {
int num = nums[i];
res[counter[num] - 1] = num; // num を対応するインデックスに配置
counter[num]--; // 累積和を 1 減算し、num を配置する次のインデックスを取得
counter[num]--; // 累積和を 1 減らして、次に num を配置するインデックスを得る
}
// 結果配列 res を使って元の配列 nums を上書き
// 結果配列 res で元の配列 nums を上書きする
for (int i = 0; i < n; i++) {
nums[i] = res[i];
}
@@ -69,10 +69,10 @@ public class counting_sort {
public static void main(String[] args) {
int[] nums = { 1, 0, 1, 2, 0, 4, 0, 2, 2, 4 };
countingSortNaive(nums);
System.out.println("計数ソート後（オブジェクトソート不可）、nums = " + Arrays.toString(nums));
System.out.println("カウントソート（オブジェクトはソート不可）完了後の nums = " + Arrays.toString(nums));
int[] nums1 = { 1, 0, 1, 2, 0, 4, 0, 2, 2, 4 };
countingSort(nums1);
System.out.println("計数ソート後、nums1 = " + Arrays.toString(nums1));
System.out.println("カウントソート完了後の nums1 = " + Arrays.toString(nums1));
}
}
}

22
ja/codes/java/chapter_sorting/heap_sort.java
View File

@@ -9,10 +9,10 @@ package chapter_sorting;
import java.util.Arrays;
public class heap_sort {
/* ヒープの長さは n、ノード i から上から下へヒープ化開始 */
/* ヒープの長さは n。ノード i から下方向にヒープ化 */
public static void siftDown(int[] nums, int n, int i) {
while (true) {
// i, l, r の中で最大のノードを判定し、ma とする
// ノード i, l, r のうち値が最大のノードを ma とする
int l = 2 * i + 1;
int r = 2 * i + 2;
int ma = i;
@@ -20,31 +20,31 @@ public class heap_sort {
ma = l;
if (r < n && nums[r] > nums[ma])
ma = r;
// ノード i が最大、またはインデックス l, r が範囲外の場合、さらなるヒープ化は不要、ブレーク
// ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける
if (ma == i)
break;
// 2つのノードを交換
// 2 つのノードを交換
int temp = nums[i];
nums[i] = nums[ma];
nums[ma] = temp;
// 下向きにヒープ化をループ
// ループで上から下へヒープ化
i = ma;
}
}
/* ヒープソート */
public static void heapSort(int[] nums) {
// ヒープ構築操作: 葉ノード以外のすべてのノードをヒープ化
// ヒープ構築：葉ノード以外のすべてのノードをヒープ化する
for (int i = nums.length / 2 - 1; i >= 0; i--) {
siftDown(nums, nums.length, i);
}
// ヒープから最大要素を抽出し、n-1 回繰り返し
// ヒープから最大要素を取り出し、n-1 回繰り返す
for (int i = nums.length - 1; i > 0; i--) {
// ルートノードと最も右の葉ノードを交換（最初の要素と最後の要素を交換）
// 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）
int tmp = nums[0];
nums[0] = nums[i];
nums[i] = tmp;
// ルートノードから上から下へヒープ化開始
// 根ノードを起点に、上から下へヒープ化
siftDown(nums, i, 0);
}
}
@@ -52,6 +52,6 @@ public class heap_sort {
public static void main(String[] args) {
int[] nums = { 4, 1, 3, 1, 5, 2 };
heapSort(nums);
System.out.println("ヒープソート後、nums = " + Arrays.toString(nums));
System.out.println("ヒープソート完了後の nums = " + Arrays.toString(nums));
}
}
}

12
ja/codes/java/chapter_sorting/insertion_sort.java
View File

@@ -11,21 +11,21 @@ import java.util.*;
public class insertion_sort {
/* 挿入ソート */
static void insertionSort(int[] nums) {
// 外側ループ: ソート済み範囲は [0, i-1]
// 外側ループ：整列済み区間は [0, i-1]
for (int i = 1; i < nums.length; i++) {
int base = nums[i], j = i - 1;
// 内側ループ: base をソート済み範囲 [0, i-1] の正しい位置に挿入
// 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する
while (j >= 0 && nums[j] > base) {
nums[j + 1] = nums[j]; // nums[j] を右に1つ移動
nums[j + 1] = nums[j]; // nums[j] を 1 つ右へ移動する
j--;
}
nums[j + 1] = base; // base を正しい位置に代入
nums[j + 1] = base; // base を正しい位置に配置する
}
}
public static void main(String[] args) {
int[] nums = { 4, 1, 3, 1, 5, 2 };
insertionSort(nums);
System.out.println("挿入ソート後、nums = " + Arrays.toString(nums));
System.out.println("挿入ソート完了後の nums = " + Arrays.toString(nums));
}
}
}

26
ja/codes/java/chapter_sorting/merge_sort.java
View File

@@ -11,26 +11,26 @@ import java.util.*;
public class merge_sort {
/* 左部分配列と右部分配列をマージ */
static void merge(int[] nums, int left, int mid, int right) {
// 左部分配列区間は [left, mid]、右部分配列区間は [mid+1, right]
// 一時配列 tmp を作成してマージ結果を格納
// 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]
// マージ結果を格納する一時配列 tmp を作成
int[] tmp = new int[right - left + 1];
// 左右部分配列の開始インデックスを初期化
// 左右の部分配列の開始インデックスを初期化する
int i = left, j = mid + 1, k = 0;
// 両部分配列にまだ要素がある間、比較してより小さい要素を一時配列にコピー
// 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする
while (i <= mid && j <= right) {
if (nums[i] <= nums[j])
tmp[k++] = nums[i++];
else
tmp[k++] = nums[j++];
}
// 左右部分配列の残りの要素を一時配列にコピー
// 左右の部分配列の残り要素を一時配列にコピーする
while (i <= mid) {
tmp[k++] = nums[i++];
}
while (j <= right) {
tmp[k++] = nums[j++];
}
// 一時配列 tmp の要素を元の配列 nums の対応する区間にコピーバック
// 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする
for (k = 0; k < tmp.length; k++) {
nums[left + k] = tmp[k];
}
@@ -40,12 +40,12 @@ public class merge_sort {
static void mergeSort(int[] nums, int left, int right) {
// 終了条件
if (left >= right)
return; // 部分配列の長さが 1 のとき再帰を終了
// 分割段階
return; // 部分配列の長さが 1 になったら再帰を終了
// 分割フェーズ
int mid = left + (right - left) / 2; // 中点を計算
mergeSort(nums, left, mid); // 左部分配列を再帰的に処理
mergeSort(nums, mid + 1, right); // 右部分配列を再帰的に処理
// マージ段階
mergeSort(nums, left, mid); // 左部分配列を再帰処理
mergeSort(nums, mid + 1, right); // 右部分配列を再帰処理
// マージフェーズ
merge(nums, left, mid, right);
}
@@ -53,6 +53,6 @@ public class merge_sort {
/* マージソート */
int[] nums = { 7, 3, 2, 6, 0, 1, 5, 4 };
mergeSort(nums, 0, nums.length - 1);
System.out.println("マージソート後、nums = " + Arrays.toString(nums));
System.out.println("マージソート完了後の nums = " + Arrays.toString(nums));
}
}
}

88
ja/codes/java/chapter_sorting/quick_sort.java
View File

@@ -10,51 +10,51 @@ import java.util.*;
/* クイックソートクラス */
class QuickSort {
/* 要素を交換 */
/* 要素の交換 */
static void swap(int[] nums, int i, int j) {
int tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
/* 分割 */
/* 番兵分割 */
static int partition(int[] nums, int left, int right) {
// nums[left] を基準値として使用
// nums[left] を基準値とする
int i = left, j = right;
while (i < j) {
while (i < j && nums[j] >= nums[left])
j--; // 右から左へ、基準値より小さい最初の要素を検索
j--; // 右から左へ基準値未満の最初の要素を探す
while (i < j && nums[i] <= nums[left])
i++; // 左から右へ、基準値より大きい最初の要素を検索
swap(nums, i, j); // これら2つの要素を交換
i++; // 左から右へ基準値より大きい最初の要素を探す
swap(nums, i, j); // この 2 つの要素を交換
}
swap(nums, i, left); // 基準値を2つの部分配列の境界に交換
swap(nums, i, left); // 基準値を 2 つの部分配列の境界へ交換する
return i; // 基準値のインデックスを返す
}
/* クイックソート */
public static void quickSort(int[] nums, int left, int right) {
// 部分配列の長さが 1 のとき再帰を終了
// 部分配列の長さが 1 なら再帰を終了する
if (left >= right)
return;
// 分割
// 番兵分割
int pivot = partition(nums, left, right);
// 左部分配列と右部分配列を再帰的に処理
// 左右の部分配列を再帰処理
quickSort(nums, left, pivot - 1);
quickSort(nums, pivot + 1, right);
}
}
/* クイックソートクラス（中央値基準最適化） */
/* クイックソートクラス（中央値ピボット最適化） */
class QuickSortMedian {
/* 要素を交換 */
/* 要素の交換 */
static void swap(int[] nums, int i, int j) {
int tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
/* 3つの候補要素の中央値を選択 */
/* 3つの候補要素の中央値を選ぶ */
static int medianThree(int[] nums, int left, int mid, int right) {
int l = nums[left], m = nums[mid], r = nums[right];
if ((l <= m && m <= r) || (r <= m && m <= l))
@@ -64,75 +64,75 @@ class QuickSortMedian {
return right;
}
/* 分割（3つの中央値） */
/* 番兵による分割処理（3 点中央値） */
static int partition(int[] nums, int left, int right) {
// 3つの候補要素の中央値を選択
// 3つの候補要素の中央値を選ぶ
int med = medianThree(nums, left, (left + right) / 2, right);
// 中央値を配列の最左端の位置に交換
// 中央値を配列の最左端に交換する
swap(nums, left, med);
// nums[left] を基準値として使用
// nums[left] を基準値とする
int i = left, j = right;
while (i < j) {
while (i < j && nums[j] >= nums[left])
j--; // 右から左へ、基準値より小さい最初の要素を検索
j--; // 右から左へ基準値未満の最初の要素を探す
while (i < j && nums[i] <= nums[left])
i++; // 左から右へ、基準値より大きい最初の要素を検索
swap(nums, i, j); // これら2つの要素を交換
i++; // 左から右へ基準値より大きい最初の要素を探す
swap(nums, i, j); // この 2 つの要素を交換
}
swap(nums, i, left); // 基準値を2つの部分配列の境界に交換
swap(nums, i, left); // 基準値を 2 つの部分配列の境界へ交換する
return i; // 基準値のインデックスを返す
}
/* クイックソート */
public static void quickSort(int[] nums, int left, int right) {
// 部分配列の長さが 1 のとき再帰を終了
// 部分配列の長さが 1 なら再帰を終了する
if (left >= right)
return;
// 分割
// 番兵分割
int pivot = partition(nums, left, right);
// 左部分配列と右部分配列を再帰的に処理
// 左右の部分配列を再帰処理
quickSort(nums, left, pivot - 1);
quickSort(nums, pivot + 1, right);
}
}
/* クイックソートクラス（末尾再帰最適化） */
/* クイックソートクラス（再帰深度最適化） */
class QuickSortTailCall {
/* 要素を交換 */
/* 要素の交換 */
static void swap(int[] nums, int i, int j) {
int tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
/* 分割 */
/* 番兵分割 */
static int partition(int[] nums, int left, int right) {
// nums[left] を基準値として使用
// nums[left] を基準値とする
int i = left, j = right;
while (i < j) {
while (i < j && nums[j] >= nums[left])
j--; // 右から左へ、基準値より小さい最初の要素を検索
j--; // 右から左へ基準値未満の最初の要素を探す
while (i < j && nums[i] <= nums[left])
i++; // 左から右へ、基準値より大きい最初の要素を検索
swap(nums, i, j); // これら2つの要素を交換
i++; // 左から右へ基準値より大きい最初の要素を探す
swap(nums, i, j); // この 2 つの要素を交換
}
swap(nums, i, left); // 基準値を2つの部分配列の境界に交換
swap(nums, i, left); // 基準値を 2 つの部分配列の境界へ交換する
return i; // 基準値のインデックスを返す
}
/* クイックソート（末尾再帰最適化） */
/* クイックソート（再帰深度最適化） */
public static void quickSort(int[] nums, int left, int right) {
// 部分配列の長さが 1 のとき終了
// 部分配列の長さが 1 なら終了
while (left < right) {
// 分割操作
// 番兵による分割処理
int pivot = partition(nums, left, right);
// 2つの部分配列のうち短い方にクイックソートを実行
// 2 つの部分配列のうち短いほうにクイックソートを適用する
if (pivot - left < right - pivot) {
quickSort(nums, left, pivot - 1); // 左部分配列を再帰的にソート
left = pivot + 1; // 残りの未ソート区間は [pivot + 1, right]
left = pivot + 1; // 未ソート区間の残りは [pivot + 1, right]
} else {
quickSort(nums, pivot + 1, right); // 右部分配列を再帰的にソート
right = pivot - 1; // 残りの未ソート区間は [left, pivot - 1]
right = pivot - 1; // 未ソート区間の残りは [left, pivot - 1]
}
}
}
@@ -143,16 +143,16 @@ public class quick_sort {
/* クイックソート */
int[] nums = { 2, 4, 1, 0, 3, 5 };
QuickSort.quickSort(nums, 0, nums.length - 1);
System.out.println("クイックソート後、nums = " + Arrays.toString(nums));
System.out.println("クイックソート完了後の nums = " + Arrays.toString(nums));
/* クイックソート（中央値基準最適化） */
/* クイックソート（中央値の基準値で最適化） */
int[] nums1 = { 2, 4, 1, 0, 3, 5 };
QuickSortMedian.quickSort(nums1, 0, nums1.length - 1);
System.out.println("中央値基準最適化クイックソート後、nums1 = " + Arrays.toString(nums1));
System.out.println("クイックソート（中央値ピボット最適化）完了後の nums1 = " + Arrays.toString(nums1));
/* クイックソート（末尾再帰最適化） */
/* クイックソート（再帰深度最適化） */
int[] nums2 = { 2, 4, 1, 0, 3, 5 };
QuickSortTailCall.quickSort(nums2, 0, nums2.length - 1);
System.out.println("末尾再帰最適化クイックソート後、nums2 = " + Arrays.toString(nums2));
System.out.println("クイックソート（再帰深度最適化）完了後の nums2 = " + Arrays.toString(nums2));
}
}
}

38
ja/codes/java/chapter_sorting/radix_sort.java
View File

@@ -9,52 +9,52 @@ package chapter_sorting;
import java.util.*;
public class radix_sort {
/* 要素 num の k 番目の桁を取得、exp = 10^(k-1) */
/* 要素 num の下から k 桁目を取得（exp = 10^(k-1)） */
static int digit(int num, int exp) {
// k の代わりに exp を渡すことで、ここでコストの高い累乗計算の繰り返しを避けることができる
// ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す
return (num / exp) % 10;
}
/* 計数ソート（nums の k 番目の桁に基づく） */
/* 計数ソート（nums の k 桁目でソート） */
static void countingSortDigit(int[] nums, int exp) {
// 10進数の桁の範囲は 0~9、したがって長さ 10 のバケット配列が必要
// 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要
int[] counter = new int[10];
int n = nums.length;
// 桁 0~9 の出現回数を統計
// 0~9 の各数字の出現回数を集計する
for (int i = 0; i < n; i++) {
int d = digit(nums[i], exp); // nums[i] の k 番目の桁を取得、d とする
counter[d]++; // 桁 d の出現回数を統計
int d = digit(nums[i], exp); // nums[i] の第 k 位を取得し、d とする
counter[d]++; // 数字 d の出現回数を数える
}
// 累積和を計算し、「出現回数」を「配列インデックス」に変換
// 累積和を求め、「出現回数」を「配列インデックス」に変換する
for (int i = 1; i < 10; i++) {
counter[i] += counter[i - 1];
}
// 逆順に走査し、バケット統計に基づいて各要素を res に配置
// 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する
int[] res = new int[n];
for (int i = n - 1; i >= 0; i--) {
int d = digit(nums[i], exp);
int j = counter[d] - 1; // 配列内での d のインデックス j を取得
res[j] = nums[i]; // 現在の要素をインデックス j に配置
counter[d]--; // d のカウントを 1 減らす
int j = counter[d] - 1; // d の配列内インデックス j を取得する
res[j] = nums[i]; // 現在の要素をインデックス j に格納する
counter[d]--; // d の個数を 1 減らす
}
// 結果で元の配列 nums を上書き
// 結果で元の配列 nums を上書きする
for (int i = 0; i < n; i++)
nums[i] = res[i];
}
/* 基数ソート */
static void radixSort(int[] nums) {
// 配列の最大要素を取得し、最大桁数を判定するために使用
// 最大桁数の判定用に配列の最大要素を取得
int m = Integer.MIN_VALUE;
for (int num : nums)
if (num > m)
m = num;
// 最下位桁から最上位桁まで走査
// 下位桁から上位桁の順に走査する
for (int exp = 1; exp <= m; exp *= 10) {
// 配列要素の k 番目の桁に対して計数ソートを実行
// 配列要素の k 桁目に対して計数ソートを行う
// k = 1 -> exp = 1
// k = 2 -> exp = 10
// すなわち exp = 10^(k-1)
// つまり exp = 10^(k-1)
countingSortDigit(nums, exp);
}
}
@@ -64,6 +64,6 @@ public class radix_sort {
int[] nums = { 10546151, 35663510, 42865989, 34862445, 81883077,
88906420, 72429244, 30524779, 82060337, 63832996 };
radixSort(nums);
System.out.println("基数ソート後、nums = " + Arrays.toString(nums));
System.out.println("基数ソート完了後の nums = " + Arrays.toString(nums));
}
}
}

10
ja/codes/java/chapter_sorting/selection_sort.java
View File

@@ -12,15 +12,15 @@ public class selection_sort {
/* 選択ソート */
public static void selectionSort(int[] nums) {
int n = nums.length;
// 外側ループ: 未ソート範囲は [i, n-1]
// 外側ループ：未整列区間は [i, n-1]
for (int i = 0; i < n - 1; i++) {
// 内側ループ: 未ソート範囲内で最小要素を見つける
// 内側のループ：未ソート区間の最小要素を見つける
int k = i;
for (int j = i + 1; j < n; j++) {
if (nums[j] < nums[k])
k = j; // 最小要素のインデックスを記録
}
// 最小要素と未ソート範囲の最初の要素を交換
// その最小要素を未整列区間の先頭要素と交換する
int temp = nums[i];
nums[i] = nums[k];
nums[k] = temp;
@@ -30,6 +30,6 @@ public class selection_sort {
public static void main(String[] args) {
int[] nums = { 4, 1, 3, 1, 5, 2 };
selectionSort(nums);
System.out.println("選択ソート後、nums = " + Arrays.toString(nums));
System.out.println("選択ソート完了後の nums = " + Arrays.toString(nums));
}
}
}

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);
}
}
}

44
ja/codes/java/chapter_tree/array_binary_tree.java
View File

@@ -9,7 +9,7 @@ package chapter_tree;
import utils.*;
import java.util.*;
/* 配列ベースの二分木クラス */
/* 配列表現による二分木クラス */
class ArrayBinaryTree {
private List<Integer> tree;
@@ -18,30 +18,30 @@ class ArrayBinaryTree {
tree = new ArrayList<>(arr);
}
/* リストの容量 */
/* リスト容量 */
public int size() {
return tree.size();
}
/* インデックス i のノードの値を取得 */
public Integer val(int i) {
// インデックスが範囲外の場合、null を返す（空の位置を表す）
// インデックスが範囲外なら、空きを表す null を返す
if (i < 0 || i >= size())
return null;
return tree.get(i);
}
/* インデックス i のノードの左の子のインデックスを取得 */
/* インデックス i のノードの左子ノードのインデックスを取得 */
public Integer left(int i) {
return 2 * i + 1;
}
/* インデックス i のノードの右の子のインデックスを取得 */
/* インデックス i のノードの右子ノードのインデックスを取得 */
public Integer right(int i) {
return 2 * i + 2;
}
/* インデックス i のノードの親のインデックスを取得 */
/* インデックス i のノードの親ノードのインデックスを取得 */
public Integer parent(int i) {
return (i - 1) / 2;
}
@@ -49,7 +49,7 @@ class ArrayBinaryTree {
/* レベル順走査 */
public List<Integer> levelOrder() {
List<Integer> res = new ArrayList<>();
// 配列を走査
// 配列を直接走査する
for (int i = 0; i < size(); i++) {
if (val(i) != null)
res.add(val(i));
@@ -57,12 +57,12 @@ class ArrayBinaryTree {
return res;
}
/* 深さ優先走査 */
/* 深さ優先探索 */
private void dfs(Integer i, String order, List<Integer> res) {
// 空の位置の場合、戻る
// 空きスロットなら返す
if (val(i) == null)
return;
// 前順走査
// 先行順走査
if ("pre".equals(order))
res.add(val(i));
dfs(left(i), order, res);
@@ -75,7 +75,7 @@ class ArrayBinaryTree {
res.add(val(i));
}
/* 前順走査 */
/* 先行順走査 */
public List<Integer> preOrder() {
List<Integer> res = new ArrayList<>();
dfs(0, "pre", res);
@@ -100,7 +100,7 @@ class ArrayBinaryTree {
public class array_binary_tree {
public static void main(String[] args) {
// 二分木を初期化
// 特定の関数を使用して配列を二分木に変換
// ここでは、配列から直接二分木を生成する関数を利用する
List<Integer> arr = Arrays.asList(1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15);
TreeNode root = TreeNode.listToTree(arr);
@@ -110,7 +110,7 @@ public class array_binary_tree {
System.out.println("二分木の連結リスト表現:");
PrintUtil.printTree(root);
// 配列ベースの二分木クラス
// 配列表現による二分木クラス
ArrayBinaryTree abt = new ArrayBinaryTree(arr);
// ノードにアクセス
@@ -118,19 +118,19 @@ public class array_binary_tree {
Integer l = abt.left(i);
Integer r = abt.right(i);
Integer p = abt.parent(i);
System.out.println("\n現在のノードのインデックスは " + i + "、値 = " + abt.val(i));
System.out.println("その左の子のインデックスは " + l + "、値 = " + (l == null ? "null" : abt.val(l)));
System.out.println("その右の子のインデックスは " + r + "、値 = " + (r == null ? "null" : abt.val(r)));
System.out.println("その親のインデックスは " + p + "、値 = " + (p == null ? "null" : abt.val(p)));
System.out.println("\n現在のノードのインデックスは " + i + "、値は " + abt.val(i));
System.out.println("その左子ノードのインデックスは " + l + "、値は " + (l == null ? "null" : abt.val(l)));
System.out.println("その右子ノードのインデックスは " + r + "、値は " + (r == null ? "null" : abt.val(r)));
System.out.println("その親ノードのインデックスは " + p + "、値は " + (p == null ? "null" : abt.val(p)));
// 木を走査
List<Integer> res = abt.levelOrder();
System.out.println("\nレベル順走査は:" + res);
System.out.println("\nレベル順走査: " + res);
res = abt.preOrder();
System.out.println("前順走査は:" + res);
System.out.println("前順走査: " + res);
res = abt.inOrder();
System.out.println("中順走査は:" + res);
System.out.println("中順走査: " + res);
res = abt.postOrder();
System.out.println("後順走査は:" + res);
System.out.println("後順走査: " + res);
}
}
}

100
ja/codes/java/chapter_tree/avl_tree.java
View File

@@ -8,7 +8,7 @@ package chapter_tree;
import utils.*;
/* AVL木 */
/* AVL 木 */
class AVLTree {
TreeNode root; // 根ノード
@@ -18,76 +18,76 @@ class AVLTree {
return node == null ? -1 : node.height;
}
/* ノードの高さを更新 */
/* ノードの高さを更新する */
private void updateHeight(TreeNode node) {
// ノードの高さは最も高い部分木の高さ + 1
// ノードの高さは最も高い部分木の高さ + 1 に等しい
node.height = Math.max(height(node.left), height(node.right)) + 1;
}
/* 平衡因子を取得 */
/* 平衡係数を取得 */
public int balanceFactor(TreeNode node) {
// 空ノードの平衡因子は 0
// 空ノードの平衡係数は 0
if (node == null)
return 0;
// ノードの平衡因子 = 左部分木の高さ - 右部分木の高さ
// ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ
return height(node.left) - height(node.right);
}
/* 右回転操作 */
/* 右回転 */
private TreeNode rightRotate(TreeNode node) {
TreeNode child = node.left;
TreeNode grandChild = child.right;
// child を軸として node を右に回転
// child を支点として node を右回転させる
child.right = node;
node.left = grandChild;
// ノードの高さを更新
// ノードの高さを更新する
updateHeight(node);
updateHeight(child);
// 回転後の部分木の根を返す
// 回転後の部分木の根ノードを返す
return child;
}
/* 左回転操作 */
/* 左回転 */
private TreeNode leftRotate(TreeNode node) {
TreeNode child = node.right;
TreeNode grandChild = child.left;
// child を軸として node を左に回転
// child を支点として node を左回転させる
child.left = node;
node.right = grandChild;
// ノードの高さを更新
// ノードの高さを更新する
updateHeight(node);
updateHeight(child);
// 回転後の部分木の根を返す
// 回転後の部分木の根ノードを返す
return child;
}
/* 回転操作を実行して部分木の平衡を回復 */
/* 回転操作を行い、この部分木の平衡を回復する */
private TreeNode rotate(TreeNode node) {
// node の平衡因子を取得
// ノード node の平衡係数を取得
int balanceFactor = balanceFactor(node);
// 左傾斜の木
// 左に偏った木
if (balanceFactor > 1) {
if (balanceFactor(node.left) >= 0) {
// 右回転
return rightRotate(node);
} else {
// 先に左回転、その後右回転
// 左回転してから右回転
node.left = leftRotate(node.left);
return rightRotate(node);
}
}
// 右傾斜の木
// 右に偏った木
if (balanceFactor < -1) {
if (balanceFactor(node.right) <= 0) {
// 左回転
return leftRotate(node);
} else {
// 先に右回転、その後左回転
// 右回転してから左回転
node.right = rightRotate(node.right);
return leftRotate(node);
}
}
// 平衡木、回転は不要、戻る
// 平衡木なので回転不要、そのまま返す
return node;
}
@@ -96,19 +96,19 @@ class AVLTree {
root = insertHelper(root, val);
}
/* 再帰的にノードを挿入（補助メソッド） */
/* ノードを再帰的に挿入する（補助メソッド） */
private TreeNode insertHelper(TreeNode node, int val) {
if (node == null)
return new TreeNode(val);
/* 1. 挿入位置を見つけてノードを挿入 */
/* 1. 挿入位置を探索してノードを挿入 */
if (val < node.val)
node.left = insertHelper(node.left, val);
else if (val > node.val)
node.right = insertHelper(node.right, val);
else
return node; // 重複ノードは挿入しない、戻る
updateHeight(node); // ノードの高さを更新
/* 2. 回転操作を実行して部分木の平衡を回復 */
return node; // 重複ノードは挿入せず、そのまま返す
updateHeight(node); // ノードの高さを更新する
/* 2. 回転操作を行い、部分木の平衡を回復する */
node = rotate(node);
// 部分木の根ノードを返す
return node;
@@ -119,11 +119,11 @@ class AVLTree {
root = removeHelper(root, val);
}
/* 再帰的にノードを削除（補助メソッド） */
/* ノードを再帰的に削除する（補助メソッド） */
private TreeNode removeHelper(TreeNode node, int val) {
if (node == null)
return null;
/* 1. ノードを見つけて削除 */
/* 1. ノードを探索して削除 */
if (val < node.val)
node.left = removeHelper(node.left, val);
else if (val > node.val)
@@ -131,14 +131,14 @@ class AVLTree {
else {
if (node.left == null || node.right == null) {
TreeNode child = node.left != null ? node.left : node.right;
// 子ノード数 = 0、ノードを削除して戻る
// 子ノード数 = 0 の場合、node をそのまま削除して返す
if (child == null)
return null;
// 子ノード数 = 1、ノードを削除
// 子ノード数 = 1 の場合、node をそのまま削除する
else
node = child;
} else {
// 子ノード数 = 2、中順走査の次のノードを削除し、現在のノードをそれで置き換える
// 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える
TreeNode temp = node.right;
while (temp.left != null) {
temp = temp.left;
@@ -147,29 +147,29 @@ class AVLTree {
node.val = temp.val;
}
}
updateHeight(node); // ノードの高さを更新
/* 2. 回転操作を実行して部分木の平衡を回復 */
updateHeight(node); // ノードの高さを更新する
/* 2. 回転操作を行い、部分木の平衡を回復する */
node = rotate(node);
// 部分木の根ノードを返す
return node;
}
/* ノードを検索 */
/* ノードを探索 */
public TreeNode search(int val) {
TreeNode cur = root;
// ループで検索、葉ノードを通過後に終了
// ループで探索し、葉ノードを越えたら抜ける
while (cur != null) {
// 対象ノードは cur の右部分木にある
// 目標ノードは cur の右部分木にある
if (cur.val < val)
cur = cur.right;
// 対象ノードは cur の左部分木にある
// 目標ノードは cur の左部分木にある
else if (cur.val > val)
cur = cur.left;
// 対象ノードを見つけた、ループを終了
// 目標ノードが見つかったらループを抜ける
else
break;
}
// 対象ノードを返す
// 目標ノードを返す
return cur;
}
}
@@ -177,22 +177,22 @@ class AVLTree {
public class avl_tree {
static void testInsert(AVLTree tree, int val) {
tree.insert(val);
System.out.println("\nノード " + val + " を挿入後、AVL木は ");
System.out.println("\nノード " + val + " を挿入した後、AVL 木は");
PrintUtil.printTree(tree.root);
}
static void testRemove(AVLTree tree, int val) {
tree.remove(val);
System.out.println("\nノード " + val + " を削除後、AVL木は ");
System.out.println("\nノード " + val + " を削除した後、AVL 木は");
PrintUtil.printTree(tree.root);
}
public static void main(String[] args) {
/* 空のAVL木を初期化 */
/* 空の AVL 木を初期化する */
AVLTree avlTree = new AVLTree();
/* ノードを挿入 */
// ノード挿入後にAVL木がどのように平衡を保つかを確認
// ノード挿入後に AVL 木がどのように平衡を保つかに注目してほしい
testInsert(avlTree, 1);
testInsert(avlTree, 2);
testInsert(avlTree, 3);
@@ -204,17 +204,17 @@ public class avl_tree {
testInsert(avlTree, 10);
testInsert(avlTree, 6);
/* 重複ノードを挿入 */
/* 重複ノードを挿入する */
testInsert(avlTree, 7);
/* ノードを削除 */
// ノード削除後にAVL木がどのように平衡を保つかを確認
testRemove(avlTree, 8); // 次数 0 のノードを削除
testRemove(avlTree, 5); // 次数 1 のノードを削除
testRemove(avlTree, 4); // 次数 2 のノードを削除
// ノード削除後に AVL 木がどのように平衡を保つかに注目してほしい
testRemove(avlTree, 8); // 次数 0 のノードを削除する
testRemove(avlTree, 5); // 次数 1 のノードを削除する
testRemove(avlTree, 4); // 次数 2 のノードを削除する
/* ノードを検索 */
TreeNode node = avlTree.search(7);
System.out.println("\n見つかったノードオブジェクトは " + node + "、ノードの値 = " + node.val);
System.out.println("\n見つかったノードオブジェクトは " + node + "、ノード値 = " + node.val);
}
}
}

64
ja/codes/java/chapter_tree/binary_search_tree.java
View File

@@ -14,7 +14,7 @@ class BinarySearchTree {
/* コンストラクタ */
public BinarySearchTree() {
// 空の木を初期化
// 空の木を初期化する
root = null;
}
@@ -23,36 +23,36 @@ class BinarySearchTree {
return root;
}
/* ノードを検索 */
/* ノードを探索 */
public TreeNode search(int num) {
TreeNode cur = root;
// ループで検索、葉ノードを通過後に終了
// ループで探索し、葉ノードを越えたら抜ける
while (cur != null) {
// 対象ノードは cur の右部分木にある
// 目標ノードは cur の右部分木にある
if (cur.val < num)
cur = cur.right;
// 対象ノードは cur の左部分木にある
// 目標ノードは cur の左部分木にある
else if (cur.val > num)
cur = cur.left;
// 対象ノードを見つけた、ループを終了
// 目標ノードが見つかったらループを抜ける
else
break;
}
// 対象ノードを返す
// 目標ノードを返す
return cur;
}
/* ノードを挿入 */
public void insert(int num) {
// 木が空の場合、根ノードを初期化
// 木が空なら、根ノードを初期化する
if (root == null) {
root = new TreeNode(num);
return;
}
TreeNode cur = root, pre = null;
// ループで検索、葉ノードを通過後に終了
// ループで探索し、葉ノードを越えたら抜ける
while (cur != null) {
// 重複ノードを見つけた場合、戻る
// 重複ノードが見つかったら、直ちに返す
if (cur.val == num)
return;
pre = cur;
@@ -73,51 +73,51 @@ class BinarySearchTree {
/* ノードを削除 */
public void remove(int num) {
// 木が空の場合、戻る
// 木が空なら、そのまま早期リターンする
if (root == null)
return;
TreeNode cur = root, pre = null;
// ループで検索、葉ノードを通過後に終了
// ループで探索し、葉ノードを越えたら抜ける
while (cur != null) {
// 削除するノードを見つけた、ループを終了
// 削除対象のノードが見つかったら、ループを抜ける
if (cur.val == num)
break;
pre = cur;
// 削除するノードは cur の右部分木にある
// 削除対象ノードは cur の右部分木にある
if (cur.val < num)
cur = cur.right;
// 削除するノードは cur の左部分木にある
// 削除対象ノードは cur の左部分木にある
else
cur = cur.left;
}
// 削除するノードがない場合、戻る
// 削除対象ノードがなければそのまま返す
if (cur == null)
return;
// 子ノード数 = 0 または 1
// 子ノード数 = 0 or 1
if (cur.left == null || cur.right == null) {
// 子ノード数 = 0/1 の場合、child = null/その子ノード
// 子ノード数が 0 / 1 のとき、child = null / その子ノード
TreeNode child = cur.left != null ? cur.left : cur.right;
// ノード cur を削除
// ノード cur を削除する
if (cur != root) {
if (pre.left == cur)
pre.left = child;
else
pre.right = child;
} else {
// 削除されるノードが根の場合、根を再割り当て
// 削除ノードが根ノードなら、根ノードを再設定
root = child;
}
}
// 子ノード数 = 2
else {
// cur の中順走査の次のノードを取得
// 中順走査における cur の次ノードを取得
TreeNode tmp = cur.right;
while (tmp.left != null) {
tmp = tmp.left;
}
// 再帰的にノード tmp を削除
// ノード tmp を再帰的に削除
remove(tmp.val);
// cur を tmp で置き換える
// tmp で cur を上書きする
cur.val = tmp.val;
}
}
@@ -127,32 +127,32 @@ public class binary_search_tree {
public static void main(String[] args) {
/* 二分探索木を初期化 */
BinarySearchTree bst = new BinarySearchTree();
// 異なる挿入順序は様々な木構造を生成できることに注意。この特定の順序は完全二分木を作成する
// 注意：挿入順序が異なると異なる二分木が生成される。このシーケンスからは完全二分木を生成できる
int[] nums = { 8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15 };
for (int num : nums) {
bst.insert(num);
}
System.out.println("\n初期化された二分木は\n");
System.out.println("\n初期化した二分木は\n");
PrintUtil.printTree(bst.getRoot());
/* ノードを検索 */
/* ノードを探索 */
TreeNode node = bst.search(7);
System.out.println("\n見つかったノードオブジェクトは " + node + "、ノードの値 = " + node.val);
System.out.println("\n見つかったノードオブジェクトは " + node + "、ノード値 = " + node.val);
/* ノードを挿入 */
bst.insert(16);
System.out.println("\nノード 16 を挿入後、二分木は\n");
System.out.println("\nノード 16 を挿入した後の二分木は\n");
PrintUtil.printTree(bst.getRoot());
/* ノードを削除 */
bst.remove(1);
System.out.println("\nノード 1 を削除後、二分木は\n");
System.out.println("\nノード 1 を削除後，二分木は\n");
PrintUtil.printTree(bst.getRoot());
bst.remove(2);
System.out.println("\nノード 2 を削除後、二分木は\n");
System.out.println("\nノード 2 を削除後，二分木は\n");
PrintUtil.printTree(bst.getRoot());
bst.remove(4);
System.out.println("\nノード 4 を削除後、二分木は\n");
System.out.println("\nノード 4 を削除後，二分木は\n");
PrintUtil.printTree(bst.getRoot());
}
}
}

6
ja/codes/java/chapter_tree/binary_tree.java
View File

@@ -17,7 +17,7 @@ public class binary_tree {
TreeNode n3 = new TreeNode(3);
TreeNode n4 = new TreeNode(4);
TreeNode n5 = new TreeNode(5);
// ノードの参照（ポインタ）を構築
// ノード間の参照（ポインタ）を構築する
n1.left = n2;
n1.right = n3;
n2.left = n4;
@@ -27,7 +27,7 @@ public class binary_tree {
/* ノードの挿入と削除 */
TreeNode P = new TreeNode(0);
// ノード P を n1 -> n2 の間に挿入
// n1 -> n2 の間にノード P を挿入
n1.left = P;
P.left = n2;
System.out.println("\nノード P を挿入後\n");
@@ -37,4 +37,4 @@ public class binary_tree {
System.out.println("\nノード P を削除後\n");
PrintUtil.printTree(n1);
}
}
}

18
ja/codes/java/chapter_tree/binary_tree_bfs.java
View File

@@ -12,31 +12,31 @@ import java.util.*;
public class binary_tree_bfs {
/* レベル順走査 */
static List<Integer> levelOrder(TreeNode root) {
// キューを初期化し、根ノードを追加
// キューを初期化し、ルートノードを追加する
Queue<TreeNode> queue = new LinkedList<>();
queue.add(root);
// 走査順序を格納するリストを初期化
// 走査順序を保存するためのリストを初期化する
List<Integer> list = new ArrayList<>();
while (!queue.isEmpty()) {
TreeNode node = queue.poll(); // キューのデキュー
list.add(node.val); // ノードの値を保存
TreeNode node = queue.poll(); // デキュー
list.add(node.val); // ノードの値を保存する
if (node.left != null)
queue.offer(node.left); // 左の子ノードをエンキュー
queue.offer(node.left); // 左子ノードをキューに追加
if (node.right != null)
queue.offer(node.right); // 右の子ノードをエンキュー
queue.offer(node.right); // 右子ノードをキューに追加
}
return list;
}
public static void main(String[] args) {
/* 二分木を初期化 */
// 特定の関数を使用して配列を二分木に変換
// ここでは、配列から直接二分木を生成する関数を利用する
TreeNode root = TreeNode.listToTree(Arrays.asList(1, 2, 3, 4, 5, 6, 7));
System.out.println("\n二分木を初期化\n");
PrintUtil.printTree(root);
/* レベル順走査 */
List<Integer> list = levelOrder(root);
System.out.println("\nレベル順走査でのノードの出力順序 = " + list);
System.out.println("\nレベル順走査のノード出力シーケンス = " + list);
}
}
}

20
ja/codes/java/chapter_tree/binary_tree_dfs.java
View File

@@ -13,11 +13,11 @@ public class binary_tree_dfs {
// 走査順序を格納するリストを初期化
static ArrayList<Integer> list = new ArrayList<>();
/* 前順走査 */
/* 先行順走査 */
static void preOrder(TreeNode root) {
if (root == null)
return;
// 訪問優先度: 根ノード -> 左部分木 -> 右部分木
// 訪問順序：根ノード -> 左部分木 -> 右部分木
list.add(root.val);
preOrder(root.left);
preOrder(root.right);
@@ -27,7 +27,7 @@ public class binary_tree_dfs {
static void inOrder(TreeNode root) {
if (root == null)
return;
// 訪問優先度: 左部分木 -> 根ノード -> 右部分木
// 訪問優先順: 左部分木 -> 根ノード -> 右部分木
inOrder(root.left);
list.add(root.val);
inOrder(root.right);
@@ -37,7 +37,7 @@ public class binary_tree_dfs {
static void postOrder(TreeNode root) {
if (root == null)
return;
// 訪問優先度: 左部分木 -> 右部分木 -> 根ノード
// 訪問優先順: 左部分木 -> 右部分木 -> 根ノード
postOrder(root.left);
postOrder(root.right);
list.add(root.val);
@@ -45,24 +45,24 @@ public class binary_tree_dfs {
public static void main(String[] args) {
/* 二分木を初期化 */
// 特定の関数を使用して配列を二分木に変換
// ここでは、配列から直接二分木を生成する関数を利用する
TreeNode root = TreeNode.listToTree(Arrays.asList(1, 2, 3, 4, 5, 6, 7));
System.out.println("\n二分木を初期化\n");
PrintUtil.printTree(root);
/* 前順走査 */
/* 先行順走査 */
list.clear();
preOrder(root);
System.out.println("\n前順走査でのノードの出力順序 = " + list);
System.out.println("\n先行順走査のノード出力シーケンス = " + list);
/* 中順走査 */
list.clear();
inOrder(root);
System.out.println("\n中順走査でのノードの出力順序 = " + list);
System.out.println("\n中間順走査のノード出力シーケンス = " + list);
/* 後順走査 */
list.clear();
postOrder(root);
System.out.println("\n後順走査でのノードの出力順序 = " + list);
System.out.println("\n後行順走査のノード出力シーケンス = " + list);
}
}
}

4
ja/codes/java/utils/ListNode.java
View File

@@ -15,7 +15,7 @@ public class ListNode {
val = x;
}
/* リストを連結リストにデシリアライズ */
/* リストを連結リストにデシリアライズする */
public static ListNode arrToLinkedList(int[] arr) {
ListNode dum = new ListNode(0);
ListNode head = dum;
@@ -25,4 +25,4 @@ public class ListNode {
}
return dum.next;
}
}
}

26
ja/codes/java/utils/PrintUtil.java
View File

@@ -19,7 +19,7 @@ class Trunk {
};
public class PrintUtil {
/* 行列を印刷 (配列) */
/* 行列を出力する（Array） */
public static <T> void printMatrix(T[][] matrix) {
System.out.println("[");
for (T[] row : matrix) {
@@ -28,7 +28,7 @@ public class PrintUtil {
System.out.println("]");
}
/* 行列を印刷 (リスト) */
/* 行列を出力する（List） */
public static <T> void printMatrix(List<List<T>> matrix) {
System.out.println("[");
for (List<T> row : matrix) {
@@ -37,7 +37,7 @@ public class PrintUtil {
System.out.println("]");
}
/* 連結リストを印刷 */
/* 連結リストを出力 */
public static void printLinkedList(ListNode head) {
List<String> list = new ArrayList<>();
while (head != null) {
@@ -47,16 +47,16 @@ public class PrintUtil {
System.out.println(String.join(" -> ", list));
}
/* 二分木を印刷 */
/* 二分木を出力 */
public static void printTree(TreeNode root) {
printTree(root, null, false);
}
/**
* 二分木を印刷
* この木プリンターはTECHIE DELIGHTから借用
* https://www.techiedelight.com/c-program-print-binary-tree/
*/
* 二分木を出力
* This tree printer is borrowed from TECHIE DELIGHT
* https://www.techiedelight.com/c-program-print-binary-tree/
*/
public static void printTree(TreeNode root, Trunk prev, boolean isRight) {
if (root == null) {
return;
@@ -97,20 +97,20 @@ public class PrintUtil {
System.out.print(p.str);
}
/* ハッシュテーブルを印刷 */
/* ハッシュテーブルを出力 */
public static <K, V> void printHashMap(Map<K, V> map) {
for (Map.Entry<K, V> kv : map.entrySet()) {
System.out.println(kv.getKey() + " -> " + kv.getValue());
}
}
/* ヒープを印刷 (優先度キュー) */
/* ヒープ（優先度付きキュー）を出力する */
public static void printHeap(Queue<Integer> queue) {
List<Integer> list = new ArrayList<>(queue);
System.out.print("ヒープの配列表現:");
System.out.print("ヒープの配列表現：");
System.out.println(list);
System.out.println("ヒープの木表現:");
System.out.println("ヒープの木構造表現：");
TreeNode root = TreeNode.listToTree(list);
printTree(root);
}
}
}

36
ja/codes/java/utils/TreeNode.java
View File

@@ -11,7 +11,7 @@ import java.util.*;
/* 二分木ノードクラス */
public class TreeNode {
public int val; // ノード値
public int height; // ノード高さ
public int height; // ノードの高さ
public TreeNode left; // 左子ノードへの参照
public TreeNode right; // 右子ノードへの参照
@@ -20,23 +20,23 @@ public class TreeNode {
val = x;
}
// シリアライゼーション符号化ルールについては、次を参照：
// シリアライズの符号化規則は以下を参照:
// https://www.hello-algo.com/chapter_tree/array_representation_of_tree/
// 二分木の配列表現：
// 二分木の配列表現:
// [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]
// 二分木の連結リスト表現：
// /——— 15
// /——— 7
// /——— 3
// | \——— 6
// | \——— 12
// 二分木の連結リスト表現:
// /——— 15
// /——— 7
// /——— 3
// | \——— 6
// | \——— 12
// ——— 1
// \——— 2
// | /——— 9
// \——— 4
// \——— 8
// \——— 2
// | /——— 9
// \——— 4
// \——— 8
/* リストを二分木にデシリアライズ：再帰的 */
/* リストを二分木にデシリアライズする: 再帰 */
private static TreeNode listToTreeDFS(List<Integer> arr, int i) {
if (i < 0 || i >= arr.size() || arr.get(i) == null) {
return null;
@@ -47,12 +47,12 @@ public class TreeNode {
return root;
}
/* リストを二分木にデシリアライズ */
/* リストを二分木にデシリアライズする */
public static TreeNode listToTree(List<Integer> arr) {
return listToTreeDFS(arr, 0);
}
/* 二分木をリストにシリアライズ：再帰的 */
/* 二分木をリストにシリアライズする: 再帰 */
private static void treeToListDFS(TreeNode root, int i, List<Integer> res) {
if (root == null)
return;
@@ -64,10 +64,10 @@ public class TreeNode {
treeToListDFS(root.right, 2 * i + 2, res);
}
/* 二分木をリストにシリアライズ */
/* 二分木をリストにシリアライズする */
public static List<Integer> treeToList(TreeNode root) {
List<Integer> res = new ArrayList<>();
treeToListDFS(root, 0, res);
return res;
}
}
}

6
ja/codes/java/utils/Vertex.java
View File

@@ -16,7 +16,7 @@ public class Vertex {
this.val = val;
}
/* 値のリストvalsを入力し、頂点のリストvetsを返す */
/* 値リスト vals を入力し、頂点リスト vets を返す */
public static Vertex[] valsToVets(int[] vals) {
Vertex[] vets = new Vertex[vals.length];
for (int i = 0; i < vals.length; i++) {
@@ -25,7 +25,7 @@ public class Vertex {
return vets;
}
/* 頂点のリストvetsを入力し、値のリストvalsを返す */
/* 頂点リスト vets を入力し、値リスト vals を返す */
public static List<Integer> vetsToVals(List<Vertex> vets) {
List<Integer> vals = new ArrayList<>();
for (Vertex vet : vets) {
@@ -33,4 +33,4 @@ public class Vertex {
}
return vals;
}
}
}