mirror of
https://github.com/krahets/hello-algo.git
synced 2026-11-18 10:43:24 +08:00
Retranslate the complete Japanese online edition from Chinese (#2008)
* Retranslate the complete Japanese online edition from Chinese * Fit Japanese homepage labels and localize heading permalinks * Point Japanese contribution instructions to the Japanese preview * Replace locale conditionals with multilingual UI tables
This commit is contained in:
@@ -10,20 +10,20 @@ import java.util.*;
|
||||
import java.util.concurrent.ThreadLocalRandom;
|
||||
|
||||
public class array {
|
||||
/* 要素へランダムアクセス */
|
||||
/* 要素にランダムアクセスする */
|
||||
static int randomAccess(int[] nums) {
|
||||
// 区間 [0, nums.length) からランダムに 1 つの数を選ぶ
|
||||
// 区間 [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,38 +31,38 @@ 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];
|
||||
}
|
||||
}
|
||||
|
||||
/* 配列を走査 */
|
||||
/* 配列を走査する */
|
||||
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,9 +71,9 @@ public class array {
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
/* 実行用コード */
|
||||
public static void main(String[] args) {
|
||||
/* 配列を初期化 */
|
||||
/* 配列を初期化する */
|
||||
int[] arr = new int[5];
|
||||
System.out.println("配列 arr = " + Arrays.toString(arr));
|
||||
int[] nums = { 1, 3, 2, 5, 4 };
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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("ノード挿入後の連結リストは");
|
||||
System.out.println("ノードを挿入した後の連結リスト");
|
||||
PrintUtil.printLinkedList(n0);
|
||||
|
||||
/* ノードを削除 */
|
||||
/* ノードを削除する */
|
||||
remove(n0);
|
||||
System.out.println("ノード削除後の連結リストは");
|
||||
System.out.println("ノードを削除した後の連結リスト");
|
||||
PrintUtil.printLinkedList(n0);
|
||||
|
||||
/* ノードにアクセス */
|
||||
/* ノードにアクセスする */
|
||||
ListNode node = access(n0, 3);
|
||||
System.out.println("連結リストのインデックス 3 にあるノードの値 = " + node.val);
|
||||
|
||||
/* ノードを探索 */
|
||||
/* ノードを探索する */
|
||||
int index = find(n0, 2);
|
||||
System.out.println("連結リスト内で値 2 のノードのインデックス = " + index);
|
||||
System.out.println("連結リスト内で値が 2 であるノードのインデックス = " + index);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -10,46 +10,46 @@ import java.util.*;
|
||||
|
||||
public class list {
|
||||
public static void main(String[] args) {
|
||||
/* リストを初期化 */
|
||||
// 配列の要素型は `int[]` のラッパークラスである `Integer[]` である点に注意
|
||||
/* リストを初期化する */
|
||||
// 配列の要素型には 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);
|
||||
|
||||
/* 末尾に要素を追加 */
|
||||
/* 末尾に要素を追加する */
|
||||
nums.add(1);
|
||||
nums.add(3);
|
||||
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;
|
||||
}
|
||||
@@ -57,9 +57,9 @@ public class list {
|
||||
/* 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("リスト nums の後ろに nums1 を連結した結果 nums = " + nums);
|
||||
|
||||
/* リストをソート */
|
||||
/* リストをソートする */
|
||||
Collections.sort(nums);
|
||||
System.out.println("リストをソートした後 nums = " + nums);
|
||||
}
|
||||
|
||||
@@ -10,94 +10,94 @@ import java.util.*;
|
||||
|
||||
/* リストクラス */
|
||||
class MyList {
|
||||
private int[] arr; // 配列(リスト要素を格納)
|
||||
private int capacity = 10; // リスト容量
|
||||
private int[] arr; // 配列(リストの要素を格納する)
|
||||
private int capacity = 10; // リストの容量
|
||||
private int size = 0; // リストの長さ(現在の要素数)
|
||||
private int extendRatio = 2; // リスト拡張時の増加倍率
|
||||
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("インデックスが範囲外です");
|
||||
arr[index] = num;
|
||||
}
|
||||
|
||||
/* 末尾に要素を追加 */
|
||||
/* 末尾に要素を追加する */
|
||||
public void add(int num) {
|
||||
// 要素数が容量を超えると、拡張機構が発動する
|
||||
// 要素数が容量を超える場合、容量を拡張する
|
||||
if (size == capacity())
|
||||
extendCapacity();
|
||||
arr[size] = num;
|
||||
// 要素数を更新
|
||||
// 要素数を更新する
|
||||
size++;
|
||||
}
|
||||
|
||||
/* 中間に要素を挿入 */
|
||||
/* 途中に要素を挿入する */
|
||||
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];
|
||||
}
|
||||
arr[index] = num;
|
||||
// 要素数を更新
|
||||
// 要素数を更新する
|
||||
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];
|
||||
}
|
||||
// 要素数を更新
|
||||
// 要素数を更新する
|
||||
size--;
|
||||
// 削除された要素を返す
|
||||
// 削除した要素を返す
|
||||
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,11 +107,11 @@ class MyList {
|
||||
}
|
||||
|
||||
public class my_list {
|
||||
/* Driver Code */
|
||||
/* 実行用コード */
|
||||
public static void main(String[] args) {
|
||||
/* リストを初期化 */
|
||||
/* リストを初期化する */
|
||||
MyList nums = new MyList();
|
||||
/* 末尾に要素を追加 */
|
||||
/* 末尾に要素を追加する */
|
||||
nums.add(1);
|
||||
nums.add(3);
|
||||
nums.add(2);
|
||||
@@ -120,28 +120,28 @@ public class my_list {
|
||||
System.out.println("リスト nums = " + Arrays.toString(nums.toArray()) +
|
||||
" 、容量 = " + 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()) +
|
||||
System.out.println("容量を拡張した後のリスト nums = " + Arrays.toString(nums.toArray()) +
|
||||
" 、容量 = " + nums.capacity() + " 、長さ = " + nums.size());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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) {
|
||||
@@ -21,26 +21,26 @@ public class n_queens {
|
||||
res.add(copyState);
|
||||
return;
|
||||
}
|
||||
// すべての列を走査
|
||||
// すべての列を走査する
|
||||
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' はクイーン、'#' は空きマスを表す
|
||||
List<List<String>> state = 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,7 +65,7 @@ public class n_queens {
|
||||
int n = 4;
|
||||
List<List<List<String>>> res = nQueens(n);
|
||||
|
||||
System.out.println("盤面の縦横サイズは " + n);
|
||||
System.out.println("入力した盤面の縦横の長さは " + n);
|
||||
System.out.println("クイーンの配置方法は全部で " + res.size() + " 通り");
|
||||
for (List<List<String>> state : res) {
|
||||
System.out.println("--------------------");
|
||||
|
||||
@@ -9,31 +9,31 @@ 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;
|
||||
}
|
||||
// すべての選択肢を走査
|
||||
// すべての選択肢を走査する
|
||||
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);
|
||||
|
||||
@@ -9,33 +9,33 @@ 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;
|
||||
}
|
||||
// すべての選択肢を走査
|
||||
// すべての選択肢を走査する
|
||||
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);
|
||||
|
||||
@@ -12,13 +12,13 @@ import java.util.*;
|
||||
public class preorder_traversal_i_compact {
|
||||
static List<TreeNode> res;
|
||||
|
||||
/* 前順走査:例題 1 */
|
||||
/* 行きがけ順走査:例題 1 */
|
||||
static void preOrder(TreeNode root) {
|
||||
if (root == null) {
|
||||
return;
|
||||
}
|
||||
if (root.val == 7) {
|
||||
// 解を記録
|
||||
// 解を記録する
|
||||
res.add(root);
|
||||
}
|
||||
preOrder(root.left);
|
||||
@@ -27,14 +27,14 @@ public class preorder_traversal_i_compact {
|
||||
|
||||
public static void main(String[] args) {
|
||||
TreeNode root = TreeNode.listToTree(Arrays.asList(1, 7, 3, 4, 5, 6, 7));
|
||||
System.out.println("\n二分木を初期化");
|
||||
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);
|
||||
|
||||
@@ -13,34 +13,34 @@ public class preorder_traversal_ii_compact {
|
||||
static List<TreeNode> path;
|
||||
static List<List<TreeNode>> res;
|
||||
|
||||
/* 前順走査:例題 2 */
|
||||
/* 行きがけ順走査:例題 2 */
|
||||
static void preOrder(TreeNode root) {
|
||||
if (root == null) {
|
||||
return;
|
||||
}
|
||||
// 試す
|
||||
// 試行
|
||||
path.add(root);
|
||||
if (root.val == 7) {
|
||||
// 解を記録
|
||||
// 解を記録する
|
||||
res.add(new ArrayList<>(path));
|
||||
}
|
||||
preOrder(root.left);
|
||||
preOrder(root.right);
|
||||
// バックトラック
|
||||
// 復元
|
||||
path.remove(path.size() - 1);
|
||||
}
|
||||
|
||||
public static void main(String[] args) {
|
||||
TreeNode root = TreeNode.listToTree(Arrays.asList(1, 7, 3, 4, 5, 6, 7));
|
||||
System.out.println("\n二分木を初期化");
|
||||
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) {
|
||||
|
||||
@@ -13,35 +13,35 @@ public class preorder_traversal_iii_compact {
|
||||
static List<TreeNode> path;
|
||||
static List<List<TreeNode>> res;
|
||||
|
||||
/* 前順走査:例題 3 */
|
||||
/* 行きがけ順走査:例題 3 */
|
||||
static void preOrder(TreeNode root) {
|
||||
// 枝刈り
|
||||
if (root == null || root.val == 3) {
|
||||
return;
|
||||
}
|
||||
// 試す
|
||||
// 試行
|
||||
path.add(root);
|
||||
if (root.val == 7) {
|
||||
// 解を記録
|
||||
// 解を記録する
|
||||
res.add(new ArrayList<>(path));
|
||||
}
|
||||
preOrder(root.left);
|
||||
preOrder(root.right);
|
||||
// バックトラック
|
||||
// 復元
|
||||
path.remove(path.size() - 1);
|
||||
}
|
||||
|
||||
public static void main(String[] args) {
|
||||
TreeNode root = TreeNode.listToTree(Arrays.asList(1, 7, 3, 4, 5, 6, 7));
|
||||
System.out.println("\n二分木を初期化");
|
||||
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値が 3 のノードを含まない、根ノードからノード 7 までのすべての経路を出力する");
|
||||
for (List<TreeNode> path : res) {
|
||||
List<Integer> vals = new ArrayList<>();
|
||||
for (TreeNode node : path) {
|
||||
|
||||
@@ -10,47 +10,47 @@ import utils.*;
|
||||
import java.util.*;
|
||||
|
||||
public class preorder_traversal_iii_template {
|
||||
/* 現在の状態が解かどうかを判定 */
|
||||
/* 現在の状態が解かを判定 */
|
||||
static boolean isSolution(List<TreeNode> state) {
|
||||
return !state.isEmpty() && state.get(state.size() - 1).val == 7;
|
||||
}
|
||||
|
||||
/* 解を記録 */
|
||||
/* 解を記録する */
|
||||
static void recordSolution(List<TreeNode> state, List<List<TreeNode>> res) {
|
||||
res.add(new ArrayList<>(state));
|
||||
}
|
||||
|
||||
/* 現在の状態で、この選択が有効かどうかを判定 */
|
||||
/* 現在の状態でこの選択が有効か判定 */
|
||||
static boolean isValid(List<TreeNode> state, TreeNode choice) {
|
||||
return choice != null && choice.val != 3;
|
||||
}
|
||||
|
||||
/* 状態を更新 */
|
||||
/* 状態を更新する */
|
||||
static void makeChoice(List<TreeNode> state, TreeNode choice) {
|
||||
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);
|
||||
}
|
||||
}
|
||||
@@ -58,14 +58,14 @@ public class preorder_traversal_iii_template {
|
||||
|
||||
public static void main(String[] args) {
|
||||
TreeNode root = TreeNode.listToTree(Arrays.asList(1, 7, 3, 4, 5, 6, 7));
|
||||
System.out.println("\n二分木を初期化");
|
||||
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値が 3 のノードを含まない、根ノードからノード 7 までのすべての経路を出力する");
|
||||
for (List<TreeNode> path : res) {
|
||||
List<Integer> vals = new ArrayList<>();
|
||||
for (TreeNode node : path) {
|
||||
|
||||
@@ -9,35 +9,35 @@ 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;
|
||||
}
|
||||
// すべての選択肢を走査
|
||||
// 枝刈り 2: start から走査し、重複する部分集合の生成を避ける
|
||||
// すべての選択肢を走査する
|
||||
// 枝刈り 2:start から走査を始め、重複した部分集合の生成を避ける
|
||||
for (int i = start; i < choices.length; i++) {
|
||||
// 枝刈り1:部分集合の和が 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; // 開始点を走査
|
||||
Arrays.sort(nums); // nums をソートする
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -9,32 +9,32 @@ 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; // 部分和
|
||||
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("この方法の出力結果には重複した集合が含まれることに注意");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -9,40 +9,40 @@ 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;
|
||||
}
|
||||
// すべての選択肢を走査
|
||||
// 枝刈り 2: start から走査し、重複する部分集合の生成を避ける
|
||||
// 枝刈り 3: start から走査し、同じ要素の重複選択を避ける
|
||||
// すべての選択肢を走査する
|
||||
// 枝刈り 2:start から走査を始め、重複した部分集合の生成を避ける
|
||||
// 枝刈り 3:start から走査を始め、同じ要素の再選択を避ける
|
||||
for (int i = start; i < choices.length; i++) {
|
||||
// 枝刈り1:部分集合の和が target を超えたら、直ちにループを終了する
|
||||
// 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため
|
||||
// 枝刈り 1:部分集合の和が target を超えたら、直ちにループを終了する
|
||||
// 配列はソート済みで後ろの要素ほど大きいため、部分集合の和が必ず target を超えるからである
|
||||
if (target - choices[i] < 0) {
|
||||
break;
|
||||
}
|
||||
// 枝刈り4:この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする
|
||||
// 枝刈り 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; // 開始点を走査
|
||||
Arrays.sort(nums); // nums をソートする
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -24,7 +24,7 @@ public class complexity_exercises {
|
||||
return n + sumRecur(n - 1);
|
||||
}
|
||||
|
||||
/* 線形時間のループ */
|
||||
/* 線形オーダーのループ */
|
||||
static int linearLoop(int n) {
|
||||
int res = 0;
|
||||
for (int i = 0; i < n; i++) {
|
||||
@@ -33,7 +33,7 @@ public class complexity_exercises {
|
||||
return res;
|
||||
}
|
||||
|
||||
/* 二次時間のループ */
|
||||
/* 二次オーダーのループ */
|
||||
static int quadraticLoop(int n) {
|
||||
int res = 0;
|
||||
for (int i = 0; i < n; i++) {
|
||||
@@ -44,7 +44,7 @@ public class complexity_exercises {
|
||||
return res;
|
||||
}
|
||||
|
||||
/* 対数時間のループ */
|
||||
/* 対数オーダーのループ */
|
||||
static int logarithmicLoop(int n) {
|
||||
while (n > 1) {
|
||||
n /= 2;
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
@@ -21,7 +21,7 @@ public class iteration {
|
||||
static int whileLoop(int n) {
|
||||
int res = 0;
|
||||
int i = 1; // 条件変数を初期化する
|
||||
// 1, 2, ..., n-1, n を順に加算する
|
||||
// ループで 1, 2, ..., n-1, n の和を求める
|
||||
while (i <= n) {
|
||||
res += i;
|
||||
i++; // 条件変数を更新する
|
||||
@@ -29,11 +29,11 @@ public class iteration {
|
||||
return res;
|
||||
}
|
||||
|
||||
/* while ループ(2回更新) */
|
||||
/* while ループ(2 回の更新) */
|
||||
static int whileLoopII(int n) {
|
||||
int res = 0;
|
||||
int i = 1; // 条件変数を初期化する
|
||||
// 1, 4, 10, ... を順に加算する
|
||||
// ループで 1, 4, 10, ... の和を求める
|
||||
while (i <= n) {
|
||||
res += i;
|
||||
// 条件変数を更新する
|
||||
@@ -46,9 +46,9 @@ public class iteration {
|
||||
/* 二重 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,19 +56,19 @@ public class iteration {
|
||||
return res.toString();
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
/* 実行用コード */
|
||||
public static void main(String[] args) {
|
||||
int n = 5;
|
||||
int res;
|
||||
|
||||
res = forLoop(n);
|
||||
System.out.println("\nfor ループの合計結果 res = " + res);
|
||||
System.out.println("\nfor ループで求めた和 res = " + res);
|
||||
|
||||
res = whileLoop(n);
|
||||
System.out.println("\nwhile ループの合計結果 res = " + res);
|
||||
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("\n二重 for ループの走査結果 " + resStr);
|
||||
|
||||
@@ -14,25 +14,25 @@ public class recursion {
|
||||
// 終了条件
|
||||
if (n == 1)
|
||||
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,25 +53,25 @@ 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;
|
||||
|
||||
res = recur(n);
|
||||
System.out.println("\n再帰関数の合計結果 res = " + res);
|
||||
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);
|
||||
System.out.println("\n末尾再帰関数で求めた和 res = " + res);
|
||||
|
||||
res = fib(n);
|
||||
System.out.println("\nフィボナッチ数列の第 " + n + " 項は " + res);
|
||||
|
||||
@@ -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,7 +72,7 @@ public class space_complexity {
|
||||
}
|
||||
}
|
||||
|
||||
/* 二次時間(再帰実装) */
|
||||
/* 二次オーダー(再帰による実装) */
|
||||
static int quadraticRecur(int n) {
|
||||
if (n <= 0)
|
||||
return 0;
|
||||
@@ -82,7 +82,7 @@ public class space_complexity {
|
||||
return quadraticRecur(n - 1);
|
||||
}
|
||||
|
||||
/* 指数時間(完全二分木の構築) */
|
||||
/* 指数オーダー(パーフェクト二分木の構築) */
|
||||
static TreeNode buildTree(int n) {
|
||||
if (n == 0)
|
||||
return null;
|
||||
@@ -92,15 +92,15 @@ 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);
|
||||
// 指数オーダー
|
||||
|
||||
@@ -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]
|
||||
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);
|
||||
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("2 次時間の操作回数 = " + count);
|
||||
System.out.println("二次オーダーの操作回数 = " + 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("2 次時間(バブルソート)の操作回数 = " + count);
|
||||
System.out.println("二次オーダー(バブルソート)の操作回数 = " + 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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -9,14 +9,14 @@ 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 } を生成
|
||||
// 配列 nums = { 1, 2, 3, ..., n } を生成する
|
||||
for (int i = 0; i < n; i++) {
|
||||
nums[i] = i + 1;
|
||||
}
|
||||
// 配列要素をランダムにシャッフル
|
||||
// 配列の要素をランダムに並べ替える
|
||||
Collections.shuffle(Arrays.asList(nums));
|
||||
// Integer[] -> int[]
|
||||
int[] res = new int[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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -9,11 +9,11 @@ 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 を計算
|
||||
// 中央のインデックス m を計算する
|
||||
int m = (i + j) / 2;
|
||||
if (nums[m] < target) {
|
||||
// 部分問題 f(m+1, j) を再帰的に解く
|
||||
@@ -22,7 +22,7 @@ public class binary_search_recur {
|
||||
// 部分問題 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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -10,24 +10,24 @@ 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<>();
|
||||
@@ -41,11 +41,11 @@ public class build_tree {
|
||||
public static void main(String[] args) {
|
||||
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(preorder));
|
||||
System.out.println("通りがけ順走査 = " + Arrays.toString(inorder));
|
||||
|
||||
TreeNode root = buildTree(preorder, inorder);
|
||||
System.out.println("構築した二分木は:");
|
||||
System.out.println("構築した二分木:");
|
||||
PrintUtil.printTree(root);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -7,7 +7,7 @@
|
||||
package chapter_divide_and_conquer;
|
||||
|
||||
public class fast_power {
|
||||
/* 高速べき乗 */
|
||||
/* 高速べき乗法 */
|
||||
static int fastPow(int x, int n) {
|
||||
if (n == 0) {
|
||||
return 1;
|
||||
|
||||
@@ -9,38 +9,38 @@ package chapter_divide_and_conquer;
|
||||
import java.util.*;
|
||||
|
||||
public class hanota {
|
||||
/* 円盤を 1 枚移動 */
|
||||
/* 円盤を 1 枚移動する */
|
||||
static void move(List<Integer> src, List<Integer> tar) {
|
||||
// src の上から円盤を1枚取り出す
|
||||
// src の一番上から円盤を 1 枚取り出す
|
||||
Integer pan = src.remove(src.size() - 1);
|
||||
// 円盤を tar の上に置く
|
||||
// tar の一番上に円盤を置く
|
||||
tar.add(pan);
|
||||
}
|
||||
|
||||
/* ハノイの塔の問題 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):src の上部 i-1 枚の円盤を tar を補助にして buf へ移す
|
||||
// 部分問題 f(i-1) :src の上から i-1 枚の円盤を、tar を使って buf に移す
|
||||
dfs(i - 1, src, tar, buf);
|
||||
// 部分問題 f(1):src に残る 1 枚の円盤を tar に移す
|
||||
// 部分問題 f(1) :src に残った 1 枚の円盤を tar に移す
|
||||
move(src, tar);
|
||||
// 部分問題 f(i-1):buf の上部 i-1 枚の円盤を src を補助にして 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();
|
||||
// A の上から n 枚の円盤を B を介して 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<>();
|
||||
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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]
|
||||
@@ -17,7 +17,7 @@ public class climbing_stairs_dfs {
|
||||
return count;
|
||||
}
|
||||
|
||||
/* 階段登り:探索 */
|
||||
/* 階段の上り方:探索 */
|
||||
public static int climbingStairsDFS(int n) {
|
||||
return dfs(n);
|
||||
}
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -11,10 +11,10 @@ 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]
|
||||
@@ -24,9 +24,9 @@ public class climbing_stairs_dfs_mem {
|
||||
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));
|
||||
}
|
||||
}
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -63,10 +63,10 @@ public class coin_change {
|
||||
|
||||
// 動的計画法
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -7,10 +7,10 @@
|
||||
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++) {
|
||||
@@ -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 を選ばない場合と選ぶ場合の和
|
||||
// 硬貨 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 を選ばない場合と選ぶ場合の和
|
||||
// 硬貨 i を選ばない場合と選ぶ場合の方法の数の和
|
||||
dp[a] = dp[a] + dp[a - coins[i - 1]];
|
||||
}
|
||||
}
|
||||
@@ -58,10 +58,10 @@ public class coin_change_ii {
|
||||
|
||||
// 動的計画法
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -9,21 +9,21 @@ 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);
|
||||
@@ -33,22 +33,22 @@ public class edit_distance {
|
||||
|
||||
/* 編集距離:メモ化探索 */
|
||||
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);
|
||||
@@ -68,14 +68,14 @@ public class edit_distance {
|
||||
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,7 +83,7 @@ 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];
|
||||
@@ -100,10 +100,10 @@ public class edit_distance {
|
||||
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] に更新する
|
||||
@@ -119,21 +119,21 @@ public class edit_distance {
|
||||
|
||||
// 全探索
|
||||
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 + " 回");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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 を入れない場合と入れる場合の最大価値を計算する
|
||||
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 ナップサック:メモ化探索 */
|
||||
/* 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 を入れない場合と入れる場合の最大価値を計算する
|
||||
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]);
|
||||
}
|
||||
}
|
||||
@@ -95,7 +95,7 @@ public class knapsack {
|
||||
|
||||
// 全探索
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -15,14 +15,14 @@ public class min_path_sum {
|
||||
if (i == 0 && j == 0) {
|
||||
return grid[0][0];
|
||||
}
|
||||
// 行または列のインデックスが範囲外なら、コスト +∞ を返す
|
||||
// 行または列のインデックスが範囲外の場合、コスト +∞ を返す
|
||||
if (i < 0 || j < 0) {
|
||||
return Integer.MAX_VALUE;
|
||||
}
|
||||
// 左上から (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];
|
||||
}
|
||||
|
||||
@@ -32,15 +32,15 @@ public class min_path_sum {
|
||||
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) までの最小経路コストを記録して返す
|
||||
@@ -51,7 +51,7 @@ public class min_path_sum {
|
||||
/* 最小経路和:動的計画法 */
|
||||
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];
|
||||
// 状態遷移:先頭行
|
||||
@@ -62,7 +62,7 @@ public class min_path_sum {
|
||||
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,10 +71,10 @@ 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];
|
||||
@@ -118,7 +118,7 @@ public class min_path_sum {
|
||||
res = minPathSumDP(grid);
|
||||
System.out.println("左上から右下までの最小経路和は " + res);
|
||||
|
||||
// 空間最適化後の動的計画法
|
||||
// 空間を最適化した動的計画法
|
||||
res = minPathSumDPComp(grid);
|
||||
System.out.println("左上から右下までの最小経路和は " + res);
|
||||
}
|
||||
|
||||
@@ -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]);
|
||||
}
|
||||
}
|
||||
@@ -54,10 +54,10 @@ public class unbounded_knapsack {
|
||||
|
||||
// 動的計画法
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -9,15 +9,15 @@ package chapter_graph;
|
||||
import java.util.*;
|
||||
import utils.*;
|
||||
|
||||
/* 隣接リストに基づく無向グラフクラス */
|
||||
/* 隣接リストで実装した無向グラフクラス */
|
||||
class GraphAdjList {
|
||||
// 隣接リスト。key は頂点、value はその頂点に隣接する全頂点
|
||||
// 隣接リスト。key:頂点、value:その頂点に隣接する全頂点
|
||||
Map<Vertex, List<Vertex>> adjList;
|
||||
|
||||
/* コンストラクタ */
|
||||
public GraphAdjList(Vertex[][] edges) {
|
||||
this.adjList = new HashMap<>();
|
||||
// すべての頂点と辺を追加
|
||||
// すべての頂点と辺を追加する
|
||||
for (Vertex[] edge : edges) {
|
||||
addVertex(edge[0]);
|
||||
addVertex(edge[1]);
|
||||
@@ -25,50 +25,50 @@ class GraphAdjList {
|
||||
}
|
||||
}
|
||||
|
||||
/* 頂点数を取得 */
|
||||
/* 頂点数を取得する */
|
||||
public int size() {
|
||||
return adjList.size();
|
||||
}
|
||||
|
||||
/* 辺を追加 */
|
||||
/* 辺を追加する */
|
||||
public void addEdge(Vertex vet1, Vertex vet2) {
|
||||
if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)
|
||||
throw new IllegalArgumentException();
|
||||
// 辺 vet1 - vet2 を追加
|
||||
// 辺 vet1 - vet2 を追加する
|
||||
adjList.get(vet1).add(vet2);
|
||||
adjList.get(vet2).add(vet1);
|
||||
}
|
||||
|
||||
/* 辺を削除 */
|
||||
/* 辺を削除する */
|
||||
public void removeEdge(Vertex vet1, Vertex vet2) {
|
||||
if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)
|
||||
throw new IllegalArgumentException();
|
||||
// 辺 vet1 - vet2 を削除
|
||||
// 辺 vet1 - vet2 を削除する
|
||||
adjList.get(vet1).remove(vet2);
|
||||
adjList.get(vet2).remove(vet1);
|
||||
}
|
||||
|
||||
/* 頂点を追加 */
|
||||
/* 頂点を追加する */
|
||||
public void addVertex(Vertex vet) {
|
||||
if (adjList.containsKey(vet))
|
||||
return;
|
||||
// 隣接リストに新しいリストを追加
|
||||
// 隣接リストに新しい連結リストを追加する
|
||||
adjList.put(vet, new ArrayList<>());
|
||||
}
|
||||
|
||||
/* 頂点を削除 */
|
||||
/* 頂点を削除する */
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
/* 隣接リストを出力 */
|
||||
/* 隣接リストを表示する */
|
||||
public void print() {
|
||||
System.out.println("隣接リスト =");
|
||||
for (Map.Entry<Vertex, List<Vertex>> pair : adjList.entrySet()) {
|
||||
@@ -82,7 +82,7 @@ class GraphAdjList {
|
||||
|
||||
public class graph_adjacency_list {
|
||||
public static void main(String[] args) {
|
||||
/* 無向グラフを初期化 */
|
||||
/* 無向グラフを初期化する */
|
||||
Vertex[] v = Vertex.valsToVets(new int[] { 1, 3, 2, 5, 4 });
|
||||
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] } };
|
||||
@@ -90,28 +90,28 @@ public class graph_adjacency_list {
|
||||
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 を追加した後のグラフ");
|
||||
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 を削除した後のグラフ");
|
||||
graph.print();
|
||||
|
||||
/* 頂点を追加 */
|
||||
/* 頂点を追加する */
|
||||
Vertex v5 = new Vertex(6);
|
||||
graph.addVertex(v5);
|
||||
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();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -9,84 +9,84 @@ package chapter_graph;
|
||||
import utils.*;
|
||||
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) {
|
||||
this.vertices = new ArrayList<>();
|
||||
this.adjMat = new ArrayList<>();
|
||||
// 頂点を追加
|
||||
// 頂点を追加する
|
||||
for (int val : vertices) {
|
||||
addVertex(val);
|
||||
}
|
||||
// 辺を追加
|
||||
// 注意:edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する
|
||||
// 辺を追加する
|
||||
// edges の要素は頂点のインデックス、すなわち vertices の要素のインデックスを表すことに注意
|
||||
for (int[] e : edges) {
|
||||
addEdge(e[0], e[1]);
|
||||
}
|
||||
}
|
||||
|
||||
/* 頂点数を取得 */
|
||||
/* 頂点数を取得する */
|
||||
public int size() {
|
||||
return vertices.size();
|
||||
}
|
||||
|
||||
/* 頂点を追加 */
|
||||
/* 頂点を追加する */
|
||||
public void addVertex(int val) {
|
||||
int n = size();
|
||||
// 頂点リストに新しい頂点の値を追加
|
||||
// 頂点リストに新しい頂点の値を追加する
|
||||
vertices.add(val);
|
||||
// 隣接行列に 1 行追加
|
||||
// 隣接行列に 1 行追加する
|
||||
List<Integer> newRow = new ArrayList<>(n);
|
||||
for (int j = 0; j < n; j++) {
|
||||
newRow.add(0);
|
||||
}
|
||||
adjMat.add(newRow);
|
||||
// 隣接行列に 1 列追加
|
||||
// 隣接行列に 1 列追加する
|
||||
for (List<Integer> row : adjMat) {
|
||||
row.add(0);
|
||||
}
|
||||
}
|
||||
|
||||
/* 頂点を削除 */
|
||||
/* 頂点を削除する */
|
||||
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 は vertices の要素インデックスに対応する
|
||||
/* 辺を追加する */
|
||||
// 引数 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 は vertices の要素インデックスに対応する
|
||||
/* 辺を削除する */
|
||||
// 引数 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);
|
||||
adjMat.get(j).set(i, 0);
|
||||
}
|
||||
|
||||
/* 隣接行列を出力 */
|
||||
/* 隣接行列を表示する */
|
||||
public void print() {
|
||||
System.out.print("頂点リスト = ");
|
||||
System.out.println(vertices);
|
||||
@@ -97,35 +97,35 @@ class GraphAdjMat {
|
||||
|
||||
public class graph_adjacency_matrix {
|
||||
public static void main(String[] args) {
|
||||
/* 無向グラフを初期化 */
|
||||
// edges の要素は頂点インデックス、すなわち vertices の要素インデックスに対応する点に注意
|
||||
/* 無向グラフを初期化する */
|
||||
// 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初期化後のグラフ");
|
||||
graph.print();
|
||||
|
||||
/* 辺を追加 */
|
||||
/* 辺を追加する */
|
||||
// 頂点 1, 2 のインデックスはそれぞれ 0, 2
|
||||
graph.addEdge(0, 2);
|
||||
System.out.println("\n辺 1-2 を追加した後のグラフ");
|
||||
graph.print();
|
||||
|
||||
/* 辺を削除 */
|
||||
/* 辺を削除する */
|
||||
// 頂点 1, 3 のインデックスはそれぞれ 0, 1
|
||||
graph.removeEdge(0, 1);
|
||||
System.out.println("\n辺 1-3 を削除した後のグラフ");
|
||||
graph.print();
|
||||
|
||||
/* 頂点を追加 */
|
||||
/* 頂点を追加する */
|
||||
graph.addVertex(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();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -10,35 +10,35 @@ 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(); // 先頭の頂点をデキュー
|
||||
res.add(vet); // 訪問した頂点を記録
|
||||
// この頂点のすべての隣接頂点を走査
|
||||
Vertex vet = que.poll(); // キューの先頭の頂点をデキューする
|
||||
res.add(vet); // 訪問した頂点を記録する
|
||||
// この頂点に隣接する全頂点を走査する
|
||||
for (Vertex adjVet : graph.adjList.get(vet)) {
|
||||
if (visited.contains(adjVet))
|
||||
continue; // 訪問済みの頂点をスキップ
|
||||
que.offer(adjVet); // 未訪問の頂点のみをキューに追加
|
||||
continue; // 訪問済みの頂点をスキップする
|
||||
que.offer(adjVet); // 未訪問の頂点だけをエンキューする
|
||||
visited.add(adjVet); // この頂点を訪問済みにする
|
||||
}
|
||||
}
|
||||
// 頂点の走査順を返す
|
||||
// 頂点の走査順序を返す
|
||||
return res;
|
||||
}
|
||||
|
||||
public static void main(String[] args) {
|
||||
/* 無向グラフを初期化 */
|
||||
/* 無向グラフを初期化する */
|
||||
Vertex[] v = Vertex.valsToVets(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
|
||||
Vertex[][] edges = { { v[0], v[1] }, { v[0], v[3] }, { v[1], v[2] }, { v[1], v[4] },
|
||||
{ v[2], v[5] }, { v[3], v[4] }, { v[3], v[6] }, { v[4], v[5] },
|
||||
@@ -47,9 +47,9 @@ public class graph_bfs {
|
||||
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));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -12,30 +12,30 @@ import utils.*;
|
||||
public class graph_dfs {
|
||||
/* 深さ優先走査の補助関数 */
|
||||
static void dfs(GraphAdjList graph, Set<Vertex> visited, List<Vertex> res, Vertex vet) {
|
||||
res.add(vet); // 訪問した頂点を記録
|
||||
res.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;
|
||||
}
|
||||
|
||||
public static void main(String[] args) {
|
||||
/* 無向グラフを初期化 */
|
||||
/* 無向グラフを初期化する */
|
||||
Vertex[] v = Vertex.valsToVets(new int[] { 0, 1, 2, 3, 4, 5, 6 });
|
||||
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] } };
|
||||
@@ -43,9 +43,9 @@ public class graph_dfs {
|
||||
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));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -21,16 +21,16 @@ 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) {
|
||||
@@ -38,9 +38,9 @@ public class fractional_knapsack {
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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,7 +31,7 @@ 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);
|
||||
}
|
||||
|
||||
@@ -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 を 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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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) {
|
||||
@@ -70,7 +70,7 @@ class ArrayHashMap {
|
||||
return pairSet;
|
||||
}
|
||||
|
||||
/* すべてのキーを取得 */
|
||||
/* すべてのキーを取得する */
|
||||
public List<Integer> keySet() {
|
||||
List<Integer> keySet = new ArrayList<>();
|
||||
for (Pair pair : buckets) {
|
||||
@@ -80,7 +80,7 @@ class ArrayHashMap {
|
||||
return keySet;
|
||||
}
|
||||
|
||||
/* すべての値を取得 */
|
||||
/* すべての値を取得する */
|
||||
public List<String> valueSet() {
|
||||
List<String> valueSet = 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);
|
||||
@@ -100,40 +100,40 @@ class ArrayHashMap {
|
||||
|
||||
public class array_hash_map {
|
||||
public static void main(String[] args) {
|
||||
/* ハッシュテーブルを初期化 */
|
||||
/* ハッシュテーブルを初期化する */
|
||||
ArrayHashMap map = new ArrayHashMap();
|
||||
|
||||
/* 追加操作 */
|
||||
// ハッシュテーブルにキーと値のペア (key, value) を追加
|
||||
map.put(12836, "シャオハー");
|
||||
map.put(15937, "シャオルオ");
|
||||
map.put(16750, "シャオスワン");
|
||||
map.put(13276, "シャオファー");
|
||||
map.put(10583, "シャオヤー");
|
||||
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 を取得
|
||||
/* 取得操作 */
|
||||
// ハッシュテーブルにキー 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");
|
||||
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);
|
||||
}
|
||||
|
||||
@@ -23,11 +23,11 @@ public class built_in_hash {
|
||||
int hashDec = Double.hashCode(dec);
|
||||
System.out.println("小数 " + dec + " のハッシュ値は " + hashDec);
|
||||
|
||||
String str = "Hello アルゴリズム";
|
||||
String str = "Hello 算法";
|
||||
int hashStr = str.hashCode();
|
||||
System.out.println("文字列 " + str + " のハッシュ値は " + hashStr);
|
||||
|
||||
Object[] arr = { 12836, "シャオハー" };
|
||||
Object[] arr = { 12836, "小哈" };
|
||||
int hashTup = Arrays.hashCode(arr);
|
||||
System.out.println("配列 " + Arrays.toString(arr) + " のハッシュ値は " + hashTup);
|
||||
|
||||
|
||||
@@ -11,40 +11,40 @@ import utils.*;
|
||||
|
||||
public class hash_map {
|
||||
public static void main(String[] args) {
|
||||
/* ハッシュテーブルを初期化 */
|
||||
/* ハッシュテーブルを初期化する */
|
||||
Map<Integer, String> map = new HashMap<>();
|
||||
|
||||
/* 追加操作 */
|
||||
// ハッシュテーブルにキーと値のペア (key, value) を追加
|
||||
map.put(12836, "シャオハー");
|
||||
map.put(15937, "シャオルオ");
|
||||
map.put(16750, "シャオスワン");
|
||||
map.put(13276, "シャオファー");
|
||||
map.put(10583, "シャオヤー");
|
||||
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 を取得
|
||||
/* 取得操作 */
|
||||
// ハッシュテーブルにキー 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);
|
||||
}
|
||||
|
||||
@@ -9,12 +9,12 @@ package chapter_hashing;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/* チェイン法ハッシュテーブル */
|
||||
/* チェイン法のハッシュテーブル */
|
||||
class HashMapChaining {
|
||||
int size; // キーと値のペア数
|
||||
int capacity; // ハッシュテーブル容量
|
||||
double loadThres; // リサイズを発動する負荷率のしきい値
|
||||
int extendRatio; // 拡張倍率
|
||||
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);
|
||||
// バケットを走査し、key が見つかれば対応する val を返す
|
||||
// バケットを走査し、key が見つかったら対応する val を返す
|
||||
for (Pair pair : bucket) {
|
||||
if (pair.key == key) {
|
||||
return pair.val;
|
||||
}
|
||||
}
|
||||
// key が見つからない場合は 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);
|
||||
// バケットを走査し、指定した key が見つかれば対応する val を更新して返す
|
||||
// バケットを走査し、指定された key が見つかったら、対応する val を更新して戻る
|
||||
for (Pair pair : bucket) {
|
||||
if (pair.key == key) {
|
||||
pair.val = val;
|
||||
return;
|
||||
}
|
||||
}
|
||||
// その key が存在しなければ、キーと値のペアを末尾に追加
|
||||
// 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);
|
||||
@@ -88,18 +88,18 @@ 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<>();
|
||||
@@ -121,28 +121,28 @@ class HashMapChaining {
|
||||
|
||||
public class hash_map_chaining {
|
||||
public static void main(String[] args) {
|
||||
/* ハッシュテーブルを初期化 */
|
||||
/* ハッシュテーブルを初期化する */
|
||||
HashMapChaining map = new HashMapChaining();
|
||||
|
||||
/* 追加操作 */
|
||||
// ハッシュテーブルにキーと値のペア (key, value) を追加
|
||||
map.put(12836, "シャオハー");
|
||||
map.put(15937, "シャオルオ");
|
||||
map.put(16750, "シャオスワン");
|
||||
map.put(13276, "シャオファー");
|
||||
map.put(10583, "シャオヤー");
|
||||
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 を取得
|
||||
/* 取得操作 */
|
||||
// ハッシュテーブルにキー key を渡し、値 value を取得する
|
||||
String name = map.get(13276);
|
||||
System.out.println("\n学籍番号 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();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,14 +6,14 @@
|
||||
|
||||
package chapter_hashing;
|
||||
|
||||
/* オープンアドレス法ハッシュテーブル */
|
||||
/* オープンアドレス法のハッシュテーブル */
|
||||
class HashMapOpenAddressing {
|
||||
private int size; // キーと値のペア数
|
||||
private int capacity = 4; // ハッシュテーブル容量
|
||||
private final double loadThres = 2.0 / 3.0; // リサイズを発動する負荷率のしきい値
|
||||
private final int extendRatio = 2; // 拡張倍率
|
||||
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,83 +31,83 @@ 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 firstTombstone; // 移動後のバケットのインデックスを返す
|
||||
}
|
||||
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--;
|
||||
}
|
||||
}
|
||||
|
||||
/* ハッシュテーブルを拡張 */
|
||||
/* ハッシュテーブルの容量を拡張する */
|
||||
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) {
|
||||
@@ -131,28 +131,28 @@ class HashMapOpenAddressing {
|
||||
|
||||
public class hash_map_open_addressing {
|
||||
public static void main(String[] args) {
|
||||
// ハッシュテーブルを初期化
|
||||
// ハッシュテーブルを初期化する
|
||||
HashMapOpenAddressing hashmap = new HashMapOpenAddressing();
|
||||
|
||||
// 追加操作
|
||||
// ハッシュテーブルにキーと値の組 (key, val) を追加する
|
||||
hashmap.put(12836, "シャオハー");
|
||||
hashmap.put(15937, "シャオルオ");
|
||||
hashmap.put(16750, "シャオスワン");
|
||||
hashmap.put(13276, "シャオファー");
|
||||
hashmap.put(10583, "シャオヤー");
|
||||
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();
|
||||
|
||||
// 検索操作
|
||||
// ハッシュテーブルにキー key を入力し、値 val を得る
|
||||
// 取得操作
|
||||
// ハッシュテーブルにキー key を渡し、値 val を取得する
|
||||
String name = hashmap.get(13276);
|
||||
System.out.println("\n学籍番号 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();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -27,7 +27,7 @@ public class simple_hash {
|
||||
return (int) hash;
|
||||
}
|
||||
|
||||
/* 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 アルゴリズム";
|
||||
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("排他的論理和ハッシュの値は " + hash);
|
||||
|
||||
hash = rotHash(key);
|
||||
System.out.println("回転ハッシュ値は " + hash);
|
||||
System.out.println("回転ハッシュの値は " + hash);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -11,53 +11,53 @@ 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);
|
||||
}
|
||||
|
||||
public static void main(String[] args) {
|
||||
/* ヒープを初期化 */
|
||||
// 最小ヒープを初期化
|
||||
/* ヒープを初期化する */
|
||||
// 最小ヒープを初期化する
|
||||
Queue<Integer> minHeap = new PriorityQueue<>();
|
||||
// 最大ヒープを初期化する(lambda 式で Comparator を変更すればよい)
|
||||
// 最大ヒープを初期化する(ラムダ式で 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);
|
||||
testPop(maxHeap);
|
||||
testPop(maxHeap);
|
||||
|
||||
/* ヒープのサイズを取得 */
|
||||
/* ヒープのサイズを取得する */
|
||||
int size = maxHeap.size();
|
||||
System.out.format("\nヒープ内の要素数は %d\n", size);
|
||||
System.out.format("\nヒープの要素数は %d\n", size);
|
||||
|
||||
/* ヒープが空かどうかを判定 */
|
||||
/* ヒープが空か判定 */
|
||||
boolean isEmpty = maxHeap.isEmpty();
|
||||
System.out.format("\nヒープが空かどうかは %b\n", isEmpty);
|
||||
System.out.format("\nヒープは空か %b\n", isEmpty);
|
||||
|
||||
/* リストを入力してヒープを構築 */
|
||||
/* リストを入力してヒープを構築する */
|
||||
// 時間計算量は O(n) であり、O(nlogn) ではない
|
||||
minHeap = new PriorityQueue<>(Arrays.asList(1, 3, 2, 5, 4));
|
||||
System.out.println("\nリストを入力して最小ヒープを構築した後");
|
||||
|
||||
@@ -11,114 +11,114 @@ 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; // 切り捨て除算
|
||||
}
|
||||
|
||||
/* 要素を交換 */
|
||||
/* 要素を交換する */
|
||||
private void swap(int i, int j) {
|
||||
int tmp = maxHeap.get(i);
|
||||
maxHeap.set(i, maxHeap.get(j));
|
||||
maxHeap.set(j, tmp);
|
||||
}
|
||||
|
||||
/* ヒープのサイズを取得 */
|
||||
/* ヒープのサイズを取得する */
|
||||
public int size() {
|
||||
return maxHeap.size();
|
||||
}
|
||||
|
||||
/* ヒープが空かどうかを判定 */
|
||||
/* ヒープが空か判定 */
|
||||
public boolean isEmpty() {
|
||||
return size() == 0;
|
||||
}
|
||||
|
||||
/* ヒープ先頭要素にアクセス */
|
||||
/* ヒープの先頭要素にアクセスする */
|
||||
public int peek() {
|
||||
return maxHeap.get(0);
|
||||
}
|
||||
|
||||
/* 要素をヒープに追加 */
|
||||
/* ヒープに要素を挿入する */
|
||||
public void push(int val) {
|
||||
// ノードを追加
|
||||
// ノードを追加する
|
||||
maxHeap.add(val);
|
||||
// 下から上へヒープ化
|
||||
// 下から上へヒープ化する
|
||||
siftUp(size() - 1);
|
||||
}
|
||||
|
||||
/* ノード i から始めて、下から上へヒープ化 */
|
||||
/* ノード i から上向きにヒープ化する */
|
||||
private void siftUp(int i) {
|
||||
while (true) {
|
||||
// ノード i の親ノードを取得
|
||||
// ノード 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;
|
||||
}
|
||||
}
|
||||
|
||||
/* ヒープ(二分木)を出力 */
|
||||
/* ヒープ(二分木)を表示する */
|
||||
public void print() {
|
||||
Queue<Integer> queue = new PriorityQueue<>((a, b) -> { return b - a; });
|
||||
queue.addAll(maxHeap);
|
||||
@@ -128,32 +128,32 @@ class MaxHeap {
|
||||
|
||||
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リストを入力してヒープを構築した後");
|
||||
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();
|
||||
|
||||
/* ヒープのサイズを取得 */
|
||||
/* ヒープのサイズを取得する */
|
||||
int size = maxHeap.size();
|
||||
System.out.format("\nヒープ内の要素数は %d\n", size);
|
||||
System.out.format("\nヒープの要素数は %d\n", size);
|
||||
|
||||
/* ヒープが空かどうかを判定 */
|
||||
/* ヒープが空か判定 */
|
||||
boolean isEmpty = maxHeap.isEmpty();
|
||||
System.out.format("\nヒープが空かどうかは %b\n", isEmpty);
|
||||
System.out.format("\nヒープは空か %b\n", isEmpty);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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] にある
|
||||
int m = i + (j - i) / 2; // 中央のインデックス m を計算する
|
||||
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 は配列の先頭要素と末尾要素の次をそれぞれ指す
|
||||
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) にある
|
||||
int m = i + (j - i) / 2; // 中央のインデックス m を計算する
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -7,29 +7,29 @@
|
||||
package chapter_searching;
|
||||
|
||||
public class binary_search_edge {
|
||||
/* 最も左の target を二分探索 */
|
||||
/* 二分探索で最も左にある 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 を二分探索 */
|
||||
/* 二分探索で最も右にある 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 より大きい最初の要素を指す
|
||||
// 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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -7,34 +7,34 @@
|
||||
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 を計算
|
||||
int m = i + (j - i) / 2; // 中央のインデックス m を計算する
|
||||
if (nums[m] < target) {
|
||||
i = m + 1; // target は区間 [m+1, j] にある
|
||||
i = m + 1; // target は区間 [m+1, j] に存在する
|
||||
} else if (nums[m] > target) {
|
||||
j = m - 1; // target は区間 [i, m-1] にある
|
||||
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 を計算
|
||||
int m = i + (j - i) / 2; // 中央のインデックス m を計算する
|
||||
if (nums[m] < target) {
|
||||
i = m + 1; // target は区間 [m+1, j] にある
|
||||
i = m + 1; // target は区間 [m+1, j] に存在する
|
||||
} else if (nums[m] > target) {
|
||||
j = m - 1; // target は区間 [i, m-1] にある
|
||||
j = m - 1; // target は区間 [i, m-1] に存在する
|
||||
} else {
|
||||
j = m - 1; // target より小さい最も右の要素は区間 [i, m-1] にある
|
||||
j = m - 1; // target より小さい要素のうち最も右にあるものは、区間 [i, m-1] に存在する
|
||||
}
|
||||
}
|
||||
// 挿入位置 i を返す
|
||||
@@ -45,7 +45,7 @@ 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);
|
||||
@@ -54,7 +54,7 @@ class binary_search_insertion {
|
||||
// 重複要素を含む配列
|
||||
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);
|
||||
|
||||
@@ -12,15 +12,15 @@ import java.util.*;
|
||||
public class hashing_search {
|
||||
/* ハッシュ探索(配列) */
|
||||
static int hashingSearchArray(Map<Integer, Integer> map, int target) {
|
||||
// ハッシュテーブルの key: 目標要素、value: インデックス
|
||||
// ハッシュテーブルにこの key がなければ -1 を返す
|
||||
// ハッシュテーブルの key:目的の要素、value:インデックス
|
||||
// ハッシュテーブルにこの key が存在しない場合、-1 を返す
|
||||
return map.getOrDefault(target, -1);
|
||||
}
|
||||
|
||||
/* ハッシュ探索(連結リスト) */
|
||||
static ListNode hashingSearchLinkedList(Map<Integer, ListNode> map, int target) {
|
||||
// ハッシュテーブルの key: 目標ノード値、value: ノードオブジェクト
|
||||
// ハッシュテーブルにこの key がなければ null を返す
|
||||
// ハッシュテーブルの key:目的のノードの値、value:ノードオブジェクト
|
||||
// ハッシュテーブルにこの key が存在しない場合、null を返す
|
||||
return map.getOrDefault(target, null);
|
||||
}
|
||||
|
||||
@@ -29,23 +29,23 @@ public class hashing_search {
|
||||
|
||||
/* ハッシュ探索(配列) */
|
||||
int[] nums = { 1, 5, 3, 2, 4, 7, 5, 9, 10, 8 };
|
||||
// ハッシュテーブルを初期化
|
||||
// ハッシュテーブルを初期化する
|
||||
Map<Integer, Integer> map = new HashMap<>();
|
||||
for (int i = 0; i < nums.length; i++) {
|
||||
map.put(nums[i], i); // key: 要素、value: インデックス
|
||||
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); // key: ノード値、value: ノード
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -11,26 +11,26 @@ import utils.*;
|
||||
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;
|
||||
}
|
||||
|
||||
@@ -40,11 +40,11 @@ public class linear_search {
|
||||
/* 配列で線形探索を行う */
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -12,7 +12,7 @@ public class two_sum {
|
||||
/* 方法 1:総当たり列挙 */
|
||||
static int[] twoSumBruteForce(int[] nums, int target) {
|
||||
int size = nums.length;
|
||||
// 2重ループのため、時間計算量は O(n^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)
|
||||
@@ -25,9 +25,9 @@ public class two_sum {
|
||||
/* 方法 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("方法1 res = " + Arrays.toString(res));
|
||||
System.out.println("方法 1 res = " + Arrays.toString(res));
|
||||
// 方法 2
|
||||
res = twoSumHashTable(nums, target);
|
||||
System.out.println("方法2 res = " + Arrays.toString(res));
|
||||
System.out.println("方法 2 res = " + Arrays.toString(res));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -13,10 +13,10 @@ public class bubble_sort {
|
||||
static void bubbleSort(int[] nums) {
|
||||
// 外側のループ:未ソート区間は [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;
|
||||
@@ -25,33 +25,33 @@ public class bubble_sort {
|
||||
}
|
||||
}
|
||||
|
||||
/* バブルソート(フラグ最適化) */
|
||||
/* バブルソート(フラグによる最適化) */
|
||||
static void bubbleSortWithFlag(int[] nums) {
|
||||
// 外側のループ:未ソート区間は [0, i]
|
||||
for (int i = nums.length - 1; i > 0; i--) {
|
||||
boolean flag = false; // フラグを初期化する
|
||||
// 内側のループ:未ソート区間 [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;
|
||||
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));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -11,17 +11,17 @@ 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 に追加
|
||||
// num をバケット i に追加する
|
||||
buckets.get(i).add(num);
|
||||
}
|
||||
// 2. 各バケットをソートする
|
||||
@@ -29,7 +29,7 @@ public class bucket_sort {
|
||||
// 組み込みのソート関数を使う。他のソートアルゴリズムに置き換えてもよい
|
||||
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));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -9,8 +9,8 @@ package chapter_sorting;
|
||||
import java.util.*;
|
||||
|
||||
public class counting_sort {
|
||||
/* 計数ソート */
|
||||
// 簡易実装のため、オブジェクトのソートには使えない
|
||||
/* カウントソート */
|
||||
// 簡易実装。オブジェクトのソートには使えない
|
||||
static void countingSortNaive(int[] nums) {
|
||||
// 1. 配列の最大要素 m を求める
|
||||
int m = 0;
|
||||
@@ -23,7 +23,7 @@ public class counting_sort {
|
||||
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++) {
|
||||
@@ -32,8 +32,8 @@ public class counting_sort {
|
||||
}
|
||||
}
|
||||
|
||||
/* 計数ソート */
|
||||
// 完全な実装で、オブジェクトをソートでき、かつ安定ソートである
|
||||
/* カウントソート */
|
||||
// 完全な実装。オブジェクトをソートでき、安定ソートである
|
||||
static void countingSort(int[] nums) {
|
||||
// 1. 配列の最大要素 m を求める
|
||||
int m = 0;
|
||||
@@ -46,19 +46,19 @@ public class counting_sort {
|
||||
for (int num : nums) {
|
||||
counter[num]++;
|
||||
}
|
||||
// 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する
|
||||
// つまり counter[num]-1 は、num が res に最後に現れるインデックス
|
||||
// 3. counter の累積和を求め、「出現回数」を「末尾のインデックス」に変換する
|
||||
// つまり、counter[num]-1 は res 内で num が最後に現れるインデックスである
|
||||
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 を配置するインデックスを得る
|
||||
res[counter[num] - 1] = num; // 対応するインデックスに num を配置する
|
||||
counter[num]--; // 累積和を 1 減らし、次に num を配置するインデックスを求める
|
||||
}
|
||||
// 結果配列 res で元の配列 nums を上書きする
|
||||
for (int i = 0; i < n; 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));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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] の正しい位置に挿入する
|
||||
// 内側のループ:ソート済み区間 [0, i-1] の正しい位置に base を挿入する
|
||||
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));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -9,28 +9,28 @@ package chapter_sorting;
|
||||
import java.util.*;
|
||||
|
||||
public class merge_sort {
|
||||
/* 左部分配列と右部分配列をマージ */
|
||||
/* 左部分配列と右部分配列をマージする */
|
||||
static void merge(int[] nums, int left, int mid, int right) {
|
||||
// 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]
|
||||
// マージ結果を格納する一時配列 tmp を作成
|
||||
// マージ後の結果を格納する一時配列 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 になったら再帰を終了
|
||||
// 分割フェーズ
|
||||
int mid = left + (right - left) / 2; // 中点を計算
|
||||
mergeSort(nums, left, mid); // 左部分配列を再帰処理
|
||||
mergeSort(nums, mid + 1, right); // 右部分配列を再帰処理
|
||||
// マージフェーズ
|
||||
return; // 部分配列の長さが 1 になったら再帰を終了する
|
||||
// 分割段階
|
||||
int mid = left + (right - left) / 2; // 中央を計算する
|
||||
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));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -17,35 +17,35 @@ class QuickSort {
|
||||
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 つの部分配列の境界へ交換する
|
||||
return i; // 基準値のインデックスを返す
|
||||
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) {
|
||||
@@ -54,49 +54,49 @@ class QuickSortMedian {
|
||||
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))
|
||||
return mid; // m は l と r の間
|
||||
return mid; // m が l と r の間にある
|
||||
if ((m <= l && l <= r) || (r <= l && l <= m))
|
||||
return left; // l は m と r の間
|
||||
return left; // l が m と r の間にある
|
||||
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 つの部分配列の境界へ交換する
|
||||
return i; // 基準値のインデックスを返す
|
||||
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) {
|
||||
@@ -105,34 +105,34 @@ class QuickSortTailCall {
|
||||
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 つの部分配列の境界へ交換する
|
||||
return i; // 基準値のインデックスを返す
|
||||
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 つの部分配列のうち短いほうにクイックソートを適用する
|
||||
if (pivot - left < right - pivot) {
|
||||
quickSort(nums, left, pivot - 1); // 左部分配列を再帰的にソート
|
||||
left = pivot + 1; // 未ソート区間の残りは [pivot + 1, right]
|
||||
quickSort(nums, left, pivot - 1); // 左部分配列を再帰的にソートする
|
||||
left = pivot + 1; // 残りの未ソート区間は [pivot + 1, right]
|
||||
} else {
|
||||
quickSort(nums, pivot + 1, right); // 右部分配列を再帰的にソート
|
||||
right = pivot - 1; // 未ソート区間の残りは [left, pivot - 1]
|
||||
quickSort(nums, pivot + 1, right); // 右部分配列を再帰的にソートする
|
||||
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));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -9,32 +9,32 @@ 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 のバケット配列が必要
|
||||
// 十進数の各桁の範囲は 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 とする
|
||||
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 に格納する
|
||||
int j = counter[d] - 1; // 配列内での d のインデックス j を取得する
|
||||
res[j] = nums[i]; // 現在の要素をインデックス j に入れる
|
||||
counter[d]--; // d の個数を 1 減らす
|
||||
}
|
||||
// 結果で元の配列 nums を上書きする
|
||||
@@ -44,14 +44,14 @@ public class radix_sort {
|
||||
|
||||
/* 基数ソート */
|
||||
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)
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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; // 最小要素のインデックスを記録
|
||||
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));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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; // 両端キューの長さ
|
||||
|
||||
/* コンストラクタ */
|
||||
@@ -20,91 +20,91 @@ class ArrayDeque {
|
||||
front = queSize = 0;
|
||||
}
|
||||
|
||||
/* 両端キューの容量を取得 */
|
||||
/* 両端キューの容量を取得する */
|
||||
public int capacity() {
|
||||
return nums.length;
|
||||
}
|
||||
|
||||
/* 両端キューの長さを取得 */
|
||||
/* 両端キューの長さを取得する */
|
||||
public int size() {
|
||||
return queSize;
|
||||
}
|
||||
|
||||
/* 両端キューが空かどうかを判定 */
|
||||
/* 両端キューが空かどうかを判定する */
|
||||
public boolean isEmpty() {
|
||||
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 が配列の先頭を越えたら末尾に戻るようにする
|
||||
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 を指す
|
||||
// 末尾のインデックス + 1 を指す末尾ポインタを計算する
|
||||
int rear = index(front + queSize);
|
||||
// num をキュー末尾に追加
|
||||
// num をキューの末尾に追加する
|
||||
nums[rear] = num;
|
||||
queSize++;
|
||||
}
|
||||
|
||||
/* キュー先頭からデキュー */
|
||||
/* 先頭からデキューする */
|
||||
public int popFirst() {
|
||||
int num = peekFirst();
|
||||
// 先頭ポインタを 1 つ後ろへ進める
|
||||
// 先頭ポインタを後ろに 1 つ移動する
|
||||
front = index(front + 1);
|
||||
queSize--;
|
||||
return num;
|
||||
}
|
||||
|
||||
/* キュー末尾からデキュー */
|
||||
/* 末尾からデキューする */
|
||||
public int popLast() {
|
||||
int num = peekLast();
|
||||
queSize--;
|
||||
return num;
|
||||
}
|
||||
|
||||
/* キュー先頭の要素にアクセス */
|
||||
/* キューの先頭要素にアクセス */
|
||||
public int peekFirst() {
|
||||
if (isEmpty())
|
||||
throw new IndexOutOfBoundsException();
|
||||
return nums[front];
|
||||
}
|
||||
|
||||
/* キュー末尾の要素にアクセス */
|
||||
/* キューの末尾要素にアクセスする */
|
||||
public int peekLast() {
|
||||
if (isEmpty())
|
||||
throw new IndexOutOfBoundsException();
|
||||
// 末尾要素のインデックスを計算
|
||||
// 末尾要素のインデックスを計算する
|
||||
int last = index(front + queSize - 1);
|
||||
return nums[last];
|
||||
}
|
||||
|
||||
/* 出力用の配列を返す */
|
||||
/* 表示用の配列を返す */
|
||||
public int[] toArray() {
|
||||
// 有効長の範囲内のリスト要素のみを変換
|
||||
// 有効な長さの範囲内にあるリストの要素だけを変換する
|
||||
int[] res = new int[queSize];
|
||||
for (int i = 0, j = front; i < queSize; i++, j++) {
|
||||
res[i] = nums[index(j)];
|
||||
@@ -115,37 +115,37 @@ class ArrayDeque {
|
||||
|
||||
public class array_deque {
|
||||
public static void main(String[] args) {
|
||||
/* 両端キューを初期化 */
|
||||
/* 両端キューを初期化する */
|
||||
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()));
|
||||
|
||||
/* 要素にアクセス */
|
||||
/* 要素にアクセスする */
|
||||
int peekFirst = deque.peekFirst();
|
||||
System.out.println("先頭要素 peekFirst = " + peekFirst);
|
||||
System.out.println("キューの先頭要素 peekFirst = " + peekFirst);
|
||||
int peekLast = deque.peekLast();
|
||||
System.out.println("末尾要素 peekLast = " + peekLast);
|
||||
System.out.println("キューの末尾要素 peekLast = " + peekLast);
|
||||
|
||||
/* 要素をエンキュー */
|
||||
/* 要素をエンキューする */
|
||||
deque.pushLast(4);
|
||||
System.out.println("要素 4 を末尾にエンキューした後の deque = " + Arrays.toString(deque.toArray()));
|
||||
System.out.println("要素 4 を末尾にエンキューした後 deque = " + Arrays.toString(deque.toArray()));
|
||||
deque.pushFirst(1);
|
||||
System.out.println("要素 1 を先頭にエンキューした後の deque = " + Arrays.toString(deque.toArray()));
|
||||
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()));
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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) {
|
||||
@@ -19,7 +19,7 @@ class ArrayQueue {
|
||||
front = queSize = 0;
|
||||
}
|
||||
|
||||
/* キューの容量を取得 */
|
||||
/* キューの容量を取得する */
|
||||
public int capacity() {
|
||||
return nums.length;
|
||||
}
|
||||
@@ -29,7 +29,7 @@ class ArrayQueue {
|
||||
return queSize;
|
||||
}
|
||||
|
||||
/* キューが空かどうかを判定 */
|
||||
/* キューが空か判定 */
|
||||
public boolean isEmpty() {
|
||||
return queSize == 0;
|
||||
}
|
||||
@@ -37,13 +37,13 @@ class ArrayQueue {
|
||||
/* エンキュー */
|
||||
public void push(int num) {
|
||||
if (queSize == capacity()) {
|
||||
System.out.println("キューは満杯です");
|
||||
System.out.println("キューが満杯です");
|
||||
return;
|
||||
}
|
||||
// 末尾ポインタを計算し、末尾インデックス + 1 を指す
|
||||
// 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする
|
||||
// 末尾のインデックス + 1 を指す末尾ポインタを計算する
|
||||
// 剰余演算で、rear が配列末尾を越えたら先頭へ戻る
|
||||
int rear = (front + queSize) % capacity();
|
||||
// num をキュー末尾に追加
|
||||
// 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() {
|
||||
// 有効長の範囲内のリスト要素のみを変換
|
||||
// 有効な長さの範囲内にあるリストの要素だけを変換する
|
||||
int[] res = new int[queSize];
|
||||
for (int i = 0, j = front; i < queSize; i++, j++) {
|
||||
res[i] = nums[j % capacity()];
|
||||
@@ -77,11 +77,11 @@ class ArrayQueue {
|
||||
|
||||
public class array_queue {
|
||||
public static void main(String[] args) {
|
||||
/* キューを初期化 */
|
||||
/* キューを初期化する */
|
||||
int capacity = 10;
|
||||
ArrayQueue queue = new ArrayQueue(capacity);
|
||||
|
||||
/* 要素をエンキュー */
|
||||
/* 要素をエンキューする */
|
||||
queue.push(1);
|
||||
queue.push(3);
|
||||
queue.push(2);
|
||||
@@ -89,27 +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 = " + pop + "、デキュー後の queue = " + 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("第 " + i + " 回のエンキューとデキューの後 queue = " + Arrays.toString(queue.toArray()));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -8,7 +8,7 @@ package chapter_stack_and_queue;
|
||||
|
||||
import java.util.*;
|
||||
|
||||
/* 配列ベースのスタック */
|
||||
/* 配列で実装したスタック */
|
||||
class ArrayStack {
|
||||
private ArrayList<Integer> stack;
|
||||
|
||||
@@ -17,12 +17,12 @@ class ArrayStack {
|
||||
stack = new ArrayList<>();
|
||||
}
|
||||
|
||||
/* スタックの長さを取得 */
|
||||
/* スタックの長さを取得する */
|
||||
public int size() {
|
||||
return stack.size();
|
||||
}
|
||||
|
||||
/* スタックが空かどうかを判定 */
|
||||
/* スタックが空かどうかを判定する */
|
||||
public boolean isEmpty() {
|
||||
return size() == 0;
|
||||
}
|
||||
@@ -39,7 +39,7 @@ class ArrayStack {
|
||||
return stack.remove(size() - 1);
|
||||
}
|
||||
|
||||
/* スタックトップの要素にアクセス */
|
||||
/* スタックの先頭要素にアクセスする */
|
||||
public int peek() {
|
||||
if (isEmpty())
|
||||
throw new IndexOutOfBoundsException();
|
||||
@@ -54,10 +54,10 @@ class ArrayStack {
|
||||
|
||||
public class array_stack {
|
||||
public static void main(String[] args) {
|
||||
/* スタックを初期化 */
|
||||
/* スタックを初期化する */
|
||||
ArrayStack stack = new ArrayStack();
|
||||
|
||||
/* 要素をプッシュ */
|
||||
/* 要素をプッシュする */
|
||||
stack.push(1);
|
||||
stack.push(3);
|
||||
stack.push(2);
|
||||
@@ -65,20 +65,20 @@ public class array_stack {
|
||||
stack.push(4);
|
||||
System.out.println("スタック stack = " + Arrays.toString(stack.toArray()));
|
||||
|
||||
/* スタックトップの要素にアクセス */
|
||||
/* スタックの先頭要素にアクセスする */
|
||||
int peek = stack.peek();
|
||||
System.out.println("スタックトップ要素 peek = " + peek);
|
||||
System.out.println("スタックの先頭要素 peek = " + peek);
|
||||
|
||||
/* 要素をポップ */
|
||||
/* 要素をポップする */
|
||||
int pop = stack.pop();
|
||||
System.out.println("ポップした要素 pop = " + pop + "、ポップ後の stack = " + Arrays.toString(stack.toArray()));
|
||||
System.out.println("ポップした要素 pop = " + pop + "、ポップ後 stack = " + Arrays.toString(stack.toArray()));
|
||||
|
||||
/* スタックの長さを取得 */
|
||||
/* スタックの長さを取得する */
|
||||
int size = stack.size();
|
||||
System.out.println("スタックの長さ size = " + size);
|
||||
|
||||
/* 空かどうかを判定 */
|
||||
/* 空かどうかを判定する */
|
||||
boolean isEmpty = stack.isEmpty();
|
||||
System.out.println("スタックが空かどうか = " + isEmpty);
|
||||
System.out.println("スタックは空か = " + isEmpty);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -10,37 +10,37 @@ import java.util.*;
|
||||
|
||||
public class deque {
|
||||
public static void main(String[] args) {
|
||||
/* 両端キューを初期化 */
|
||||
/* 両端キューを初期化する */
|
||||
Deque<Integer> deque = new LinkedList<>();
|
||||
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);
|
||||
System.out.println("キューの先頭要素 peekFirst = " + peekFirst);
|
||||
int peekLast = deque.peekLast();
|
||||
System.out.println("末尾要素 peekLast = " + 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 = " + deque);
|
||||
System.out.println("末尾からデキューした要素 = " + popLast + "、末尾からデキューした後 deque = " + deque);
|
||||
int popFirst = deque.pollFirst();
|
||||
System.out.println("先頭からデキューした要素 = " + popFirst + "、先頭からデキューした後の deque = " + 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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -8,11 +8,11 @@ package chapter_stack_and_queue;
|
||||
|
||||
import java.util.*;
|
||||
|
||||
/* 双方向連結リストノード */
|
||||
/* 双方向連結リストのノード */
|
||||
class ListNode {
|
||||
int val; // ノード値
|
||||
int val; // ノードの値
|
||||
ListNode next; // 後続ノードへの参照
|
||||
ListNode prev; // 前駆ノードへの参照
|
||||
ListNode prev; // 前のノードへの参照
|
||||
|
||||
ListNode(int val) {
|
||||
this.val = val;
|
||||
@@ -20,21 +20,21 @@ class ListNode {
|
||||
}
|
||||
}
|
||||
|
||||
/* 双方向連結リストベースの両端キュー */
|
||||
/* 双方向連結リストで実装した両端キュー */
|
||||
class LinkedListDeque {
|
||||
private ListNode front, rear; // 先頭ノード front、末尾ノード rear
|
||||
private ListNode front, rear; // 先頭ノード front 、末尾ノード rear
|
||||
private int queSize = 0; // 両端キューの長さ
|
||||
|
||||
public LinkedListDeque() {
|
||||
front = rear = null;
|
||||
}
|
||||
|
||||
/* 両端キューの長さを取得 */
|
||||
/* 両端キューの長さを取得する */
|
||||
public int size() {
|
||||
return queSize;
|
||||
}
|
||||
|
||||
/* 両端キューが空かどうかを判定 */
|
||||
/* 両端キューが空かどうかを判定する */
|
||||
public boolean isEmpty() {
|
||||
return size() == 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; // 先頭ノードを更新する
|
||||
// 末尾へのエンキュー操作
|
||||
} else {
|
||||
// node を連結リストの末尾に追加
|
||||
// node を連結リストの末尾に追加する
|
||||
rear.next = node;
|
||||
node.prev = rear;
|
||||
rear = node; // 末尾ノードを更新する
|
||||
}
|
||||
queSize++; // キューの長さを更新
|
||||
queSize++; // キューの長さを更新する
|
||||
}
|
||||
|
||||
/* キュー先頭にエンキュー */
|
||||
/* 先頭にエンキューする */
|
||||
public void pushFirst(int num) {
|
||||
push(num, true);
|
||||
}
|
||||
|
||||
/* キュー末尾にエンキュー */
|
||||
/* 末尾にエンキューする */
|
||||
public void pushLast(int num) {
|
||||
push(num, false);
|
||||
}
|
||||
@@ -76,58 +76,58 @@ class LinkedListDeque {
|
||||
if (isEmpty())
|
||||
throw new IndexOutOfBoundsException();
|
||||
int val;
|
||||
// 要素が1つの場合、先頭と末尾は同じノードを指す
|
||||
// キューの長さが 1 のとき、先頭と末尾は同じノードを指す
|
||||
if (queSize == 1) {
|
||||
val = front.val;
|
||||
front = null;
|
||||
rear = null;
|
||||
}
|
||||
// キュー先頭からの取り出し
|
||||
// 先頭からのデキュー操作
|
||||
else if (isFront) {
|
||||
val = front.val; // 先頭ノードの値を一時保存
|
||||
// 先頭ノードを削除
|
||||
val = front.val; // 先頭ノードの値を一時保存する
|
||||
// 先頭ノードを削除する
|
||||
ListNode fNext = front.next;
|
||||
fNext.prev = null;
|
||||
front.next = null;
|
||||
front = fNext; // 先頭ノードを更新する
|
||||
// キュー末尾からの取り出し
|
||||
// 末尾からのデキュー操作
|
||||
} else {
|
||||
val = rear.val; // 末尾ノードの値を一時保存
|
||||
// 末尾ノードを削除
|
||||
val = rear.val; // 末尾ノードの値を一時保存する
|
||||
// 末尾ノードを削除する
|
||||
ListNode rPrev = rear.prev;
|
||||
rPrev.next = null;
|
||||
rear.prev = null;
|
||||
rear = rPrev; // 末尾ノードを更新する
|
||||
}
|
||||
queSize--; // キューの長さを更新
|
||||
queSize--; // キューの長さを更新する
|
||||
return val;
|
||||
}
|
||||
|
||||
/* キュー先頭からデキュー */
|
||||
/* 先頭からデキューする */
|
||||
public int popFirst() {
|
||||
return pop(true);
|
||||
}
|
||||
|
||||
/* キュー末尾からデキュー */
|
||||
/* 末尾からデキューする */
|
||||
public int popLast() {
|
||||
return pop(false);
|
||||
}
|
||||
|
||||
/* キュー先頭の要素にアクセス */
|
||||
/* キューの先頭要素にアクセス */
|
||||
public int peekFirst() {
|
||||
if (isEmpty())
|
||||
throw new 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,37 +141,37 @@ class LinkedListDeque {
|
||||
|
||||
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()));
|
||||
|
||||
/* 要素にアクセス */
|
||||
/* 要素にアクセスする */
|
||||
int peekFirst = deque.peekFirst();
|
||||
System.out.println("先頭要素 peekFirst = " + peekFirst);
|
||||
System.out.println("キューの先頭要素 peekFirst = " + peekFirst);
|
||||
int peekLast = deque.peekLast();
|
||||
System.out.println("末尾要素 peekLast = " + peekLast);
|
||||
System.out.println("キューの末尾要素 peekLast = " + peekLast);
|
||||
|
||||
/* 要素をエンキュー */
|
||||
/* 要素をエンキューする */
|
||||
deque.pushLast(4);
|
||||
System.out.println("要素 4 を末尾にエンキューした後の deque = " + Arrays.toString(deque.toArray()));
|
||||
System.out.println("要素 4 を末尾にエンキューした後 deque = " + Arrays.toString(deque.toArray()));
|
||||
deque.pushFirst(1);
|
||||
System.out.println("要素 1 を先頭にエンキューした後の deque = " + Arrays.toString(deque.toArray()));
|
||||
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()));
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -8,9 +8,9 @@ package chapter_stack_and_queue;
|
||||
|
||||
import java.util.*;
|
||||
|
||||
/* 連結リストベースのキュー */
|
||||
/* 連結リストで実装したキュー */
|
||||
class LinkedListQueue {
|
||||
private ListNode front, rear; // 先頭ノード front、末尾ノード rear
|
||||
private ListNode front, rear; // 先頭ノード front 、末尾ノード rear
|
||||
private int queSize = 0;
|
||||
|
||||
public LinkedListQueue() {
|
||||
@@ -23,20 +23,20 @@ class LinkedListQueue {
|
||||
return queSize;
|
||||
}
|
||||
|
||||
/* キューが空かどうかを判定 */
|
||||
/* キューが空か判定 */
|
||||
public boolean isEmpty() {
|
||||
return size() == 0;
|
||||
}
|
||||
|
||||
/* エンキュー */
|
||||
public void push(int num) {
|
||||
// 末尾ノードの後ろに num を追加
|
||||
// 末尾ノードの後ろに num を追加する
|
||||
ListNode node = new ListNode(num);
|
||||
// キューが空なら、先頭・末尾ノードをともにそのノードに設定
|
||||
// キューが空の場合、先頭と末尾の両方がこのノードを指すようにする
|
||||
if (front == null) {
|
||||
front = node;
|
||||
rear = node;
|
||||
// キューが空でなければ、そのノードを末尾ノードの後ろに追加
|
||||
// キューが空でない場合、このノードを末尾ノードの後ろに追加する
|
||||
} else {
|
||||
rear.next = node;
|
||||
rear = node;
|
||||
@@ -47,13 +47,13 @@ class LinkedListQueue {
|
||||
/* デキュー */
|
||||
public int pop() {
|
||||
int num = peek();
|
||||
// 先頭ノードを削除
|
||||
// 先頭ノードを削除する
|
||||
front = front.next;
|
||||
queSize--;
|
||||
return num;
|
||||
}
|
||||
|
||||
/* キュー先頭の要素にアクセス */
|
||||
/* キューの先頭要素にアクセス */
|
||||
public int peek() {
|
||||
if (isEmpty())
|
||||
throw new IndexOutOfBoundsException();
|
||||
@@ -74,10 +74,10 @@ class LinkedListQueue {
|
||||
|
||||
public class linkedlist_queue {
|
||||
public static void main(String[] args) {
|
||||
/* キューを初期化 */
|
||||
/* キューを初期化する */
|
||||
LinkedListQueue queue = new LinkedListQueue();
|
||||
|
||||
/* 要素をエンキュー */
|
||||
/* 要素をエンキューする */
|
||||
queue.push(1);
|
||||
queue.push(3);
|
||||
queue.push(2);
|
||||
@@ -85,20 +85,20 @@ public class linkedlist_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 = " + pop + "、デキュー後の queue = " + 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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -9,21 +9,21 @@ package chapter_stack_and_queue;
|
||||
import java.util.*;
|
||||
import utils.*;
|
||||
|
||||
/* 連結リストベースのスタック */
|
||||
/* 連結リストで実装したスタック */
|
||||
class LinkedListStack {
|
||||
private ListNode stackPeek; // 先頭ノードをスタックトップとする
|
||||
private ListNode stackPeek; // 先頭ノードをスタックの先頭とする
|
||||
private int stkSize = 0; // スタックの長さ
|
||||
|
||||
public LinkedListStack() {
|
||||
stackPeek = null;
|
||||
}
|
||||
|
||||
/* スタックの長さを取得 */
|
||||
/* スタックの長さを取得する */
|
||||
public int size() {
|
||||
return stkSize;
|
||||
}
|
||||
|
||||
/* スタックが空かどうかを判定 */
|
||||
/* スタックが空かどうかを判定する */
|
||||
public boolean isEmpty() {
|
||||
return size() == 0;
|
||||
}
|
||||
@@ -44,7 +44,7 @@ class LinkedListStack {
|
||||
return num;
|
||||
}
|
||||
|
||||
/* スタックトップの要素にアクセス */
|
||||
/* スタックの先頭要素にアクセスする */
|
||||
public int peek() {
|
||||
if (isEmpty())
|
||||
throw new IndexOutOfBoundsException();
|
||||
@@ -65,10 +65,10 @@ class LinkedListStack {
|
||||
|
||||
public class linkedlist_stack {
|
||||
public static void main(String[] args) {
|
||||
/* スタックを初期化 */
|
||||
/* スタックを初期化する */
|
||||
LinkedListStack stack = new LinkedListStack();
|
||||
|
||||
/* 要素をプッシュ */
|
||||
/* 要素をプッシュする */
|
||||
stack.push(1);
|
||||
stack.push(3);
|
||||
stack.push(2);
|
||||
@@ -76,20 +76,20 @@ public class linkedlist_stack {
|
||||
stack.push(4);
|
||||
System.out.println("スタック stack = " + Arrays.toString(stack.toArray()));
|
||||
|
||||
/* スタックトップの要素にアクセス */
|
||||
/* スタックの先頭要素にアクセスする */
|
||||
int peek = stack.peek();
|
||||
System.out.println("スタックトップ要素 peek = " + peek);
|
||||
System.out.println("スタックの先頭要素 peek = " + peek);
|
||||
|
||||
/* 要素をポップ */
|
||||
/* 要素をポップする */
|
||||
int pop = stack.pop();
|
||||
System.out.println("ポップした要素 pop = " + pop + "、ポップ後の stack = " + Arrays.toString(stack.toArray()));
|
||||
System.out.println("ポップした要素 pop = " + pop + "、ポップ後 stack = " + Arrays.toString(stack.toArray()));
|
||||
|
||||
/* スタックの長さを取得 */
|
||||
/* スタックの長さを取得する */
|
||||
int size = stack.size();
|
||||
System.out.println("スタックの長さ size = " + size);
|
||||
|
||||
/* 空かどうかを判定 */
|
||||
/* 空かどうかを判定する */
|
||||
boolean isEmpty = stack.isEmpty();
|
||||
System.out.println("スタックが空かどうか = " + isEmpty);
|
||||
System.out.println("スタックは空か = " + isEmpty);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -10,10 +10,10 @@ import java.util.*;
|
||||
|
||||
public class queue {
|
||||
public static void main(String[] args) {
|
||||
/* キューを初期化 */
|
||||
/* キューを初期化する */
|
||||
Queue<Integer> queue = new LinkedList<>();
|
||||
|
||||
/* 要素をエンキュー */
|
||||
/* 要素をエンキューする */
|
||||
queue.offer(1);
|
||||
queue.offer(3);
|
||||
queue.offer(2);
|
||||
@@ -21,20 +21,20 @@ public class queue {
|
||||
queue.offer(4);
|
||||
System.out.println("キュー queue = " + queue);
|
||||
|
||||
/* キュー先頭の要素にアクセス */
|
||||
/* キューの先頭要素にアクセス */
|
||||
int peek = queue.peek();
|
||||
System.out.println("先頭要素 peek = " + peek);
|
||||
System.out.println("キューの先頭要素 peek = " + peek);
|
||||
|
||||
/* 要素をデキュー */
|
||||
/* 要素をデキューする */
|
||||
int pop = queue.poll();
|
||||
System.out.println("デキューした要素 pop = " + pop + "、デキュー後の queue = " + queue);
|
||||
System.out.println("デキューした要素 pop = " + pop + "、デキュー後 queue = " + queue);
|
||||
|
||||
/* キューの長さを取得 */
|
||||
int size = queue.size();
|
||||
System.out.println("キューの長さ size = " + size);
|
||||
|
||||
/* キューが空かどうかを判定 */
|
||||
/* キューが空か判定 */
|
||||
boolean isEmpty = queue.isEmpty();
|
||||
System.out.println("キューが空かどうか = " + isEmpty);
|
||||
System.out.println("キューは空か = " + isEmpty);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -10,10 +10,10 @@ import java.util.*;
|
||||
|
||||
public class stack {
|
||||
public static void main(String[] args) {
|
||||
/* スタックを初期化 */
|
||||
/* スタックを初期化する */
|
||||
Stack<Integer> stack = new Stack<>();
|
||||
|
||||
/* 要素をプッシュ */
|
||||
/* 要素をプッシュする */
|
||||
stack.push(1);
|
||||
stack.push(3);
|
||||
stack.push(2);
|
||||
@@ -21,20 +21,20 @@ public class stack {
|
||||
stack.push(4);
|
||||
System.out.println("スタック stack = " + stack);
|
||||
|
||||
/* スタックトップの要素にアクセス */
|
||||
/* スタックの先頭要素にアクセスする */
|
||||
int peek = stack.peek();
|
||||
System.out.println("スタックトップ要素 peek = " + peek);
|
||||
System.out.println("スタックの先頭要素 peek = " + peek);
|
||||
|
||||
/* 要素をポップ */
|
||||
/* 要素をポップする */
|
||||
int pop = stack.pop();
|
||||
System.out.println("ポップした要素 pop = " + pop + "、ポップ後の stack = " + stack);
|
||||
System.out.println("ポップした要素 pop = " + pop + "、ポップ後 stack = " + stack);
|
||||
|
||||
/* スタックの長さを取得 */
|
||||
/* スタックの長さを取得する */
|
||||
int size = stack.size();
|
||||
System.out.println("スタックの長さ size = " + size);
|
||||
|
||||
/* 空かどうかを判定 */
|
||||
/* 空かどうかを判定する */
|
||||
boolean isEmpty = stack.isEmpty();
|
||||
System.out.println("スタックが空かどうか = " + isEmpty);
|
||||
System.out.println("スタックは空か = " + isEmpty);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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 のノードの値を取得 */
|
||||
/* インデックス 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,39 +57,39 @@ 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);
|
||||
// 中順走査
|
||||
// 通りがけ順走査
|
||||
if ("in".equals(order))
|
||||
res.add(val(i));
|
||||
dfs(right(i), order, res);
|
||||
// 後順走査
|
||||
// 帰りがけ順走査
|
||||
if ("post".equals(order))
|
||||
res.add(val(i));
|
||||
}
|
||||
|
||||
/* 先行順走査 */
|
||||
/* 行きがけ順走査 */
|
||||
public List<Integer> preOrder() {
|
||||
List<Integer> res = new ArrayList<>();
|
||||
dfs(0, "pre", res);
|
||||
return res;
|
||||
}
|
||||
|
||||
/* 中順走査 */
|
||||
/* 通りがけ順走査 */
|
||||
public List<Integer> inOrder() {
|
||||
List<Integer> res = new ArrayList<>();
|
||||
dfs(0, "in", res);
|
||||
return res;
|
||||
}
|
||||
|
||||
/* 後順走査 */
|
||||
/* 帰りがけ順走査 */
|
||||
public List<Integer> postOrder() {
|
||||
List<Integer> res = new ArrayList<>();
|
||||
dfs(0, "post", res);
|
||||
@@ -99,38 +99,38 @@ 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);
|
||||
System.out.println("\n二分木を初期化\n");
|
||||
System.out.println("二分木の配列表現:");
|
||||
System.out.println("\n二分木を初期化する\n");
|
||||
System.out.println("二分木の配列表現:");
|
||||
System.out.println(arr);
|
||||
System.out.println("二分木の連結リスト表現:");
|
||||
System.out.println("二分木の連結リスト表現:");
|
||||
PrintUtil.printTree(root);
|
||||
|
||||
// 配列表現による二分木クラス
|
||||
// 配列で表した二分木クラス
|
||||
ArrayBinaryTree abt = new ArrayBinaryTree(arr);
|
||||
|
||||
// ノードにアクセス
|
||||
// ノードにアクセスする
|
||||
int i = 1;
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -12,19 +12,19 @@ import utils.*;
|
||||
class AVLTree {
|
||||
TreeNode root; // 根ノード
|
||||
|
||||
/* ノードの高さを取得 */
|
||||
/* ノードの高さを取得する */
|
||||
public int height(TreeNode node) {
|
||||
// 空ノードの高さは -1、葉ノードの高さは 0
|
||||
// 空ノードの高さは -1 、葉ノードの高さは 0
|
||||
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
|
||||
if (node == null)
|
||||
@@ -33,11 +33,11 @@ class AVLTree {
|
||||
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;
|
||||
// ノードの高さを更新する
|
||||
@@ -47,11 +47,11 @@ class AVLTree {
|
||||
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;
|
||||
// ノードの高さを更新する
|
||||
@@ -61,9 +61,9 @@ class AVLTree {
|
||||
return child;
|
||||
}
|
||||
|
||||
/* 回転操作を行い、この部分木の平衡を回復する */
|
||||
/* 回転操作によって、この部分木の平衡を回復する */
|
||||
private TreeNode rotate(TreeNode node) {
|
||||
// ノード node の平衡係数を取得
|
||||
// ノード node の平衡係数を取得する
|
||||
int balanceFactor = balanceFactor(node);
|
||||
// 左に偏った木
|
||||
if (balanceFactor > 1) {
|
||||
@@ -71,7 +71,7 @@ class AVLTree {
|
||||
// 右回転
|
||||
return rightRotate(node);
|
||||
} else {
|
||||
// 左回転してから右回転
|
||||
// 左回転してから右回転する
|
||||
node.left = leftRotate(node.left);
|
||||
return rightRotate(node);
|
||||
}
|
||||
@@ -82,16 +82,16 @@ class AVLTree {
|
||||
// 左回転
|
||||
return leftRotate(node);
|
||||
} else {
|
||||
// 右回転してから左回転
|
||||
// 右回転してから左回転する
|
||||
node.right = rightRotate(node.right);
|
||||
return leftRotate(node);
|
||||
}
|
||||
}
|
||||
// 平衡木なので回転不要、そのまま返す
|
||||
// 平衡な木なので、回転せずにそのまま返す
|
||||
return node;
|
||||
}
|
||||
|
||||
/* ノードを挿入 */
|
||||
/* ノードを挿入する */
|
||||
public void insert(int val) {
|
||||
root = insertHelper(root, val);
|
||||
}
|
||||
@@ -100,21 +100,21 @@ class AVLTree {
|
||||
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; // 重複ノードは挿入せず、そのまま返す
|
||||
return node; // 重複したノードは挿入せず、そのまま戻る
|
||||
updateHeight(node); // ノードの高さを更新する
|
||||
/* 2. 回転操作を行い、部分木の平衡を回復する */
|
||||
/* 2. 回転操作によって、この部分木の平衡を回復する */
|
||||
node = rotate(node);
|
||||
// 部分木の根ノードを返す
|
||||
return node;
|
||||
}
|
||||
|
||||
/* ノードを削除 */
|
||||
/* ノードを削除する */
|
||||
public void remove(int val) {
|
||||
root = removeHelper(root, val);
|
||||
}
|
||||
@@ -123,7 +123,7 @@ class AVLTree {
|
||||
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 の場合、node をそのまま削除して返す
|
||||
// 子ノード数 = 0 の場合、node を削除して戻る
|
||||
if (child == null)
|
||||
return null;
|
||||
// 子ノード数 = 1 の場合、node をそのまま削除する
|
||||
// 子ノード数 = 1 の場合、node を削除する
|
||||
else
|
||||
node = child;
|
||||
} else {
|
||||
// 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える
|
||||
// 子ノード数 = 2 の場合、通りがけ順で次のノードを削除し、そのノードで現在のノードを置き換える
|
||||
TreeNode temp = node.right;
|
||||
while (temp.left != null) {
|
||||
temp = temp.left;
|
||||
@@ -148,28 +148,28 @@ class AVLTree {
|
||||
}
|
||||
}
|
||||
updateHeight(node); // ノードの高さを更新する
|
||||
/* 2. 回転操作を行い、部分木の平衡を回復する */
|
||||
/* 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,13 +177,13 @@ 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);
|
||||
}
|
||||
|
||||
@@ -191,8 +191,8 @@ public class avl_tree {
|
||||
/* 空の 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 木がどのように平衡を保つかに注目してほしい
|
||||
/* ノードを削除する */
|
||||
// ノード削除後、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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -18,41 +18,41 @@ class BinarySearchTree {
|
||||
root = null;
|
||||
}
|
||||
|
||||
/* 二分木の根ノードを取得 */
|
||||
/* 二分木の根ノードを取得する */
|
||||
public TreeNode getRoot() {
|
||||
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;
|
||||
@@ -63,7 +63,7 @@ class BinarySearchTree {
|
||||
else
|
||||
cur = cur.left;
|
||||
}
|
||||
// ノードを挿入
|
||||
// ノードを挿入する
|
||||
TreeNode node = new TreeNode(num);
|
||||
if (pre.val < num)
|
||||
pre.right = node;
|
||||
@@ -71,31 +71,31 @@ class BinarySearchTree {
|
||||
pre.left = node;
|
||||
}
|
||||
|
||||
/* ノードを削除 */
|
||||
/* ノードを削除する */
|
||||
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 or 1
|
||||
// 子ノード数 = 0 または 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 を削除する
|
||||
if (cur != root) {
|
||||
@@ -104,18 +104,18 @@ class BinarySearchTree {
|
||||
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);
|
||||
// tmp で cur を上書きする
|
||||
cur.val = tmp.val;
|
||||
@@ -125,34 +125,34 @@ class BinarySearchTree {
|
||||
|
||||
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());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -10,31 +10,31 @@ import utils.*;
|
||||
|
||||
public class binary_tree {
|
||||
public static void main(String[] args) {
|
||||
/* 二分木を初期化 */
|
||||
// ノードを初期化
|
||||
/* 二分木を初期化する */
|
||||
// ノードを初期化する
|
||||
TreeNode n1 = new TreeNode(1);
|
||||
TreeNode n2 = new TreeNode(2);
|
||||
TreeNode n3 = new TreeNode(3);
|
||||
TreeNode n4 = new TreeNode(4);
|
||||
TreeNode n5 = new TreeNode(5);
|
||||
// ノード間の参照(ポインタ)を構築する
|
||||
// ノード間の参照(ポインタ)を設定する
|
||||
n1.left = n2;
|
||||
n1.right = n3;
|
||||
n2.left = n4;
|
||||
n2.right = n5;
|
||||
System.out.println("\n二分木を初期化\n");
|
||||
System.out.println("\n二分木を初期化する\n");
|
||||
PrintUtil.printTree(n1);
|
||||
|
||||
/* ノードの挿入と削除 */
|
||||
TreeNode P = new TreeNode(0);
|
||||
// n1 -> n2 の間にノード P を挿入
|
||||
// n1 -> n2 の間にノード P を挿入する
|
||||
n1.left = P;
|
||||
P.left = n2;
|
||||
System.out.println("\nノード P を挿入後\n");
|
||||
System.out.println("\nノード P の挿入後\n");
|
||||
PrintUtil.printTree(n1);
|
||||
// ノード P を削除
|
||||
// ノード P を削除する
|
||||
n1.left = n2;
|
||||
System.out.println("\nノード P を削除後\n");
|
||||
System.out.println("\nノード P の削除後\n");
|
||||
PrintUtil.printTree(n1);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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(); // デキュー
|
||||
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");
|
||||
System.out.println("\n二分木を初期化する\n");
|
||||
PrintUtil.printTree(root);
|
||||
|
||||
/* レベル順走査 */
|
||||
List<Integer> list = levelOrder(root);
|
||||
System.out.println("\nレベル順走査のノード出力シーケンス = " + list);
|
||||
System.out.println("\nレベル順走査で表示するノードの順序 = " + list);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -10,10 +10,10 @@ import utils.*;
|
||||
import java.util.*;
|
||||
|
||||
public class binary_tree_dfs {
|
||||
// 走査順序を格納するリストを初期化
|
||||
// 走査順序を格納するリストを初期化する
|
||||
static ArrayList<Integer> list = new ArrayList<>();
|
||||
|
||||
/* 先行順走査 */
|
||||
/* 行きがけ順走査 */
|
||||
static void preOrder(TreeNode root) {
|
||||
if (root == null)
|
||||
return;
|
||||
@@ -23,46 +23,46 @@ public class binary_tree_dfs {
|
||||
preOrder(root.right);
|
||||
}
|
||||
|
||||
/* 中順走査 */
|
||||
/* 通りがけ順走査 */
|
||||
static void inOrder(TreeNode root) {
|
||||
if (root == null)
|
||||
return;
|
||||
// 訪問優先順: 左部分木 -> 根ノード -> 右部分木
|
||||
// 訪問順序:左部分木 -> 根ノード -> 右部分木
|
||||
inOrder(root.left);
|
||||
list.add(root.val);
|
||||
inOrder(root.right);
|
||||
}
|
||||
|
||||
/* 後順走査 */
|
||||
/* 帰りがけ順走査 */
|
||||
static void postOrder(TreeNode root) {
|
||||
if (root == null)
|
||||
return;
|
||||
// 訪問優先順: 左部分木 -> 右部分木 -> 根ノード
|
||||
// 訪問順序:左部分木 -> 右部分木 -> 根ノード
|
||||
postOrder(root.left);
|
||||
postOrder(root.right);
|
||||
list.add(root.val);
|
||||
}
|
||||
|
||||
public static void main(String[] args) {
|
||||
/* 二分木を初期化 */
|
||||
// ここでは、配列から直接二分木を生成する関数を利用する
|
||||
/* 二分木を初期化する */
|
||||
// ここでは配列から二分木を直接生成する関数を使う
|
||||
TreeNode root = TreeNode.listToTree(Arrays.asList(1, 2, 3, 4, 5, 6, 7));
|
||||
System.out.println("\n二分木を初期化\n");
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
|
||||
package utils;
|
||||
|
||||
/* 連結リストノード */
|
||||
/* 連結リストのノード */
|
||||
public class ListNode {
|
||||
public int val;
|
||||
public ListNode next;
|
||||
@@ -15,7 +15,7 @@ public class ListNode {
|
||||
val = x;
|
||||
}
|
||||
|
||||
/* リストを連結リストにデシリアライズする */
|
||||
/* リストをデシリアライズして連結リストにする */
|
||||
public static ListNode arrToLinkedList(int[] arr) {
|
||||
ListNode dum = new ListNode(0);
|
||||
ListNode head = dum;
|
||||
|
||||
@@ -19,7 +19,7 @@ class Trunk {
|
||||
};
|
||||
|
||||
public class PrintUtil {
|
||||
/* 行列を出力する(Array) */
|
||||
/* 行列を表示する(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) */
|
||||
/* 行列を表示する(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);
|
||||
}
|
||||
|
||||
/**
|
||||
* 二分木を出力
|
||||
* This tree printer is borrowed from TECHIE DELIGHT
|
||||
* https://www.techiedelight.com/c-program-print-binary-tree/
|
||||
*/
|
||||
* 二分木を表示する
|
||||
* この木の表示処理は 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,14 +97,14 @@ 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("ヒープの配列表現:");
|
||||
|
||||
@@ -8,35 +8,35 @@ package utils;
|
||||
|
||||
import java.util.*;
|
||||
|
||||
/* 二分木ノードクラス */
|
||||
/* 二分木のノードクラス */
|
||||
public class TreeNode {
|
||||
public int val; // ノード値
|
||||
public int val; // ノードの値
|
||||
public int height; // ノードの高さ
|
||||
public TreeNode left; // 左子ノードへの参照
|
||||
public TreeNode right; // 右子ノードへの参照
|
||||
public TreeNode left; // 左の子ノードへの参照
|
||||
public TreeNode right; // 右の子ノードへの参照
|
||||
|
||||
/* コンストラクタ */
|
||||
public TreeNode(int x) {
|
||||
val = x;
|
||||
}
|
||||
|
||||
// シリアライズの符号化規則は以下を参照:
|
||||
// https://www.hello-algo.com/chapter_tree/array_representation_of_tree/
|
||||
// 二分木の配列表現:
|
||||
// シリアライズの符号化規則は次を参照:
|
||||
// https://www.hello-algo.com/ja/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,7 +64,7 @@ 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);
|
||||
|
||||
@@ -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) {
|
||||
|
||||
Reference in New Issue
Block a user