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

Re-translate the Japanese version (#1871)

Browse Source 
* Retranslate Japanese docs with GPT-5.4

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

10
ja/codes/cpp/.gitignore vendored Normal file
View File

@@ -0,0 +1,10 @@
# Ignore all
*
# Unignore all with extensions
!*.*
# Unignore all dirs
!*/
*.dSYM/
build/

20
ja/codes/cpp/CMakeLists.txt Normal file
View File

@@ -0,0 +1,20 @@
cmake_minimum_required(VERSION 3.10)
project(hello_algo CXX)
set(CMAKE_CXX_STANDARD 11)
include_directories(./include)
add_subdirectory(chapter_computational_complexity)
add_subdirectory(chapter_array_and_linkedlist)
add_subdirectory(chapter_stack_and_queue)
add_subdirectory(chapter_hashing)
add_subdirectory(chapter_tree)
add_subdirectory(chapter_heap)
add_subdirectory(chapter_graph)
add_subdirectory(chapter_searching)
add_subdirectory(chapter_sorting)
add_subdirectory(chapter_divide_and_conquer)
add_subdirectory(chapter_backtracking)
add_subdirectory(chapter_dynamic_programming)
add_subdirectory(chapter_greedy)

4
ja/codes/cpp/chapter_array_and_linkedlist/CMakeLists.txt Normal file
View File

@@ -0,0 +1,4 @@
add_executable(array array.cpp)
add_executable(linked_list linked_list.cpp)
add_executable(list list.cpp)
add_executable(my_list my_list.cpp)

62
ja/codes/cpp/chapter_array_and_linkedlist/array.cpp
View File

@@ -6,57 +6,57 @@
#include "../utils/common.hpp"
/* 要素への乱数アクセス */
/* 要素へランダムアクセス */
int randomAccess(int *nums, int size) {
// [0, size)の範囲で乱数を選択
// 区間 [0, size) からランダムに 1 つの数を選ぶ
int randomIndex = rand() % size;
// 乱数要素を取得して返却
// ランダムな要素を取得して返す
int randomNum = nums[randomIndex];
return randomNum;
}
/* 配列長の拡張 */
/* 配列長を拡張する */
int *extend(int *nums, int size, int enlarge) {
// 拡張された長さの配列を初期化
// 拡張後の長さを持つ配列を初期化する
int *res = new int[size + enlarge];
// 元の配列の全要素を新しい配列にコピー
for (int i = 0; i < size; i++) {
res[i] = nums[i];
}
// メモリを解放
// メモリを解放する
delete[] nums;
// 拡張後の新しい配列を返却
// 拡張後の新しい配列を返す
return res;
}
/* `index`に要素numを挿入 */
/* 配列の index 番目に要素 num を挿入 */
void insert(int *nums, int size, int num, int index) {
// `index`より後のすべての要素を1つ後ろに移動
// インデックス index 以降の全要素を 1 つ後ろへ移動する
for (int i = size - 1; i > index; i--) {
nums[i] = nums[i - 1];
}
// indexの位置にnumを代入
// index の要素に num を代入する
nums[index] = num;
}
/* `index`の要素を削除 */
/* index の要素を削除する */
void remove(int *nums, int size, int index) {
// `index`より後のすべての要素を1つ前に移動
// インデックス index より後ろの全要素を 1 つ前へ移動する
for (int i = index; i < size - 1; i++) {
nums[i] = nums[i + 1];
}
}
/* 配列の走査 */
/* 配列を走査 */
void traverse(int *nums, int size) {
int count = 0;
// インデックスによる配列の走査
// インデックスで配列を走査
for (int i = 0; i < size; i++) {
count += nums[i];
}
}
/* 配列内の指定要素を検索 */
/* 配列内で指定要素を探す */
int find(int *nums, int size, int target) {
for (int i = 0; i < size; i++) {
if (nums[i] == target)
@@ -65,49 +65,49 @@ int find(int *nums, int size, int target) {
return -1;
}
/* ドライバーコード */
/* Driver Code */
int main() {
/* 配列を初期化 */
int size = 5;
int *arr = new int[size];
cout << "Array arr = ";
cout << "配列 arr = ";
printArray(arr, size);
int *nums = new int[size]{1, 3, 2, 5, 4};
cout << "Array nums = ";
cout << "配列 nums = ";
printArray(nums, size);
/* 乱数アクセス */
/* ランダムアクセス */
int randomNum = randomAccess(nums, size);
cout << "Get a random element from nums = " << randomNum << endl;
cout << "nums から取得したランダム要素 " << randomNum << endl;
/* 長さの拡張 */
/* 長さを拡張 */
int enlarge = 3;
nums = extend(nums, size, enlarge);
size += enlarge;
cout << "Extend the array length to 8, resulting in nums = ";
cout << "配列長を 8 に拡張し、nums = ";
printArray(nums, size);
/* 要素の挿入 */
/* 要素を挿入する */
insert(nums, size, 6, 3);
cout << "Insert the number 6 at index 3, resulting in nums = ";
cout << "インデックス 3 に数値 6 を挿入し、nums = ";
printArray(nums, size);
/* 要素の削除 */
/* 要素を削除 */
remove(nums, size, 2);
cout << "Remove the element at index 2, resulting in nums = ";
cout << "インデックス 2 の要素を削除し、nums = ";
printArray(nums, size);
/* 配列の走査 */
/* 配列を走査 */
traverse(nums, size);
/* 要素の検索 */
/* 要素を探索する */
int index = find(nums, size, 3);
cout << "Find element 3 in nums, index = " << index << endl;
cout << "nums 内で要素 3 を検索し、インデックス = " << index << endl;
// メモリを解放
// メモリを解放する
delete[] arr;
delete[] nums;
return 0;
}
}

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

@@ -6,14 +6,14 @@
#include "../utils/common.hpp"
/* 連結リストのノードn0の後にノードPを挿入 */
/* 連結リストでノード n0 の後ろにノード P を挿入する */
void insert(ListNode *n0, ListNode *P) {
ListNode *n1 = n0->next;
P->next = n1;
n0->next = P;
}
/* 連結リストのノードn0の後の最初のノードを削除 */
/* 連結リストでノード n0 の直後のノードを削除する */
void remove(ListNode *n0) {
if (n0->next == nullptr)
return;
@@ -21,11 +21,11 @@ void remove(ListNode *n0) {
ListNode *P = n0->next;
ListNode *n1 = P->next;
n0->next = n1;
// メモリを解放
// メモリを解放する
delete P;
}
/* 連結リストの`index`番目のノードにアクセス */
/* 連結リスト内で index 番目のノードにアクセス */
ListNode *access(ListNode *head, int index) {
for (int i = 0; i < index; i++) {
if (head == nullptr)
@@ -35,7 +35,7 @@ ListNode *access(ListNode *head, int index) {
return head;
}
/* 連結リストで値がtargetの最初のノードを検索 */
/* 連結リストで値が target の最初のノードを探す */
int find(ListNode *head, int target) {
int index = 0;
while (head != nullptr) {
@@ -47,7 +47,7 @@ int find(ListNode *head, int target) {
return -1;
}
/* ドライバーコード */
/* Driver Code */
int main() {
/* 連結リストを初期化 */
// 各ノードを初期化
@@ -56,34 +56,34 @@ int main() {
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;
cout << "The initialized linked list is" << endl;
cout << "初期化した連結リストは" << endl;
printLinkedList(n0);
/* ノードを挿入 */
insert(n0, new ListNode(0));
cout << "Linked list after inserting the node is" << endl;
cout << "ノード挿入後の連結リストは" << endl;
printLinkedList(n0);
/* ノードを削除 */
remove(n0);
cout << "Linked list after removing the node is" << endl;
cout << "ノード削除後の連結リストは" << endl;
printLinkedList(n0);
/* ノードにアクセス */
ListNode *node = access(n0, 3);
cout << "The value of the node at index 3 in the linked list = " << node->val << endl;
cout << "連結リストのインデックス 3 のノードの値 = " << node->val << endl;
/* ノードを検索 */
/* ノードを探索 */
int index = find(n0, 2);
cout << "The index of the node with value 2 in the linked list = " << index << endl;
cout << "連結リスト内で値が 2 のノードのインデックス = " << index << endl;
// メモリを解放
// メモリを解放する
freeMemoryLinkedList(n0);
return 0;
}
}

30
ja/codes/cpp/chapter_array_and_linkedlist/list.cpp
View File

@@ -6,25 +6,25 @@
#include "../utils/common.hpp"
/* ドライバーコード */
/* Driver Code */
int main() {
/* リストを初期化 */
vector<int> nums = {1, 3, 2, 5, 4};
cout << "List nums = ";
cout << "リスト nums = ";
printVector(nums);
/* 要素にアクセス */
int num = nums[1];
cout << "Access the element at index 1, obtained num = " << num << endl;
cout << "インデックス 1 の要素にアクセスすると、num = " << num << endl;
/* 要素を更新 */
nums[1] = 0;
cout << "Update the element at index 1 to 0, resulting in nums = ";
cout << "インデックス 1 の要素を 0 に更新すると、nums = ";
printVector(nums);
/* リストをクリア */
/* リストを空にする */
nums.clear();
cout << "After clearing the list, nums = ";
cout << "リストを空にした後の nums = ";
printVector(nums);
/* 末尾に要素を追加 */
@@ -33,40 +33,40 @@ int main() {
nums.push_back(2);
nums.push_back(5);
nums.push_back(4);
cout << "After adding elements, nums = ";
cout << "要素追加後の nums = ";
printVector(nums);
/* 中間に要素を挿入 */
nums.insert(nums.begin() + 3, 6);
cout << "Insert the number 6 at index 3, resulting in nums = ";
cout << "インデックス 3 に数値 6 を挿入し、nums = ";
printVector(nums);
/* 要素を削除 */
nums.erase(nums.begin() + 3);
cout << "Remove the element at index 3, resulting in nums = ";
cout << "インデックス 3 の要素を削除すると、nums = ";
printVector(nums);
/* インデックスによるリストの走査 */
/* インデックスでリストを走査 */
int count = 0;
for (int i = 0; i < nums.size(); i++) {
count += nums[i];
}
/* リスト要素の走査 */
/* リスト要素を直接走査 */
count = 0;
for (int x : nums) {
count += x;
}
/* 2つのリストを連結 */
/* 2 つのリストを連結する */
vector<int> nums1 = {6, 8, 7, 10, 9};
nums.insert(nums.end(), nums1.begin(), nums1.end());
cout << "Concatenate list nums1 to nums, resulting in nums = ";
cout << "リスト nums1 を nums の後ろに連結すると、nums = ";
printVector(nums);
/* リストをソート */
sort(nums.begin(), nums.end());
cout << "After sorting the list, nums = ";
cout << "リストをソートした後の nums = ";
printVector(nums);
return 0;
}
}

68
ja/codes/cpp/chapter_array_and_linkedlist/my_list.cpp
View File

@@ -10,9 +10,9 @@
class MyList {
private:
int *arr; // 配列（リスト要素を格納）
int arrCapacity = 10; // リストの容量
int arrCapacity = 10; // リスト容量
int arrSize = 0; // リストの長さ（現在の要素数）
int extendRatio = 2; // リスト拡張時の倍率
int extendRatio = 2; // リスト拡張時の増加倍率
public:
/* コンストラクタ */
@@ -20,39 +20,39 @@ class MyList {
arr = new int[arrCapacity];
}
/* デストラクタ */
/* デストラクタメソッド */
~MyList() {
delete[] arr;
}
/* リストの長さを取得（現在の要素数）*/
/* リストの長さを取得（現在の要素数） */
int size() {
return arrSize;
}
/* リストの容量を取得 */
/* リスト容量を取得する */
int capacity() {
return arrCapacity;
}
/* 要素にアクセス */
int get(int index) {
// インデックスが範囲外の場合、例外をスロー（以下同様）
// インデックスが範囲外なら例外を送出する。以下同様
if (index < 0 || index >= size())
throw out_of_range("Index out of bounds");
throw out_of_range("インデックスが範囲外");
return arr[index];
}
/* 要素を更新 */
void set(int index, int num) {
if (index < 0 || index >= size())
throw out_of_range("Index out of bounds");
throw out_of_range("インデックスが範囲外");
arr[index] = num;
}
/* 末尾に要素を追加 */
void add(int num) {
// 要素数が容量を超えた場合、拡張メカニズムをトリガー
// 要素数が容量を超えると、拡張機構が発動する
if (size() == capacity())
extendCapacity();
arr[size()] = num;
@@ -63,11 +63,11 @@ class MyList {
/* 中間に要素を挿入 */
void insert(int index, int num) {
if (index < 0 || index >= size())
throw out_of_range("Index out of bounds");
// 要素数が容量を超えた場合、拡張メカニズムをトリガー
throw out_of_range("インデックスが範囲外");
// 要素数が容量を超えると、拡張機構が発動する
if (size() == capacity())
extendCapacity();
// `index`より後のすべての要素を1つ後ろに移動
// index 以降の要素をすべて 1 つ後ろへずらす
for (int j = size() - 1; j >= index; j--) {
arr[j + 1] = arr[j];
}
@@ -79,36 +79,36 @@ class MyList {
/* 要素を削除 */
int remove(int index) {
if (index < 0 || index >= size())
throw out_of_range("Index out of bounds");
throw out_of_range("インデックスが範囲外");
int num = arr[index];
// `index`より後のすべての要素を1つ前に移動
// インデックス index より後の要素をすべて 1 つ前に移動する
for (int j = index; j < size() - 1; j++) {
arr[j] = arr[j + 1];
}
// 要素数を更新
arrSize--;
// 削除された要素を返却
// 削除された要素を返す
return num;
}
/* リストを拡張 */
/* リストの拡張 */
void extendCapacity() {
// 元の配列のextendRatio倍の長さで新しい配列を作成
// 元の配列の `extendRatio` 倍の長さを持つ新しい配列を作成する
int newCapacity = capacity() * extendRatio;
int *tmp = arr;
arr = new int[newCapacity];
// 元の配列のすべての要素を新しい配列にコピー
// 元の配列の全要素を新しい配列にコピー
for (int i = 0; i < size(); i++) {
arr[i] = tmp[i];
}
// メモリを解放
// メモリを解放する
delete[] tmp;
arrCapacity = newCapacity;
}
/* リストをVectorに変換して印刷用に使用 */
/* 出力用にリストを Vector に変換 */
vector<int> toVector() {
// 有効な長さ範囲内の要素のみを変換
// 有効長の範囲内のリスト要素のみを変換
vector<int> vec(size());
for (int i = 0; i < size(); i++) {
vec[i] = arr[i];
@@ -117,7 +117,7 @@ class MyList {
}
};
/* ドライバーコード */
/* Driver Code */
int main() {
/* リストを初期化 */
MyList *nums = new MyList();
@@ -127,45 +127,45 @@ int main() {
nums->add(2);
nums->add(5);
nums->add(4);
cout << "List nums = ";
cout << "リスト nums = ";
vector<int> vec = nums->toVector();
printVector(vec);
cout << "Capacity = " << nums->capacity() << ", length = " << nums->size() << endl;
cout << "容量 = " << nums->capacity() << " ，長さ = " << nums->size() << endl;
/* 中間に要素を挿入 */
nums->insert(3, 6);
cout << "Insert the number 6 at index 3, resulting in nums = ";
cout << "インデックス 3 に数値 6 を挿入し、nums = ";
vec = nums->toVector();
printVector(vec);
/* 要素を削除 */
nums->remove(3);
cout << "Remove the element at index 3, resulting in nums = ";
cout << "インデックス 3 の要素を削除すると、nums = ";
vec = nums->toVector();
printVector(vec);
/* 要素にアクセス */
int num = nums->get(1);
cout << "Access the element at index 1, obtained num = " << num << endl;
cout << "インデックス 1 の要素にアクセスすると、num = " << num << endl;
/* 要素を更新 */
nums->set(1, 0);
cout << "Update the element at index 1 to 0, resulting in nums = ";
cout << "インデックス 1 の要素を 0 に更新すると、nums = ";
vec = nums->toVector();
printVector(vec);
/* 拡張メカニズムをテスト */
/* 拡張機構をテストする */
for (int i = 0; i < 10; i++) {
// i = 5の時、リストの長さがリストの容量を超え、この時点で拡張メカニズムがトリガーされる
// i = 5 のとき、リスト長が容量を超えるため、この時点で拡張機構が発動する
nums->add(i);
}
cout << "After extending, list nums = ";
cout << "拡張後のリスト nums = ";
vec = nums->toVector();
printVector(vec);
cout << "Capacity = " << nums->capacity() << ", length = " << nums->size() << endl;
cout << "容量 = " << nums->capacity() << " ，長さ = " << nums->size() << endl;
// メモリを解放
// メモリを解放する
delete nums;
return 0;
}
}

10
ja/codes/cpp/chapter_backtracking/CMakeLists.txt Normal file
View File

@@ -0,0 +1,10 @@
add_executable(preorder_traversal_i_compact preorder_traversal_i_compact.cpp)
add_executable(preorder_traversal_ii_compact preorder_traversal_ii_compact.cpp)
add_executable(preorder_traversal_iii_compact preorder_traversal_iii_compact.cpp)
add_executable(preorder_traversal_iii_template preorder_traversal_iii_template.cpp)
add_executable(permutations_i permutations_i.cpp)
add_executable(permutations_ii permutations_ii.cpp)
add_executable(n_queens n_queens.cpp)
add_executable(subset_sum_i_naive subset_sum_i_naive.cpp)
add_executable(subset_sum_i subset_sum_i.cpp)
add_executable(subset_sum_ii subset_sum_ii.cpp)

32
ja/codes/cpp/chapter_backtracking/n_queens.cpp
View File

@@ -6,40 +6,40 @@
#include "../utils/common.hpp"
/* バックトラッキングアルゴリズム：n クイーン */
/* バックトラッキング：N クイーン */
void backtrack(int row, int n, vector<vector<string>> &state, vector<vector<vector<string>>> &res, vector<bool> &cols,
vector<bool> &diags1, vector<bool> &diags2) {
// すべての行が配置されたら、解を記録
// すべての行への配置が完了したら、解を記録する
if (row == n) {
res.push_back(state);
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[row][col] = "Q";
cols[col] = diags1[diag1] = diags2[diag2] = true;
// 次の行を配置
// 次の行に配置する
backtrack(row + 1, n, state, res, cols, diags1, diags2);
// 回退：セルを空のスポットに復元
// 戻す：そのマスを空きマスに戻す
state[row][col] = "#";
cols[col] = diags1[diag1] = diags2[diag2] = false;
}
}
}
/* n クイーンを解く */
/* N クイーンを解く */
vector<vector<vector<string>>> nQueens(int n) {
// n*n サイズのチェスボードを初期化、'Q' はクイーンを表し、'#' は空のスポットを表す
// n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す
vector<vector<string>> state(n, vector<string>(n, "#"));
vector<bool> cols(n, false); // クイーンのある列を記録
vector<bool> diags1(2 * n - 1, false); // クイーンのある主対角線を記録
vector<bool> diags2(2 * n - 1, false); // クイーンのある副対角線を記録
vector<bool> cols(n, false); // 列にクイーンがあるか記録
vector<bool> diags1(2 * n - 1, false); // 主対角線にクイーンがあるかを記録
vector<bool> diags2(2 * n - 1, false); // 副対角線にクイーンがあるかを記録
vector<vector<vector<string>>> res;
backtrack(0, n, state, res, cols, diags1, diags2);
@@ -47,13 +47,13 @@ vector<vector<vector<string>>> nQueens(int n) {
return res;
}
/* ドライバーコード */
/* Driver Code */
int main() {
int n = 4;
vector<vector<vector<string>>> res = nQueens(n);
cout << "チェスボードの次元を " << n << " として入力" << endl;
cout << "クイーン配置解の総数 = " << res.size() << endl;
cout << "入力した盤面の縦横は " << n << endl;
cout << "クイーンの配置方法は全部で " << res.size() << " 通り" << endl;
for (const vector<vector<string>> &state : res) {
cout << "--------------------" << endl;
for (const vector<string> &row : state) {
@@ -62,4 +62,4 @@ int main() {
}
return 0;
}
}

18
ja/codes/cpp/chapter_backtracking/permutations_i.cpp
View File

@@ -6,9 +6,9 @@
#include "../utils/common.hpp"
/* バックトラッキングアルゴリズム：順列 I */
/* バックトラッキング：順列 I */
void backtrack(vector<int> &state, const vector<int> &choices, vector<bool> &selected, vector<vector<int>> &res) {
// 状態の長さが要素数と等しくなったら、解を記録
// 状態の長さが要素数に等しければ、解を記録
if (state.size() == choices.size()) {
res.push_back(state);
return;
@@ -16,21 +16,21 @@ void backtrack(vector<int> &state, const vector<int> &choices, vector<bool> &sel
// すべての選択肢を走査
for (int i = 0; i < choices.size(); i++) {
int choice = choices[i];
// 剪定：要素の重複選択を許可しない
// 枝刈り：要素の重複選択を許可しない
if (!selected[i]) {
// 試行：選択を行い、状態を更新
// 試行: 選択を行い、状態を更新
selected[i] = true;
state.push_back(choice);
// 次のラウンドの選択に進む
// 次の選択へ進む
backtrack(state, choices, selected, res);
// 回退：選択を取り消し、前の状態に復元
// バックトラック：選択を取り消し、前の状態に戻す
selected[i] = false;
state.pop_back();
}
}
}
/* 順列 I */
/* 全順列 I */
vector<vector<int>> permutationsI(vector<int> nums) {
vector<int> state;
vector<bool> selected(nums.size(), false);
@@ -39,7 +39,7 @@ vector<vector<int>> permutationsI(vector<int> nums) {
return res;
}
/* ドライバーコード */
/* Driver Code */
int main() {
vector<int> nums = {1, 2, 3};
@@ -51,4 +51,4 @@ int main() {
printVectorMatrix(res);
return 0;
}
}

20
ja/codes/cpp/chapter_backtracking/permutations_ii.cpp
View File

@@ -6,9 +6,9 @@
#include "../utils/common.hpp"
/* バックトラッキングアルゴリズム：順列 II */
/* バックトラッキング：順列 II */
void backtrack(vector<int> &state, const vector<int> &choices, vector<bool> &selected, vector<vector<int>> &res) {
// 状態の長さが要素数と等しくなったら、解を記録
// 状態の長さが要素数に等しければ、解を記録
if (state.size() == choices.size()) {
res.push_back(state);
return;
@@ -17,22 +17,22 @@ void backtrack(vector<int> &state, const vector<int> &choices, vector<bool> &sel
unordered_set<int> duplicated;
for (int i = 0; i < choices.size(); i++) {
int choice = choices[i];
// 剪定：要素の重複選択を許可せず、等しい要素の重複選択も許可しない
// 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない
if (!selected[i] && duplicated.find(choice) == duplicated.end()) {
// 試行：選択を行い、状態を更新
duplicated.emplace(choice); // 選択された要素値を記録
// 試行: 選択を行い、状態を更新
duplicated.emplace(choice); // 選択済みの要素値を記録
selected[i] = true;
state.push_back(choice);
// 次のラウンドの選択に進む
// 次の選択へ進む
backtrack(state, choices, selected, res);
// 回退：選択を取り消し、前の状態に復元
// バックトラック：選択を取り消し、前の状態に戻す
selected[i] = false;
state.pop_back();
}
}
}
/* 順列 II */
/* 全順列 II */
vector<vector<int>> permutationsII(vector<int> nums) {
vector<int> state;
vector<bool> selected(nums.size(), false);
@@ -41,7 +41,7 @@ vector<vector<int>> permutationsII(vector<int> nums) {
return res;
}
/* ドライバーコード */
/* Driver Code */
int main() {
vector<int> nums = {1, 1, 2};
@@ -53,4 +53,4 @@ int main() {
printVectorMatrix(res);
return 0;
}
}

16
ja/codes/cpp/chapter_backtracking/preorder_traversal_i_compact.cpp
View File

@@ -8,7 +8,7 @@
vector<TreeNode *> res;
/* 前順走査：例１ */
/* 前順走査：例題 1 */
void preOrder(TreeNode *root) {
if (root == nullptr) {
return;
@@ -21,23 +21,19 @@ void preOrder(TreeNode *root) {
preOrder(root->right);
}
/* ドライバーコード */
/* Driver Code */
int main() {
vector<int> arr = {1, 7, 3, 4, 5, 6, 7};
TreeNode *root = vecToTree(arr);
TreeNode *root = vectorToTree(vector<int>{1, 7, 3, 4, 5, 6, 7});
cout << "\n二分木を初期化" << endl;
printTree(root);
// 前順走査
res.clear();
// 先行順走査
preOrder(root);
cout << "\n値7のノードをすべて出力" << endl;
cout << "\n値が 7 のすべてのノードを出力" << endl;
vector<int> vals;
for (TreeNode *node : res) {
vals.push_back(node->val);
}
printVector(vals);
return 0;
}
}

21
ja/codes/cpp/chapter_backtracking/preorder_traversal_ii_compact.cpp
View File

@@ -9,12 +9,12 @@
vector<TreeNode *> path;
vector<vector<TreeNode *>> res;
/* 前順走査：例２ */
/* 前順走査：例題 2 */
void preOrder(TreeNode *root) {
if (root == nullptr) {
return;
}
// 試行
// 試す
path.push_back(root);
if (root->val == 7) {
// 解を記録
@@ -22,23 +22,20 @@ void preOrder(TreeNode *root) {
}
preOrder(root->left);
preOrder(root->right);
// 回退
// バックトラック
path.pop_back();
}
/* ドライバーコード */
/* Driver Code */
int main() {
vector<int> arr = {1, 7, 3, 4, 5, 6, 7};
TreeNode *root = vecToTree(arr);
TreeNode *root = vectorToTree(vector<int>{1, 7, 3, 4, 5, 6, 7});
cout << "\n二分木を初期化" << endl;
printTree(root);
// 前順走査
path.clear();
res.clear();
// 先行順走査
preOrder(root);
cout << "\nルートからノード7までのすべてのパスを出力" << endl;
cout << "\n根ノードからノード 7 までのすべての経路を出力" << endl;
for (vector<TreeNode *> &path : res) {
vector<int> vals;
for (TreeNode *node : path) {
@@ -46,6 +43,4 @@ int main() {
}
printVector(vals);
}
return 0;
}
}

23
ja/codes/cpp/chapter_backtracking/preorder_traversal_iii_compact.cpp
View File

@@ -9,13 +9,13 @@
vector<TreeNode *> path;
vector<vector<TreeNode *>> res;
/* 前順走査：例３ */
/* 前順走査：例題 3 */
void preOrder(TreeNode *root) {
// 剪定
// 枝刈り
if (root == nullptr || root->val == 3) {
return;
}
// 試行
// 試す
path.push_back(root);
if (root->val == 7) {
// 解を記録
@@ -23,23 +23,20 @@ void preOrder(TreeNode *root) {
}
preOrder(root->left);
preOrder(root->right);
// 回退
// バックトラック
path.pop_back();
}
/* ドライバーコード */
/* Driver Code */
int main() {
vector<int> arr = {1, 7, 3, 4, 5, 6, 7};
TreeNode *root = vecToTree(arr);
TreeNode *root = vectorToTree(vector<int>{1, 7, 3, 4, 5, 6, 7});
cout << "\n二分木を初期化" << endl;
printTree(root);
// 前順走査
path.clear();
res.clear();
// 先行順走査
preOrder(root);
cout << "\nルートからノード7までのすべてのパスを出力、値3のノードは含まない" << endl;
cout << "\n根ノードからノード 7 までのすべての経路を出力し、経路に値 3 のノードを含めない" << endl;
for (vector<TreeNode *> &path : res) {
vector<int> vals;
for (TreeNode *node : path) {
@@ -47,6 +44,4 @@ int main() {
}
printVector(vals);
}
return 0;
}
}

29
ja/codes/cpp/chapter_backtracking/preorder_traversal_iii_template.cpp
View File

@@ -16,7 +16,7 @@ void recordSolution(vector<TreeNode *> &state, vector<vector<TreeNode *>> &res)
res.push_back(state);
}
/* 現在の状態下で選択が合法かどうかを判定 */
/* 現在の状態で、この選択が有効かどうかを判定 */
bool isValid(vector<TreeNode *> &state, TreeNode *choice) {
return choice != nullptr && choice->val != 3;
}
@@ -26,47 +26,46 @@ void makeChoice(vector<TreeNode *> &state, TreeNode *choice) {
state.push_back(choice);
}
/* 状態を復元 */
/* 状態を元に戻す */
void undoChoice(vector<TreeNode *> &state, TreeNode *choice) {
state.pop_back();
}
/* バックトラッキングアルゴリズム：例３ */
/* バックトラッキング：例題 3 */
void backtrack(vector<TreeNode *> &state, vector<TreeNode *> &choices, vector<vector<TreeNode *>> &res) {
// 解かどうかをチェック
// 解かどうかを確認
if (isSolution(state)) {
// 解を記録
recordSolution(state, res);
}
// すべての選択肢を走査
for (TreeNode *choice : choices) {
// 剪定：選択が合法かどうかをチェック
// 枝刈り：選択が妥当かを確認する
if (isValid(state, choice)) {
// 試行：選択を行い、状態を更新
// 試行: 選択を行い、状態を更新
makeChoice(state, choice);
// 次のラウンドの選択に進む
// 次の選択へ進む
vector<TreeNode *> nextChoices{choice->left, choice->right};
backtrack(state, nextChoices, res);
// 回退：選択を取り消し、前の状態に復元
// バックトラック：選択を取り消し、前の状態に戻す
undoChoice(state, choice);
}
}
}
/* ドライバーコード */
/* Driver Code */
int main() {
vector<int> arr = {1, 7, 3, 4, 5, 6, 7};
TreeNode *root = vecToTree(arr);
TreeNode *root = vectorToTree(vector<int>{1, 7, 3, 4, 5, 6, 7});
cout << "\n二分木を初期化" << endl;
printTree(root);
// バックトラッキングアルゴリズム
// バックトラッキング法
vector<TreeNode *> state;
vector<TreeNode *> choices = {root};
vector<vector<TreeNode *>> res;
backtrack(state, choices, res);
cout << "\nルートからノード7までのすべてのパスを出力、パスには値3のノードを含まないことが要求される" << endl;
cout << "\n根ノードからノード 7 までのすべての経路を出力し、経路に値 3 のノードを含めない" << endl;
for (vector<TreeNode *> &path : res) {
vector<int> vals;
for (TreeNode *node : path) {
@@ -74,6 +73,4 @@ int main() {
}
printVector(vals);
}
return 0;
}
}

30
ja/codes/cpp/chapter_backtracking/subset_sum_i.cpp
View File

@@ -6,41 +6,41 @@
#include "../utils/common.hpp"
/* バックトラッキングアルゴリズム：部分集合和 I */
/* バックトラッキング：部分和 I */
void backtrack(vector<int> &state, int target, vector<int> &choices, int start, vector<vector<int>> &res) {
// 部分集合の和がtargetと等しいとき、解を記録
// 部分集合の和が target に等しければ、解を記録
if (target == 0) {
res.push_back(state);
return;
}
// すべての選択肢を走査
// 剪定二：startから走査を開始し、重複する部分集合の生成を回避
// 枝刈り 2: start から走査し、重複する部分集合の生成を避ける
for (int i = start; i < choices.size(); i++) {
// 剪定一：部分集合の和がtargetを超えた場合、即座にループを終了
// 配列がソートされているため、後の要素はさらに大きく、部分集合の和は必ずtargetを超える
// 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する
// 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため
if (target - choices[i] < 0) {
break;
}
// 試行：選択を行い、target、startを更新
// 試す：選択を行い、target と start を更新
state.push_back(choices[i]);
// 次のラウンドの選択に進む
// 次の選択へ進む
backtrack(state, target - choices[i], choices, i, res);
// 回退：選択を取り消し、前の状態に復元
// バックトラック：選択を取り消し、前の状態に戻す
state.pop_back();
}
}
/* 部分集合和 I を解く */
vector<vector<int>> subsetSumI(vector<int> nums, int target) {
/* 部分和 I を解く */
vector<vector<int>> subsetSumI(vector<int> &nums, int target) {
vector<int> state; // 状態（部分集合）
sort(nums.begin(), nums.end()); // nums をソート
int start = 0; // 走査の開始点
vector<vector<int>> res; // 結果リスト（部分集合リスト）
int start = 0; // 開始点を走査
vector<vector<int>> res; // 結果リスト（部分集合のリスト）
backtrack(state, target, nums, start, res);
return res;
}
/* ドライバーコード */
/* Driver Code */
int main() {
vector<int> nums = {3, 4, 5};
int target = 9;
@@ -50,8 +50,8 @@ int main() {
cout << "入力配列 nums = ";
printVector(nums);
cout << "target = " << target << endl;
cout << "和が " << target << " のすべての部分集合 res = " << endl;
cout << "合計が " << target << " に等しいすべての部分集合 res = " << endl;
printVectorMatrix(res);
return 0;
}
}

29
ja/codes/cpp/chapter_backtracking/subset_sum_i_naive.cpp
View File

@@ -6,38 +6,38 @@
#include "../utils/common.hpp"
/* バックトラッキングアルゴリズム：部分集合和 I */
/* バックトラッキング：部分和 I */
void backtrack(vector<int> &state, int target, int total, vector<int> &choices, vector<vector<int>> &res) {
// 部分集合の和がtargetと等しいとき、解を記録
// 部分集合の和が target に等しければ、解を記録
if (total == target) {
res.push_back(state);
return;
}
// すべての選択肢を走査
for (int i = 0; i < choices.size(); i++) {
// 剪定：部分集合の和がtargetを超えた場合、その選択をスキップ
for (size_t i = 0; i < choices.size(); i++) {
// 枝刈り：部分和が target を超える場合はその選択をスキップする
if (total + choices[i] > target) {
continue;
}
// 試行：選択を行い、要素とtotalを更新
// 試行：選択を行い、要素と total を更新する
state.push_back(choices[i]);
// 次のラウンドの選択に進む
// 次の選択へ進む
backtrack(state, target, total + choices[i], choices, res);
// 回退：選択を取り消し、前の状態に復元
// バックトラック：選択を取り消し、前の状態に戻す
state.pop_back();
}
}
/* 部分集合和 I を解く（重複する部分集合を含む） */
vector<vector<int>> subsetSumINaive(vector<int> nums, int target) {
/* 部分和 I を解く（重複部分集合を含む） */
vector<vector<int>> subsetSumINaive(vector<int> &nums, int target) {
vector<int> state; // 状態（部分集合）
int total = 0; // 部分集合の和
vector<vector<int>> res; // 結果リスト（部分集合リスト）
int total = 0; // 部分和
vector<vector<int>> res; // 結果リスト（部分集合のリスト）
backtrack(state, target, total, nums, res);
return res;
}
/* ドライバーコード */
/* Driver Code */
int main() {
vector<int> nums = {3, 4, 5};
int target = 9;
@@ -47,9 +47,8 @@ int main() {
cout << "入力配列 nums = ";
printVector(nums);
cout << "target = " << target << endl;
cout << "和が " << target << " のすべての部分集合 res = " << endl;
cout << "合計が " << target << " に等しいすべての部分集合 res = " << endl;
printVectorMatrix(res);
cout << "この方法の結果には重複する集合が含まれています" << endl;
return 0;
}
}

34
ja/codes/cpp/chapter_backtracking/subset_sum_ii.cpp
View File

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

5
ja/codes/cpp/chapter_computational_complexity/CMakeLists.txt Normal file
View File

@@ -0,0 +1,5 @@
add_executable(iteration iteration.cpp)
add_executable(recursion recursion.cpp)
add_executable(space_complexity space_complexity.cpp)
add_executable(time_complexity time_complexity.cpp)
add_executable(worst_best_time_complexity worst_best_time_complexity.cpp)

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

@@ -9,7 +9,7 @@
/* for ループ */
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;
}
@@ -19,35 +19,35 @@ int forLoop(int n) {
/* while ループ */
int whileLoop(int n) {
int res = 0;
int i = 1; // 条件変数を初期化
// 1, 2, ..., n-1, n の合計をループ計算
int i = 1; // 条件変数を初期化する
// 1, 2, ..., n-1, n を順に加算する
while (i <= n) {
res += i;
i++; // 条件変数を更新
i++; // 条件変数を更新する
}
return res;
}
/* while ループ（2つの更新） */
/* while ループ（2回更新） */
int whileLoopII(int n) {
int res = 0;
int i = 1; // 条件変数を初期化
// 1, 4, 10, ... の合計をループ計算
int i = 1; // 条件変数を初期化する
// 1, 4, 10, ... を順に加算する
while (i <= n) {
res += i;
// 条件変数を更新
// 条件変数を更新する
i++;
i *= 2;
}
return res;
}
/* 2重 for ループ */
/* 二重 for ループ */
string nestedForLoop(int n) {
ostringstream res;
// ループ 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 << "(" << i << ", " << j << "), ";
}
@@ -55,7 +55,7 @@ string nestedForLoop(int n) {
return res.str();
}
/* ドライバーコード */
/* Driver Code */
int main() {
int n = 5;
int res;
@@ -67,10 +67,10 @@ int main() {
cout << "\nwhile ループの合計結果 res = " << res << endl;
res = whileLoopII(n);
cout << "\nwhile ループ（2つの更新）の合計結果 res = " << res << endl;
cout << "\nwhile ループ（2 回更新）の合計結果 res = " << res << endl;
string resStr = nestedForLoop(n);
cout << "\n2重 for ループ走査の結果 = " << resStr << endl;
cout << "\n二重 for ループの走査結果 " << resStr << endl;
return 0;
}
}

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

@@ -13,23 +13,23 @@ int recur(int n) {
return 1;
// 再帰：再帰呼び出し
int res = recur(n - 1);
// 戻り値：結果を返す
// 帰りがけ：結果を返す
return n + res;
}
/* 反復で再帰をシミュレート */
/* 反復で再帰を模擬する */
int forLoopRecur(int n) {
// 明示的なスタックを使用してシステムコールスタックをシミュレート
// 明示的なスタックを使ってシステムコールスタックを模擬する
stack<int> stack;
int res = 0;
// 再帰：再帰呼び出し
for (int i = n; i > 0; i--) {
// 「スタックへのプッシュ」で「再帰」をシミュレート
// 「スタックへのプッシュ」で「再帰」を模擬する
stack.push(i);
}
// 戻り値：結果を返す
// 帰りがけ：結果を返す
while (!stack.empty()) {
// 「スタックからのポップ」で「戻り値」をシミュレート
// 「スタックから取り出す操作」で「帰り」をシミュレート
res += stack.top();
stack.pop();
}
@@ -51,13 +51,13 @@ int fib(int n) {
// 終了条件 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 */
int main() {
int n = 5;
int res;
@@ -66,13 +66,13 @@ int main() {
cout << "\n再帰関数の合計結果 res = " << res << endl;
res = forLoopRecur(n);
cout << "\n反復を使用して再帰をシミュレートした合計結果 res = " << res << endl;
cout << "\n反復で再帰をシミュレートした合計結果 res = " << res << endl;
res = tailRecur(n, 0);
cout << "\n末尾再帰関数の合計結果 res = " << res << endl;
res = fib(n);
cout << "フィボナッチ数列の第 " << n << " 番目の数は " << res << endl;
cout << "\nフィボナッチ数列の第 " << n << " 項は " << res << endl;
return 0;
}
}

44
ja/codes/cpp/chapter_computational_complexity/space_complexity.cpp
View File

@@ -8,44 +8,44 @@
/* 関数 */
int func() {
// 何らかの操作を実行
// 何らかの処理を行う
return 0;
}
/* 定数計算量 */
/* 定数階 */
void constant(int n) {
// 定数、変数、オブジェクトは O(1) 空間を占める
// 定数、変数、オブジェクトは O(1) の空間を占める
const int a = 0;
int b = 0;
vector<int> nums(10000);
ListNode node(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++) {
func();
}
}
/* 線形計算量 */
/* 線形階 */
void linear(int n) {
// 長さ n の配列は O(n) 空間を占める
// 長さ n の配列は O(n) の空間を使用
vector<int> nums(n);
// 長さ n のリストは O(n) 空間を占める
// 長さ n のリストは O(n) の空間を使用
vector<ListNode> nodes;
for (int i = 0; i < n; i++) {
nodes.push_back(ListNode(i));
}
// 長さ n のハッシュテーブルは O(n) 空間を占める
// 長さ n のハッシュテーブルは O(n) の空間を使用
unordered_map<int, string> map;
for (int i = 0; i < n; i++) {
map[i] = to_string(i);
}
}
/* 線形計算量（再帰実装） */
/* 線形時間（再帰実装） */
void linearRecur(int n) {
cout << "再帰 n = " << n << endl;
if (n == 1)
@@ -53,9 +53,9 @@ void linearRecur(int n) {
linearRecur(n - 1);
}
/* 二次計算量 */
/* 二乗階 */
void quadratic(int n) {
// 二次元リストは O(n^2) 空間を占める
// 二次元リストは O(n^2) の空間を使用
vector<vector<int>> numMatrix;
for (int i = 0; i < n; i++) {
vector<int> tmp;
@@ -66,16 +66,16 @@ void quadratic(int n) {
}
}
/* 二次計算量（再帰実装） */
/* 二次時間（再帰実装） */
int quadraticRecur(int n) {
if (n <= 0)
return 0;
vector<int> nums(n);
cout << "再帰 n = " << n << ", nums の長さ = " << nums.size() << endl;
cout << "再帰 n = " << n << " における nums の長さ = " << nums.size() << endl;
return quadraticRecur(n - 1);
}
/* 指数計算量（完全二分木の構築） */
/* 指数時間（完全二分木の構築） */
TreeNode *buildTree(int n) {
if (n == 0)
return nullptr;
@@ -85,23 +85,23 @@ TreeNode *buildTree(int n) {
return root;
}
/* ドライバーコード */
/* Driver Code */
int main() {
int n = 5;
// 定数計算量
// 定数階
constant(n);
// 線形計算量
// 線形階
linear(n);
linearRecur(n);
// 二次計算量
// 二乗階
quadratic(n);
quadraticRecur(n);
// 指数計算量
// 指数オーダー
TreeNode *root = buildTree(n);
printTree(root);
// メモリを解放
// メモリを解放する
freeMemoryTree(root);
return 0;
}
}

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

@@ -6,7 +6,7 @@
#include "../utils/common.hpp"
/* 定数計算量 */
/* 定数階 */
int constant(int n) {
int count = 0;
int size = 100000;
@@ -15,7 +15,7 @@ int constant(int n) {
return count;
}
/* 線形計算量 */
/* 線形階 */
int linear(int n) {
int count = 0;
for (int i = 0; i < n; i++)
@@ -23,20 +23,20 @@ int linear(int n) {
return count;
}
/* 線形計算量（配列の走査） */
/* 線形時間（配列を走査） */
int arrayTraversal(vector<int> &nums) {
int count = 0;
// ループ回数は配列の長さに比例
// ループ回数は配列長に比例する
for (int num : nums) {
count++;
}
return count;
}
/* 二次計算量 */
/* 二乗階 */
int quadratic(int n) {
int count = 0;
// ループ回数はデータサイズ n の二乗に比例
// ループ回数はデータサイズ n の二乗に比例する
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
count++;
@@ -45,29 +45,29 @@ int quadratic(int n) {
return count;
}
/* 二次計算量（バブルソート） */
/* 二次時間（バブルソート） */
int bubbleSort(vector<int> &nums) {
int count = 0; // カウンター
// 外側ループ：未ソート範囲は [0, i]
int count = 0; // カウンタ
// 外側のループ：未ソート区間は [0, i]
for (int i = nums.size() - 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;
}
/* 指数計算量（ループ実装） */
/* 指数時間（ループ実装） */
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++;
@@ -78,14 +78,14 @@ int exponential(int n) {
return count;
}
/* 指数計算量（再帰実装） */
/* 指数時間（再帰実装） */
int expRecur(int n) {
if (n == 1)
return 1;
return expRecur(n - 1) + expRecur(n - 1) + 1;
}
/* 対数計算量（ループ実装） */
/* 対数時間（ループ実装） */
int logarithmic(int n) {
int count = 0;
while (n > 1) {
@@ -95,14 +95,14 @@ int logarithmic(int n) {
return count;
}
/* 対数計算量（再帰実装） */
/* 対数時間（再帰実装） */
int logRecur(int n) {
if (n <= 1)
return 0;
return logRecur(n / 2) + 1;
}
/* 線形対数計算量 */
/* 線形対数時間 */
int linearLogRecur(int n) {
if (n <= 1)
return 1;
@@ -113,56 +113,56 @@ int linearLogRecur(int n) {
return count;
}
/* 階乗計算量（再帰実装） */
/* 階乗時間（再帰実装） */
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 */
int main() {
// n を変更して、さまざまな計算量での操作回数の変化傾向を体験可能
// n を変えて実行し、各計算量で操作回数がどう変化するかを確認できる
int n = 8;
cout << "入力データサイズ n = " << n << endl;
int count = constant(n);
cout << "定数計算量の操作回数 = " << count << endl;
cout << "定数オーダーの操作回数 = " << count << endl;
count = linear(n);
cout << "線形計算量の操作回数 = " << count << endl;
cout << "線形オーダーの操作回数 = " << count << endl;
vector<int> arr(n);
count = arrayTraversal(arr);
cout << "線形計算量の操作回数（配列走査） = " << count << endl;
cout << "線形オーダー（配列走査）の操作回数 = " << count << endl;
count = quadratic(n);
cout << "二次計算量の操作回数 = " << count << endl;
cout << "二乗オーダーの操作回数 = " << count << endl;
vector<int> nums(n);
for (int i = 0; i < n; i++)
nums[i] = n - i; // [n,n-1,...,2,1]
count = bubbleSort(nums);
cout << "二次計算量の操作回数（バブルソート） = " << count << endl;
cout << "二乗オーダー（バブルソート）の操作回数 = " << count << endl;
count = exponential(n);
cout << "指数計算量の操作回数（ループ実装） = " << count << endl;
cout << "指数オーダー（ループ実装）の操作回数 = " << count << endl;
count = expRecur(n);
cout << "指数計算量の操作回数（再帰実装） = " << count << endl;
cout << "指数オーダー（再帰実装）の操作回数 = " << count << endl;
count = logarithmic(n);
cout << "対数計算量の操作回数（ループ実装） = " << count << endl;
cout << "対数オーダー（ループ実装）の操作回数 = " << count << endl;
count = logRecur(n);
cout << "対数計算量の操作回数（再帰実装） = " << count << endl;
cout << "対数オーダー（再帰実装）の操作回数 = " << count << endl;
count = linearLogRecur(n);
cout << "線形対数計算量の操作回数（再帰実装） = " << count << endl;
cout << "線形対数オーダー（再帰実装）の操作回数 = " << count << endl;
count = factorialRecur(n);
cout << "階乗計算量の操作回数（再帰実装） = " << count << endl;
cout << "階乗オーダー（再帰実装）の操作回数 = " << count << endl;
return 0;
}
}

18
ja/codes/cpp/chapter_computational_complexity/worst_best_time_complexity.cpp
View File

@@ -6,40 +6,40 @@
#include "../utils/common.hpp"
/* 要素 {1, 2, ..., n} をランダムにシャッフルした配列を生成 */
/* 要素が { 1, 2, ..., n } で、順序がシャッフルされた配列を生成 */
vector<int> randomNumbers(int n) {
vector<int> nums(n);
// 配列 nums = { 1, 2, 3, ..., n } を生成
for (int i = 0; i < n; i++) {
nums[i] = i + 1;
}
// システム時刻を使用してランダムシードを生成
// システム時刻を使って乱数シードを生成する
unsigned seed = chrono::system_clock::now().time_since_epoch().count();
// 配列要素をランダムにシャッフル
shuffle(nums.begin(), nums.end(), default_random_engine(seed));
return nums;
}
/* 配列 nums で数値1のインデックスを見つける */
/* 配列 nums 内で数値 1 のインデックスを探す */
int findOne(vector<int> &nums) {
for (int i = 0; i < nums.size(); i++) {
// 要素1が配列の先頭にある場合、最良時間計算量 O(1) を達成
// 要素1が配列の末尾にある場合、最悪時間計算量 O(n) を達成
// 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる
// 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる
if (nums[i] == 1)
return i;
}
return -1;
}
/* ドライバーコード */
/* Driver Code */
int main() {
for (int i = 0; i < 1000; i++) {
int n = 100;
vector<int> nums = randomNumbers(n);
int index = findOne(nums);
cout << "\n配列 [ 1, 2, ..., n ] をシャッフル後 = ";
cout << "\n配列 [ 1, 2, ..., n ] をシャッフルした後 = ";
printVector(nums);
cout << "数値1のインデックスは " << index << endl;
cout << "数字 1 のインデックスは " << index << endl;
}
return 0;
}
}

3
ja/codes/cpp/chapter_divide_and_conquer/CMakeLists.txt Normal file
View File

@@ -0,0 +1,3 @@
add_executable(binary_search_recur binary_search_recur.cpp)
add_executable(build_tree build_tree.cpp)
add_executable(hanota hanota.cpp)

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

@@ -8,20 +8,20 @@
/* 二分探索：問題 f(i, j) */
int dfs(vector<int> &nums, int target, int i, int j) {
// 区間が空の場合、対象要素が存在しないことを示すため、-1 を返す
// 区間が空なら対象要素は存在しないので -1 を返す
if (i > j) {
return -1;
}
// 中点インデックス m を計算
int m = i + (j - i) / 2;
int m = (i + j) / 2;
if (nums[m] < target) {
// 再帰的な部分問題 f(m+1, j)
// 部分問題 f(m+1, j) を再帰的に解く
return dfs(nums, target, m + 1, j);
} else if (nums[m] > target) {
// 再帰的な部分問題 f(i, m-1)
// 部分問題 f(i, m-1) を再帰的に解く
return dfs(nums, target, i, m - 1);
} else {
// 対象要素が見つかったため、そのインデックスを返す
// 目標要素が見つかったらそのインデックスを返す
return m;
}
}
@@ -33,14 +33,14 @@ int binarySearch(vector<int> &nums, int target) {
return dfs(nums, target, 0, n - 1);
}
/* ドライバーコード */
/* Driver Code */
int main() {
int target = 6;
vector<int> nums = {1, 3, 6, 8, 12, 15, 23, 26, 31, 35};
// 二分探索（両端閉区間）
// 二分探索（両閉区間）
int index = binarySearch(nums, target);
cout << "対象要素 6 のインデックス =" << index << endl;
cout << "対象要素 6 のインデックス = " << index << endl;
return 0;
}

26
ja/codes/cpp/chapter_divide_and_conquer/build_tree.cpp
View File

@@ -6,26 +6,26 @@
#include "../utils/common.hpp"
/* 二分木の構築：分割統治 */
/* 二分木を構築：分割統治 */
TreeNode *dfs(vector<int> &preorder, unordered_map<int, int> &inorderMap, int i, int l, int r) {
// 部分木の区間が空の場合に終了
// 部分木区間が空なら終了する
if (r - l < 0)
return NULL;
// ルートノードを初期化
// ルートノードを初期化する
TreeNode *root = new TreeNode(preorder[i]);
// m を問い合わせて左右の部分木を分割
// m を求めて左右部分木を分割する
int m = inorderMap[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;
}
/* 二分木の構築 */
/* 二分木を構築 */
TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) {
// ハッシュテーブルを初期化し、中間順序の要素からインデックスへのマッピングを格納
// inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する
unordered_map<int, int> inorderMap;
for (int i = 0; i < inorder.size(); i++) {
inorderMap[inorder[i]] = i;
@@ -34,18 +34,18 @@ TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) {
return root;
}
/* ドライバーコード */
/* Driver Code */
int main() {
vector<int> preorder = {3, 9, 2, 1, 7};
vector<int> inorder = {9, 3, 1, 2, 7};
cout << "前順走査 = ";
printVector(preorder);
cout << "中間順序走査 = ";
cout << "中順走査 = ";
printVector(inorder);
TreeNode *root = buildTree(preorder, inorder);
cout << "構築された二分木:\n";
cout << "構築した二分木：\n";
printTree(root);
return 0;
}
}

30
ja/codes/cpp/chapter_divide_and_conquer/hanota.cpp
View File

@@ -6,45 +6,45 @@
#include "../utils/common.hpp"
/* 円盤を移動 */
/* 円盤を 1 枚移動 */
void move(vector<int> &src, vector<int> &tar) {
// src の最上部から円盤を取り出す
// src の上から円盤を1枚取り出す
int pan = src.back();
src.pop_back();
// 円盤を tar の最上部に配置
// 円盤を tar の上に置く
tar.push_back(pan);
}
/* ハノイの塔問題 f(i) を解く */
/* ハノイの塔の問題 f(i) を解く */
void dfs(int i, vector<int> &src, vector<int> &buf, vector<int> &tar) {
// src に円盤が1つだけ残っている場合、それを tar に移動
// src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す
if (i == 1) {
move(src, tar);
return;
}
// 部分問題 f(i-1)：tar の助けを借りて、上位 i-1 個の円盤を src から buf に移動
// 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す
dfs(i - 1, src, tar, buf);
// 部分問題 f(1)：残りの1つの円盤を src から tar に移動
// 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す
move(src, tar);
// 部分問題 f(i-1)：src の助けを借りて、上位 i-1 個の円盤を buf から tar に移動
// 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す
dfs(i - 1, buf, src, tar);
}
/* ハノイの塔問題を解く */
/* ハノイの塔を解く */
void solveHanota(vector<int> &A, vector<int> &B, vector<int> &C) {
int n = A.size();
// B の助けを借りて、上位 n 個の円盤を A から C に移動
// A の上から n 枚の円盤を B を介して C へ移す
dfs(n, A, B, C);
}
/* ドライバーコード */
/* Driver Code */
int main() {
// リストの末尾が柱の最上部
// リスト末尾が柱の頂上
vector<int> A = {5, 4, 3, 2, 1};
vector<int> B = {};
vector<int> C = {};
cout << "初期状態:\n";
cout << "初期状態：\n";
cout << "A =";
printVector(A);
cout << "B =";
@@ -54,7 +54,7 @@ int main() {
solveHanota(A, B, C);
cout << "円盤移動後:\n";
cout << "円盤の移動完了後：\n";
cout << "A =";
printVector(A);
cout << "B =";
@@ -63,4 +63,4 @@ int main() {
printVector(C);
return 0;
}
}

10
ja/codes/cpp/chapter_dynamic_programming/CMakeLists.txt Normal file
View File

@@ -0,0 +1,10 @@
add_executable(climbing_stairs_backtrack climbing_stairs_backtrack.cpp)
add_executable(climbing_stairs_dfs climbing_stairs_dfs.cpp)
add_executable(climbing_stairs_dfs_mem climbing_stairs_dfs_mem.cpp)
add_executable(climbing_stairs_dp climbing_stairs_dp.cpp)
add_executable(min_cost_climbing_stairs_dp min_cost_climbing_stairs_dp.cpp)
add_executable(min_path_sum min_path_sum.cpp)
add_executable(unbounded_knapsack unbounded_knapsack.cpp)
add_executable(coin_change coin_change.cpp)
add_executable(coin_change_ii coin_change_ii.cpp)
add_executable(edit_distance edit_distance.cpp)

21
ja/codes/cpp/chapter_dynamic_programming/climbing_stairs_backtrack.cpp
View File

@@ -1,3 +1,4 @@
/**
* File: climbing_stairs_backtrack.cpp
* Created Time: 2023-06-30
@@ -8,35 +9,35 @@
/* バックトラッキング */
void backtrack(vector<int> &choices, int state, int n, vector<int> &res) {
// n段目に到達したとき、解の数に1を加える
// 第 n 段に到達したら、方法数を 1 増やす
if (state == n)
res[0]++;
// すべての選択肢を走査
for (auto &choice : choices) {
// 剪定：n段を超えて登ることを許可しない
// 枝刈り: 第 n 段を超えないようにする
if (state + choice > n)
continue;
// 試行：選択を行い、状態を更新
// 試行: 選択を行い、状態を更新
backtrack(choices, state + choice, n, res);
// 撤回
// バックトラック
}
}
/* 階段登り：バックトラッキング */
int climbingStairsBacktrack(int n) {
vector<int> choices = {1, 2}; // 1段または2段登ることを選択可能
int state = 0; // 0段目から登り始める
vector<int> res = {0}; // res[0] を使用して解の数を記録
vector<int> choices = {1, 2}; // 1 段または 2 段上ることを選べる
int state = 0; // 第 0 段から上り始める
vector<int> res = {0}; // res[0] を使って方法数を記録する
backtrack(choices, state, n, res);
return res[0];
}
/* ドライバーコード */
/* Driver Code */
int main() {
int n = 9;
int res = climbingStairsBacktrack(n);
cout << n << "段の階段を登る解は" << res << "通りです" << endl;
cout << "階段を " << n << " 段上る方法は全部で " << res << " 通り" << endl;
return 0;
}
}

14
ja/codes/cpp/chapter_dynamic_programming/climbing_stairs_constraint_dp.cpp
View File

@@ -6,19 +6,19 @@
#include "../utils/common.hpp"
/* 制約付き階段登り：動的プログラミング */
/* 制約付き階段登り：動的計画法 */
int climbingStairsConstraintDP(int n) {
if (n == 1 || n == 2) {
return 1;
}
// DPテーブルを初期化し、部分問題の解を格納するために使用
// 部分問題の解を保存するために dp テーブルを初期化
vector<vector<int>> dp(n + 1, vector<int>(3, 0));
// 初期状態：最小の部分問題の解を事前設定
// 初期状態：最小部分問題の解をあらかじめ設定
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];
@@ -26,12 +26,12 @@ int climbingStairsConstraintDP(int n) {
return dp[n][1] + dp[n][2];
}
/* ドライバーコード */
/* Driver Code */
int main() {
int n = 9;
int res = climbingStairsConstraintDP(n);
cout << n << "段の階段を登る解は" << res << "通りです" << endl;
cout << "階段を " << n << " 段上る方法は全部で " << res << " 通り" << endl;
return 0;
}
}

10
ja/codes/cpp/chapter_dynamic_programming/climbing_stairs_dfs.cpp
View File

@@ -6,9 +6,9 @@
#include "../utils/common.hpp"
/* 探索 */
/* 検索 */
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]
@@ -21,12 +21,12 @@ int climbingStairsDFS(int n) {
return dfs(n);
}
/* ドライバーコード */
/* Driver Code */
int main() {
int n = 9;
int res = climbingStairsDFS(n);
cout << n << "段の階段を登る解は" << res << "通りです" << endl;
cout << "階段を " << n << " 段上る方法は全部で " << res << " 通り" << endl;
return 0;
}
}

14
ja/codes/cpp/chapter_dynamic_programming/climbing_stairs_dfs_mem.cpp
View File

@@ -8,32 +8,32 @@
/* メモ化探索 */
int dfs(int i, vector<int> &mem) {
// 既知の dp[1] と dp[2] を返す
// dp[1] と dp[2] は既知なので返す
if (i == 1 || i == 2)
return i;
// dp[i] の記録がある場合、それを返す
// dp[i] の記録があれば、それをそのまま返す
if (mem[i] != -1)
return mem[i];
// dp[i] = dp[i-1] + dp[i-2]
int count = dfs(i - 1, mem) + dfs(i - 2, mem);
// dp[i] を記録
// dp[i] を記録する
mem[i] = count;
return count;
}
/* 階段登り：メモ化探索 */
int climbingStairsDFSMem(int n) {
// mem[i] は i 段目に登る総解数を記録、-1 は記録なしを意味する
// mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す
vector<int> mem(n + 1, -1);
return dfs(n, mem);
}
/* ドライバーコード */
/* Driver Code */
int main() {
int n = 9;
int res = climbingStairsDFSMem(n);
cout << n << "段の階段を登る解は" << res << "通りです" << endl;
cout << "階段を " << n << " 段上る方法は全部で " << res << " 通り" << endl;
return 0;
}
}

18
ja/codes/cpp/chapter_dynamic_programming/climbing_stairs_dp.cpp
View File

@@ -6,23 +6,23 @@
#include "../utils/common.hpp"
/* 階段登り：動的プログラミング */
/* 階段登り：動的計画法 */
int climbingStairsDP(int n) {
if (n == 1 || n == 2)
return n;
// DPテーブルを初期化し、部分問題の解を格納するために使用
// 部分問題の解を保存するために dp テーブルを初期化
vector<int> dp(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];
}
/* 階段登り：空間最適化動的プログラミング */
/* 階段登り：空間最適化した動的計画法 */
int climbingStairsDPComp(int n) {
if (n == 1 || n == 2)
return n;
@@ -35,15 +35,15 @@ int climbingStairsDPComp(int n) {
return b;
}
/* ドライバーコード */
/* Driver Code */
int main() {
int n = 9;
int res = climbingStairsDP(n);
cout << n << "段の階段を登る解は" << res << "通りです" << endl;
cout << "階段を " << n << " 段上る方法は全部で " << res << " 通り" << endl;
res = climbingStairsDPComp(n);
cout << n << "段の階段を登る解は" << res << "通りです" << endl;
cout << "階段を " << n << " 段上る方法は全部で " << res << " 通り" << endl;
return 0;
}
}

32
ja/codes/cpp/chapter_dynamic_programming/coin_change.cpp
View File

@@ -6,24 +6,24 @@
#include "../utils/common.hpp"
/* 硬貨両替：動的プログラミング */
/* コイン両替：動的計画法 */
int coinChangeDP(vector<int> &coins, int amt) {
int n = coins.size();
int MAX = amt + 1;
// DPテーブルを初期化
// dp テーブルを初期化
vector<vector<int>> dp(n + 1, vector<int>(amt + 1, 0));
// 状態遷移：最初の行と最初の列
// 状態遷移：先頭行と先頭列
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] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);
}
}
@@ -31,21 +31,21 @@ int coinChangeDP(vector<int> &coins, int amt) {
return dp[n][amt] != MAX ? dp[n][amt] : -1;
}
/* 硬貨両替：空間最適化動的プログラミング */
/* コイン交換：空間最適化後の動的計画法 */
int coinChangeDPComp(vector<int> &coins, int amt) {
int n = coins.size();
int MAX = amt + 1;
// DPテーブルを初期化
// dp テーブルを初期化
vector<int> dp(amt + 1, MAX);
dp[0] = 0;
// 状態遷移
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] = min(dp[a], dp[a - coins[i - 1]] + 1);
}
}
@@ -53,18 +53,18 @@ int coinChangeDPComp(vector<int> &coins, int amt) {
return dp[amt] != MAX ? dp[amt] : -1;
}
/* ドライバーコード */
/* Driver code */
int main() {
vector<int> coins = {1, 2, 5};
int amt = 4;
// 動的プログラミング
// 動的計画法
int res = coinChangeDP(coins, amt);
cout << "目標金額を作るのに必要な最小硬貨数は " << res << " です" << endl;
cout << "目標金額を作るのに必要な最小硬貨枚数は " << res << endl;
// 空間最適化動的プログラミング
// 空間最適化後の動的計画法
res = coinChangeDPComp(coins, amt);
cout << "目標金額を作るのに必要な最小硬貨数は " << res << " です" << endl;
cout << "目標金額を作るのに必要な最小硬貨枚数は " << res << endl;
return 0;
}
}

30
ja/codes/cpp/chapter_dynamic_programming/coin_change_ii.cpp
View File

@@ -6,12 +6,12 @@
#include "../utils/common.hpp"
/* 硬貨両替 II：動的プログラミング */
/* コイン両替 II：動的計画法 */
int coinChangeIIDP(vector<int> &coins, int amt) {
int n = coins.size();
// DPテーブルを初期化
// dp テーブルを初期化
vector<vector<int>> dp(n + 1, vector<int>(amt + 1, 0));
// 最初の列を初期化
// 先頭列を初期化する
for (int i = 0; i <= n; i++) {
dp[i][0] = 1;
}
@@ -19,10 +19,10 @@ int coinChangeIIDP(vector<int> &coins, int amt) {
for (int i = 1; i <= n; i++) {
for (int a = 1; a <= amt; a++) {
if (coins[i - 1] > a) {
// 目標金額を超える場合、硬貨 i を選択しない
// 目標金額を超えるなら硬貨 i は選ばない
dp[i][a] = dp[i - 1][a];
} else {
// 選択しない場合と硬貨 i を選択する場合の2つの選択肢の合計
// コイン i を選ばない場合と選ぶ場合の和
dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];
}
}
@@ -30,20 +30,20 @@ int coinChangeIIDP(vector<int> &coins, int amt) {
return dp[n][amt];
}
/* 硬貨両替 II：空間最適化動的プログラミング */
/* コイン両替 II：空間最適化した動的計画法 */
int coinChangeIIDPComp(vector<int> &coins, int amt) {
int n = coins.size();
// DPテーブルを初期化
// dp テーブルを初期化
vector<int> dp(amt + 1, 0);
dp[0] = 1;
// 状態遷移
for (int i = 1; i <= n; i++) {
for (int a = 1; a <= amt; a++) {
if (coins[i - 1] > a) {
// 目標金額を超える場合、硬貨 i を選択しない
// 目標金額を超えるなら硬貨 i は選ばない
dp[a] = dp[a];
} else {
// 選択しない場合と硬貨 i を選択する場合の2つの選択肢の合計
// コイン i を選ばない場合と選ぶ場合の和
dp[a] = dp[a] + dp[a - coins[i - 1]];
}
}
@@ -51,18 +51,18 @@ int coinChangeIIDPComp(vector<int> &coins, int amt) {
return dp[amt];
}
/* ドライバーコード */
/* Driver code */
int main() {
vector<int> coins = {1, 2, 5};
int amt = 5;
// 動的プログラミング
// 動的計画法
int res = coinChangeIIDP(coins, amt);
cout << "目標金額を作る硬貨の組み合わせ数は " << res << " です" << endl;
cout << "目標金額を作る硬貨の組み合わせ数は " << res << endl;
// 空間最適化動的プログラミング
// 空間最適化後の動的計画法
res = coinChangeIIDPComp(coins, amt);
cout << "目標金額を作る硬貨の組み合わせ数は " << res << " です" << endl;
cout << "目標金額を作る硬貨の組み合わせ数は " << res << endl;
return 0;
}
}

100
ja/codes/cpp/chapter_dynamic_programming/edit_distance.cpp
View File

@@ -6,47 +6,73 @@
#include "../utils/common.hpp"
/* 編集距離：ブルートフォース探索 */
/* 編集距離：総当たり探索 */
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[i - 1] == t[j - 1])
return editDistanceDFS(s, t, i - 1, j - 1);
// 最小編集数 = 3つの操作（挿入、削除、置換）からの最小編集数 + 1
// 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1
int insert = editDistanceDFS(s, t, i, j - 1);
int del = editDistanceDFS(s, t, i - 1, j);
int replace = editDistanceDFS(s, t, i - 1, j - 1);
// 最小編集数を返す
// 最小編集回数を返す
return min(min(insert, del), replace) + 1;
}
/* 編集距離：動的プログラミング */
/* 編集距離：メモ化探索 */
int editDistanceDFSMem(string s, string t, vector<vector<int>> &mem, int i, int j) {
// s と t がともに空なら 0 を返す
if (i == 0 && j == 0)
return 0;
// s が空なら t の長さを返す
if (i == 0)
return j;
// t が空なら s の長さを返す
if (j == 0)
return i;
// 記録済みなら、それをそのまま返す
if (mem[i][j] != -1)
return mem[i][j];
// 2 つの文字が等しければ、その 2 文字をそのままスキップする
if (s[i - 1] == t[j - 1])
return editDistanceDFSMem(s, t, mem, i - 1, j - 1);
// 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1
int insert = editDistanceDFSMem(s, t, mem, i, j - 1);
int del = editDistanceDFSMem(s, t, mem, i - 1, j);
int replace = editDistanceDFSMem(s, t, mem, i - 1, j - 1);
// 最小編集回数を記録して返す
mem[i][j] = min(min(insert, del), replace) + 1;
return mem[i][j];
}
/* 編集距離：動的計画法 */
int editDistanceDP(string s, string t) {
int n = s.length(), m = t.length();
vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0));
// 状態遷移：最初の行と最初の列
// 状態遷移：先頭行と先頭列
for (int i = 1; i <= n; i++) {
dp[i][0] = i;
}
for (int j = 1; j <= m; j++) {
dp[0][j] = j;
}
// 状態遷移：残りの行と列
// 状態遷移: 残りの行と列
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (s[i - 1] == t[j - 1]) {
// 2つの文字が等しい場合、これら2つの文字をスキップ
// 2 つの文字が等しければ、その 2 文字をそのままスキップする
dp[i][j] = dp[i - 1][j - 1];
} else {
// 最小編集数 = 3つの操作（挿入、削除、置換）からの最小編集数 + 1
// 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1
dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;
}
}
@@ -54,19 +80,57 @@ int editDistanceDP(string s, string t) {
return dp[n][m];
}
/* ドライバーコード */
/* 編集距離：空間最適化した動的計画法 */
int editDistanceDPComp(string s, string t) {
int n = s.length(), m = t.length();
vector<int> dp(m + 1, 0);
// 状態遷移：先頭行
for (int j = 1; j <= m; j++) {
dp[j] = j;
}
// 状態遷移：残りの行
for (int i = 1; i <= n; i++) {
// 状態遷移：先頭列
int leftup = dp[0]; // dp[i-1, j-1] を一時保存する
dp[0] = i;
// 状態遷移：残りの列
for (int j = 1; j <= m; j++) {
int temp = dp[j];
if (s[i - 1] == t[j - 1]) {
// 2 つの文字が等しければ、その 2 文字をそのままスキップする
dp[j] = leftup;
} else {
// 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1
dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1;
}
leftup = temp; // 次の反復の dp[i-1, j-1] に更新する
}
}
return dp[m];
}
/* Driver Code */
int main() {
string s = "bag";
string t = "pack";
int n = s.length(), m = t.length();
// ブルートフォース探索
// 全探索
int res = editDistanceDFS(s, t, n, m);
cout << s << " を " << t << " に変更するには最低 " << res << " 回の編集が必要です" << endl;
cout << s << " を " << t << " に変更するには最小で " << res << " 回の編集が必要\n";
// 動的プログラミング
// メモ化探索
vector<vector<int>> mem(n + 1, vector<int>(m + 1, -1));
res = editDistanceDFSMem(s, t, mem, n, m);
cout << s << " を " << t << " に変更するには最小で " << res << " 回の編集が必要\n";
// 動的計画法
res = editDistanceDP(s, t);
cout << s << " を " << t << " に変更するには最低 " << res << " 回の編集が必要です" << endl;
cout << s << " を " << t << " に変更するには最小で " << res << " 回の編集が必要\n";
// 空間最適化後の動的計画法
res = editDistanceDPComp(s, t);
cout << s << " を " << t << " に変更するには最小で " << res << " 回の編集が必要\n";
return 0;
}
}

79
ja/codes/cpp/chapter_dynamic_programming/knapsack.cpp
View File

@@ -1,41 +1,61 @@
/**
* File: knapsack.cpp
* Created Time: 2023-07-10
* Author: krahets (krahets@163.com)
*/
#include <algorithm>
#include <iostream>
#include <vector>
#include "../utils/common.hpp"
using namespace std;
/* 0-1 ナップサック：ブルートフォース探索 */
/* 0-1 ナップサック：総当たり探索 */
int knapsackDFS(vector<int> &wgt, vector<int> &val, int i, int c) {
// すべてのアイテムが選択されたか、ナップサックに残り容量がない場合、値 0 を返す
// すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す
if (i == 0 || c == 0) {
return 0;
}
// ナップサックの容量を超える場合、ナップサックに入れないことしか選択できない
// ナップサック容量を超える場合は、入れない選択しかできない
if (wgt[i - 1] > c) {
return knapsackDFS(wgt, val, i - 1, c);
}
// アイテム i を入れない場合と入れる場合の最大値を計算
// 品物 i を入れない場合と入れる場合の最大価値を計算する
int no = knapsackDFS(wgt, val, i - 1, c);
int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];
// 2つの選択肢のより大きい値を返す
// 2つの案のうち価値が大きいほうを返す
return max(no, yes);
}
/* 0-1 ナップサック：動的プログラミング */
/* 0-1 ナップサック：メモ化探索 */
int knapsackDFSMem(vector<int> &wgt, vector<int> &val, vector<vector<int>> &mem, int i, int c) {
// すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 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 つの案のうち価値が大きい方を記録して返す
mem[i][c] = max(no, yes);
return mem[i][c];
}
/* 0-1 ナップサック：動的計画法 */
int knapsackDP(vector<int> &wgt, vector<int> &val, int cap) {
int n = wgt.size();
// DPテーブルを初期化
// dp テーブルを初期化
vector<vector<int>> dp(n + 1, vector<int>(cap + 1, 0));
// 状態遷移
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] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);
}
}
@@ -43,17 +63,17 @@ int knapsackDP(vector<int> &wgt, vector<int> &val, int cap) {
return dp[n][cap];
}
/* 0-1 ナップサック：空間最適化動的プログラミング */
/* 0-1 ナップサック：空間最適化後の動的計画法 */
int knapsackDPComp(vector<int> &wgt, vector<int> &val, int cap) {
int n = wgt.size();
// DPテーブルを初期化
// dp テーブルを初期化
vector<int> dp(cap + 1, 0);
// 状態遷移
for (int i = 1; i <= n; i++) {
// 逆順で走査
// 逆順に走査する
for (int c = cap; c >= 1; c--) {
if (wgt[i - 1] <= c) {
// 選択しない場合とアイテム i を選択する場合のより大きい値
// 品物 i を選ばない場合と選ぶ場合の大きい方
dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
}
}
@@ -61,24 +81,29 @@ int knapsackDPComp(vector<int> &wgt, vector<int> &val, int cap) {
return dp[cap];
}
/* ドライバーコード */
/* Driver Code */
int main() {
vector<int> wgt = {10, 20, 30, 40, 50};
vector<int> val = {50, 120, 150, 210, 240};
int cap = 50;
int n = wgt.size();
// ブルートフォース探索
// 全探索
int res = knapsackDFS(wgt, val, n, cap);
cout << "ナップサック容量内での最大値は " << res << " です" << endl;
cout << "ナップサック容量を超えない最大価値は " << res << endl;
// 動的プログラミング
// メモ化探索
vector<vector<int>> mem(n + 1, vector<int>(cap + 1, -1));
res = knapsackDFSMem(wgt, val, mem, n, cap);
cout << "ナップサック容量を超えない最大価値は " << res << endl;
// 動的計画法
res = knapsackDP(wgt, val, cap);
cout << "ナップサック容量内での最大値は " << res << " です" << endl;
cout << "ナップサック容量を超えない最大価値は " << res << endl;
// 空間最適化動的プログラミング
// 空間最適化後の動的計画法
res = knapsackDPComp(wgt, val, cap);
cout << "ナップサック容量内での最大値は " << res << " です" << endl;
cout << "ナップサック容量を超えない最大価値は " << res << endl;
return 0;
}
}

26
ja/codes/cpp/chapter_dynamic_programming/min_cost_climbing_stairs_dp.cpp
View File

@@ -6,24 +6,24 @@
#include "../utils/common.hpp"
/* 最小コスト階段登り：動的プログラミング */
/* 階段登りの最小コスト：動的計画法 */
int minCostClimbingStairsDP(vector<int> &cost) {
int n = cost.size() - 1;
if (n == 1 || n == 2)
return cost[n];
// DPテーブルを初期化し、部分問題の解を格納するために使用
// 部分問題の解を保存するために dp テーブルを初期化
vector<int> dp(n + 1);
// 初期状態：最小の部分問題の解を事前設定
// 初期状態：最小部分問題の解をあらかじめ設定
dp[1] = cost[1];
dp[2] = cost[2];
// 状態遷移：小さな問題から大きな部分問題を段階的に解く
// 状態遷移：小さい部分問題から大きい部分問題へ順に解く
for (int i = 3; i <= n; i++) {
dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];
}
return dp[n];
}
/* 最小コスト階段登り：空間最適化動的プログラミング */
/* 階段昇りの最小コスト：空間最適化後の動的計画法 */
int minCostClimbingStairsDPComp(vector<int> &cost) {
int n = cost.size() - 1;
if (n == 1 || n == 2)
@@ -37,21 +37,17 @@ int minCostClimbingStairsDPComp(vector<int> &cost) {
return b;
}
/* ドライバーコード */
/* Driver Code */
int main() {
vector<int> cost = {0, 1, 10, 1, 1, 1, 10, 1, 1, 10, 1};
cout << "階段のコストリストを [";
for (int i = 0; i < cost.size(); i++) {
cout << cost[i];
if (i < cost.size() - 1) cout << ", ";
}
cout << "] として入力" << endl;
cout << "入力された階段コストのリストは ";
printVector(cost);
int res = minCostClimbingStairsDP(cost);
cout << "階段を登るための最小コスト " << res << endl;
cout << "階段を上り切る最小コストは " << res << endl;
res = minCostClimbingStairsDPComp(cost);
cout << "階段を登るための最小コスト " << res << endl;
cout << "階段を上り切る最小コストは " << res << endl;
return 0;
}
}

94
ja/codes/cpp/chapter_dynamic_programming/min_path_sum.cpp
View File

@@ -6,38 +6,60 @@
#include "../utils/common.hpp"
/* 最小パス和：ブルートフォース探索 */
/* 最小経路和：全探索 */
int minPathSumDFS(vector<vector<int>> &grid, int i, int j) {
// 左上のセルの場合、探索を終了
// 左上のセルなら探索を終了する
if (i == 0 && j == 0) {
return grid[0][0];
}
// 行または列のインデックスが範囲外の場合、+∞ のコストを返す
// 行または列のインデックスが範囲外なら、コスト +∞ を返す
if (i < 0 || j < 0) {
return INT_MAX;
}
// 左上から (i-1, j) と (i, j-1) への最小パスコストを計算
// 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する
int up = minPathSumDFS(grid, i - 1, j);
int left = minPathSumDFS(grid, i, j - 1);
// 左上から (i, j) への最小パスコストを返す
return min(left, up) + grid[i][j];
// 左上隅から (i, j) までの最小経路コストを返す
return min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;
}
/* 最小パス和：動的プログラミング */
/* 最小経路和：メモ化探索 */
int minPathSumDFSMem(vector<vector<int>> &grid, vector<vector<int>> &mem, int i, int j) {
// 左上のセルなら探索を終了する
if (i == 0 && j == 0) {
return grid[0][0];
}
// 行または列のインデックスが範囲外なら、コスト +∞ を返す
if (i < 0 || j < 0) {
return INT_MAX;
}
// 既に記録があればそのまま返す
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) までの最小経路コストを記録して返す
mem[i][j] = min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;
return mem[i][j];
}
/* 最小経路和：動的計画法 */
int minPathSumDP(vector<vector<int>> &grid) {
int n = grid.size(), m = grid[0].size();
// DPテーブルを初期化
// dp テーブルを初期化
vector<vector<int>> dp(n, vector<int>(m));
dp[0][0] = grid[0][0];
// 状態遷移：最初の行
// 状態遷移：先頭行
for (int j = 1; j < m; j++) {
dp[0][j] = dp[0][j - 1] + grid[0][j];
}
// 状態遷移：最初の列
// 状態遷移：先頭列
for (int i = 1; i < n; i++) {
dp[i][0] = dp[i - 1][0] + grid[i][0];
}
// 状態遷移：残りの行と列
// 状態遷移: 残りの行と列
for (int i = 1; i < n; i++) {
for (int j = 1; j < m; j++) {
dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];
@@ -46,23 +68,49 @@ int minPathSumDP(vector<vector<int>> &grid) {
return dp[n - 1][m - 1];
}
/* ドライバーコード */
/* 最小経路和：空間最適化後の動的計画法 */
int minPathSumDPComp(vector<vector<int>> &grid) {
int n = grid.size(), m = grid[0].size();
// dp テーブルを初期化
vector<int> dp(m);
// 状態遷移：先頭行
dp[0] = grid[0][0];
for (int j = 1; j < m; j++) {
dp[j] = dp[j - 1] + grid[0][j];
}
// 状態遷移：残りの行
for (int i = 1; i < n; i++) {
// 状態遷移：先頭列
dp[0] = dp[0] + grid[i][0];
// 状態遷移：残りの列
for (int j = 1; j < m; j++) {
dp[j] = min(dp[j - 1], dp[j]) + grid[i][j];
}
}
return dp[m - 1];
}
/* Driver Code */
int main() {
vector<vector<int>> grid = {
{1, 3, 1, 5},
{2, 2, 4, 2},
{5, 3, 2, 1},
{4, 3, 5, 2}
};
vector<vector<int>> grid = {{1, 3, 1, 5}, {2, 2, 4, 2}, {5, 3, 2, 1}, {4, 3, 5, 2}};
int n = grid.size(), m = grid[0].size();
// ブルートフォース探索
// 全探索
int res = minPathSumDFS(grid, n - 1, m - 1);
cout << "左上角から右下角への最小パス和は " << res << " です" << endl;
cout << "左上から右下までの最小経路和は " << res << endl;
// 動的プログラミング
// メモ化探索
vector<vector<int>> mem(n, vector<int>(m, -1));
res = minPathSumDFSMem(grid, mem, n - 1, m - 1);
cout << "左上から右下までの最小経路和は " << res << endl;
// 動的計画法
res = minPathSumDP(grid);
cout << "左上角から右下角への最小パス和は " << res << " です" << endl;
cout << "左上から右下までの最小経路和は " << res << endl;
// 空間最適化後の動的計画法
res = minPathSumDPComp(grid);
cout << "左上から右下までの最小経路和は " << res << endl;
return 0;
}
}

28
ja/codes/cpp/chapter_dynamic_programming/unbounded_knapsack.cpp
View File

@@ -6,19 +6,19 @@
#include "../utils/common.hpp"
/* 完全ナップサック：動的プログラミング */
/* 完全ナップサック問題：動的計画法 */
int unboundedKnapsackDP(vector<int> &wgt, vector<int> &val, int cap) {
int n = wgt.size();
// DPテーブルを初期化
// dp テーブルを初期化
vector<vector<int>> dp(n + 1, vector<int>(cap + 1, 0));
// 状態遷移
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] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);
}
}
@@ -26,19 +26,19 @@ int unboundedKnapsackDP(vector<int> &wgt, vector<int> &val, int cap) {
return dp[n][cap];
}
/* 完全ナップサック：空間最適化動的プログラミング */
/* 完全ナップサック問題：空間最適化後の動的計画法 */
int unboundedKnapsackDPComp(vector<int> &wgt, vector<int> &val, int cap) {
int n = wgt.size();
// DPテーブルを初期化
// dp テーブルを初期化
vector<int> dp(cap + 1, 0);
// 状態遷移
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] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
}
}
@@ -46,19 +46,19 @@ int unboundedKnapsackDPComp(vector<int> &wgt, vector<int> &val, int cap) {
return dp[cap];
}
/* ドライバーコード */
/* Driver code */
int main() {
vector<int> wgt = {1, 2, 3};
vector<int> val = {5, 11, 15};
int cap = 4;
// 動的プログラミング
// 動的計画法
int res = unboundedKnapsackDP(wgt, val, cap);
cout << "ナップサック容量内での最大値は " << res << " です" << endl;
cout << "ナップサック容量を超えない最大価値は " << res << endl;
// 空間最適化動的プログラミング
// 空間最適化後の動的計画法
res = unboundedKnapsackDPComp(wgt, val, cap);
cout << "ナップサック容量内での最大値は " << res << " です" << endl;
cout << "ナップサック容量を超えない最大価値は " << res << endl;
return 0;
}
}

5
ja/codes/cpp/chapter_graph/CMakeLists.txt Normal file
View File

@@ -0,0 +1,5 @@
add_executable(graph_bfs graph_bfs.cpp)
add_executable(graph_dfs graph_dfs.cpp)
# add_executable(graph_adjacency_list graph_adjacency_list.cpp)
add_executable(graph_adjacency_list_test graph_adjacency_list_test.cpp)
add_executable(graph_adjacency_matrix graph_adjacency_matrix.cpp)

20
ja/codes/cpp/chapter_graph/graph_adjacency_list.cpp
View File

@@ -9,10 +9,10 @@
/* 隣接リストに基づく無向グラフクラス */
class GraphAdjList {
public:
// 隣接リスト、キー：頂点、値：その頂点のすべての隣接頂点
// 隣接リスト。key は頂点、value はその頂点に隣接する全頂点
unordered_map<Vertex *, vector<Vertex *>> adjList;
/* ベクターから指定されたノードを削除 */
/* vector 内の指定ノードを削除 */
void remove(vector<Vertex *> &vec, Vertex *vet) {
for (int i = 0; i < vec.size(); i++) {
if (vec[i] == vet) {
@@ -40,7 +40,7 @@ class GraphAdjList {
/* 辺を追加 */
void addEdge(Vertex *vet1, Vertex *vet2) {
if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)
throw invalid_argument("Vertex does not exist");
throw invalid_argument("頂点が存在しません");
// 辺 vet1 - vet2 を追加
adjList[vet1].push_back(vet2);
adjList[vet2].push_back(vet1);
@@ -49,7 +49,7 @@ class GraphAdjList {
/* 辺を削除 */
void removeEdge(Vertex *vet1, Vertex *vet2) {
if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)
throw invalid_argument("Vertex does not exist");
throw invalid_argument("頂点が存在しません");
// 辺 vet1 - vet2 を削除
remove(adjList[vet1], vet2);
remove(adjList[vet2], vet1);
@@ -59,23 +59,23 @@ class GraphAdjList {
void addVertex(Vertex *vet) {
if (adjList.count(vet))
return;
// 隣接リストに新しい連結リストを追加
// 隣接リストに新しいリストを追加
adjList[vet] = vector<Vertex *>();
}
/* 頂点を削除 */
void removeVertex(Vertex *vet) {
if (!adjList.count(vet))
throw invalid_argument("Vertex does not exist");
// 隣接リストから頂点vetに対応する連結リストを削除
throw invalid_argument("頂点が存在しません");
// 隣接リストから頂点 vet に対応するリストを削除
adjList.erase(vet);
// 他の頂点の連結リストを走査し、vetを含むすべての辺を削除
// 他の頂点のリストを走査し、vet を含むすべての辺を削除
for (auto &adj : adjList) {
remove(adj.second, vet);
}
}
/* 隣接リストを印刷 */
/* 隣接リストを出力 */
void print() {
cout << "隣接リスト =" << endl;
for (auto &adj : adjList) {
@@ -87,4 +87,4 @@ class GraphAdjList {
}
};
// テストケースはgraph_adjacency_list_test.cppを参照
// テストケースは `graph_adjacency_list_test.cpp` を参照

49
ja/codes/cpp/chapter_graph/graph_adjacency_list_test.cpp Normal file
View File

@@ -0,0 +1,49 @@
/**
* File: graph_adjacency_list_test.cpp
* Created Time: 2023-02-09
* Author: what-is-me (whatisme@outlook.jp), krahets (krahets@163.com)
*/
#include "./graph_adjacency_list.cpp"
/* Driver Code */
int main() {
/* 無向グラフを初期化 */
vector<Vertex *> v = valsToVets(vector<int>{1, 3, 2, 5, 4});
vector<vector<Vertex *>> edges = {{v[0], v[1]}, {v[0], v[3]}, {v[1], v[2]},
{v[2], v[3]}, {v[2], v[4]}, {v[3], v[4]}};
GraphAdjList graph(edges);
cout << "\n初期化後、グラフは" << endl;
graph.print();
/* 辺を追加 */
// 頂点 1, 2 は v[0], v[2]
graph.addEdge(v[0], v[2]);
cout << "\n辺 1-2 を追加した後、グラフは" << endl;
graph.print();
/* 辺を削除 */
// 頂点 1, 3 は v[0], v[1]
graph.removeEdge(v[0], v[1]);
cout << "\n辺 1-3 を削除した後、グラフは" << endl;
graph.print();
/* 頂点を追加 */
Vertex *v5 = new Vertex(6);
graph.addVertex(v5);
cout << "\n頂点 6 を追加した後、グラフは" << endl;
graph.print();
/* 頂点を削除 */
// 頂点 3 は v[1]
graph.removeVertex(v[1]);
cout << "\n頂点 3 を削除した後、グラフは" << endl;
graph.print();
// メモリを解放する
for (Vertex *vet : v) {
delete vet;
}
return 0;
}

56
ja/codes/cpp/chapter_graph/graph_adjacency_matrix.cpp
View File

@@ -8,8 +8,8 @@
/* 隣接行列に基づく無向グラフクラス */
class GraphAdjMat {
vector<int> vertices; // 頂点リスト、要素は「頂点値」を表し、インデックスは「頂点インデックス」を表す
vector<vector<int>> adjMat; // 隣接行列、行と列のインデックスは「頂点インデックス」に対応
vector<int> vertices; // 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す
vector<vector<int>> adjMat; // 隣接行列。行・列のインデックスは「頂点インデックス」に対応
public:
/* コンストラクタ */
@@ -19,7 +19,7 @@ class GraphAdjMat {
addVertex(val);
}
// 辺を追加
// 辺の要素は頂点インデックスを表す
// 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する
for (const vector<int> &edge : edges) {
addEdge(edge[0], edge[1]);
}
@@ -33,11 +33,11 @@ class GraphAdjMat {
/* 頂点を追加 */
void addVertex(int val) {
int n = size();
// 頂点リストに新しい頂点値を追加
// 頂点リストに新しい頂点の値を追加
vertices.push_back(val);
// 隣接行列に行を追加
// 隣接行列に 1 行追加
adjMat.emplace_back(vector<int>(n, 0));
// 隣接行列に列を追加
// 隣接行列に 1 列追加
for (vector<int> &row : adjMat) {
row.push_back(0);
}
@@ -46,42 +46,42 @@ class GraphAdjMat {
/* 頂点を削除 */
void removeVertex(int index) {
if (index >= size()) {
throw out_of_range("Vertex does not exist");
throw out_of_range("頂点が存在しません");
}
// 頂点リストから`index`の頂点を削除
// 頂点リストから index の頂点を削除する
vertices.erase(vertices.begin() + index);
// 隣接行列から`index`の行を削除
// 隣接行列で index 行を削除する
adjMat.erase(adjMat.begin() + index);
// 隣接行列から`index`の列を削除
// 隣接行列で index 列を削除する
for (vector<int> &row : adjMat) {
row.erase(row.begin() + index);
}
}
/* 辺を追加 */
// パラメータi、jは頂点要素のインデックスに対応
// 引数 i, j は vertices の要素インデックスに対応する
void addEdge(int i, int j) {
// インデックス範囲外と等価性を処理
// インデックスの範囲外と等値の処理
if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {
throw out_of_range("Vertex does not exist");
throw out_of_range("頂点が存在しません");
}
// 無向グラフでは、隣接行列は主対角線について対称、即ち(i, j) == (j, i)を満たす
// 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす
adjMat[i][j] = 1;
adjMat[j][i] = 1;
}
/* 辺を削除 */
// パラメータi、jは頂点要素のインデックスに対応
// 引数 i, j は vertices の要素インデックスに対応する
void removeEdge(int i, int j) {
// インデックス範囲外と等価性を処理
// インデックスの範囲外と等値の処理
if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {
throw out_of_range("Vertex does not exist");
throw out_of_range("頂点が存在しません");
}
adjMat[i][j] = 0;
adjMat[j][i] = 0;
}
/* 隣接行列を印刷 */
/* 隣接行列を出力 */
void print() {
cout << "頂点リスト = ";
printVector(vertices);
@@ -90,10 +90,10 @@ class GraphAdjMat {
}
};
/* ドライバーコード */
/* Driver Code */
int main() {
/* 無向グラフを初期化 */
// 辺の要素は頂点インデックスを表す
// edges の要素は頂点インデックス、すなわち vertices の要素インデックスに対応する点に注意
vector<int> vertices = {1, 3, 2, 5, 4};
vector<vector<int>> edges = {{0, 1}, {0, 3}, {1, 2}, {2, 3}, {2, 4}, {3, 4}};
GraphAdjMat graph(vertices, edges);
@@ -101,27 +101,27 @@ int main() {
graph.print();
/* 辺を追加 */
// 頂点1、2のインデックスはそれぞれ0、2
// 頂点 1, 2 のインデックスはそれぞれ 0, 2
graph.addEdge(0, 2);
cout << "\n辺 1-2 を追加後、グラフは" << endl;
cout << "\n辺 1-2 を追加した後、グラフは" << endl;
graph.print();
/* 辺を削除 */
// 頂点1、3のインデックスはそれぞれ0、1
// 頂点 1, 3 のインデックスはそれぞれ 0, 1
graph.removeEdge(0, 1);
cout << "\n辺 1-3 を削除後、グラフは" << endl;
cout << "\n辺 1-3 を削除した後、グラフは" << endl;
graph.print();
/* 頂点を追加 */
graph.addVertex(6);
cout << "\n頂点 6 を追加後、グラフは" << endl;
cout << "\n頂点 6 を追加した後、グラフは" << endl;
graph.print();
/* 頂点を削除 */
// 頂点3のインデックスは1
// 頂点 3 のインデックスは 1
graph.removeVertex(1);
cout << "\n頂点 3 を削除後、グラフは" << endl;
cout << "\n頂点 3 を削除した後、グラフは" << endl;
graph.print();
return 0;
}
}

38
ja/codes/cpp/chapter_graph/graph_bfs.cpp
View File

@@ -7,34 +7,34 @@
#include "../utils/common.hpp"
#include "./graph_adjacency_list.cpp"
/* 幅優先走査 */
// 隣接リストを使用してグラフを表現し、指定された頂点のすべての隣接頂点を取得
/* 幅優先探索 */
// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする
vector<Vertex *> graphBFS(GraphAdjList &graph, Vertex *startVet) {
// 頂点走査順序
// 頂点の走査順序
vector<Vertex *> res;
// ハッシュセット、訪問済み頂点を記録するために使用
// 訪問済み頂点を記録するためのハッシュ集合
unordered_set<Vertex *> visited = {startVet};
// BFSを実装するために使用されるキュー
// BFS の実装にキューを用いる
queue<Vertex *> que;
que.push(startVet);
// 頂点vetから開始し、すべての頂点が訪問されるまでループ
// 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す
while (!que.empty()) {
Vertex *vet = que.front();
que.pop(); // キューの先頭の頂点をデキュー
res.push_back(vet); // 訪問済み頂点を記録
// その頂点のすべての隣接頂点を走査
que.pop(); // 先頭の頂点をデキュー
res.push_back(vet); // 訪問した頂点を記録
// この頂点のすべての隣接頂点を走査
for (auto adjVet : graph.adjList[vet]) {
if (visited.count(adjVet))
continue; // すでに訪問済みの頂点をスキップ
que.push(adjVet); // 未訪問の頂点のみをエンキュー
visited.emplace(adjVet); // 頂点を訪問済みとしてマーク
continue; // 訪問済みの頂点をスキップ
que.push(adjVet); // 未訪問の頂点のみをキューに追加
visited.emplace(adjVet); // この頂点を訪問済みにする
}
}
// 頂点走査順序を返す
// 頂点の走査順を返す
return res;
}
/* ドライバーコード */
/* Driver Code */
int main() {
/* 無向グラフを初期化 */
vector<Vertex *> v = valsToVets({0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
@@ -42,18 +42,18 @@ int main() {
{v[2], v[5]}, {v[3], v[4]}, {v[3], v[6]}, {v[4], v[5]},
{v[4], v[7]}, {v[5], v[8]}, {v[6], v[7]}, {v[7], v[8]}};
GraphAdjList graph(edges);
cout << "\n初期化後、グラフは\n";
cout << "\n初期化後、グラフは\\n";
graph.print();
/* 幅優先走査 */
/* 幅優先探索 */
vector<Vertex *> res = graphBFS(graph, v[0]);
cout << "\n幅優先走査（BFS）の頂点順序は" << endl;
cout << "\n幅優先探索（BFS）の頂点順序は" << endl;
printVector(vetsToVals(res));
// メモリを解放
// メモリを解放する
for (Vertex *vet : v) {
delete vet;
}
return 0;
}
}

28
ja/codes/cpp/chapter_graph/graph_dfs.cpp
View File

@@ -7,31 +7,31 @@
#include "../utils/common.hpp"
#include "./graph_adjacency_list.cpp"
/* 深さ優先走査ヘルパー関数 */
/* 深さ優先走査の補助関数 */
void dfs(GraphAdjList &graph, unordered_set<Vertex *> &visited, vector<Vertex *> &res, Vertex *vet) {
res.push_back(vet); // 訪問済み頂点を記録
visited.emplace(vet); // 頂点を訪問済みとしてマーク
// その頂点のすべての隣接頂点を走査
res.push_back(vet); // 訪問した頂点を記録
visited.emplace(vet); // この頂点を訪問済みにする
// この頂点のすべての隣接頂点を走査
for (Vertex *adjVet : graph.adjList[vet]) {
if (visited.count(adjVet))
continue; // すでに訪問済みの頂点をスキップ
continue; // 訪問済みの頂点をスキップ
// 隣接頂点を再帰的に訪問
dfs(graph, visited, res, adjVet);
}
}
/* 深さ優先走査 */
// 隣接リストを使用してグラフを表現し、指定された頂点のすべての隣接頂点を取得
/* 深さ優先探索 */
// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする
vector<Vertex *> graphDFS(GraphAdjList &graph, Vertex *startVet) {
// 頂点走査順序
// 頂点の走査順序
vector<Vertex *> res;
// ハッシュセット、訪問済み頂点を記録するために使用
// 訪問済み頂点を記録するためのハッシュ集合
unordered_set<Vertex *> visited;
dfs(graph, visited, res, startVet);
return res;
}
/* ドライバーコード */
/* Driver Code */
int main() {
/* 無向グラフを初期化 */
vector<Vertex *> v = valsToVets(vector<int>{0, 1, 2, 3, 4, 5, 6});
@@ -41,15 +41,15 @@ int main() {
cout << "\n初期化後、グラフは" << endl;
graph.print();
/* 深さ優先走査 */
/* 深さ優先探索 */
vector<Vertex *> res = graphDFS(graph, v[0]);
cout << "\n深さ優先走査（DFS）の頂点順序は" << endl;
cout << "\n深さ優先探索（DFS）の頂点順序は" << endl;
printVector(vetsToVals(res));
// メモリを解放
// メモリを解放する
for (Vertex *vet : v) {
delete vet;
}
return 0;
}
}

3
ja/codes/cpp/chapter_greedy/CMakeLists.txt Normal file
View File

@@ -0,0 +1,3 @@
add_executable(coin_change_greedy coin_change_greedy.cpp)
add_executable(fractional_knapsack fractional_knapsack.cpp)
add_executable(max_capacity max_capacity.cpp)

32
ja/codes/cpp/chapter_greedy/coin_change_greedy.cpp
View File

@@ -6,55 +6,55 @@
#include "../utils/common.hpp"
/* 硬貨両替：貪欲法 */
/* コイン交換：貪欲法 */
int coinChangeGreedy(vector<int> &coins, int amt) {
// 硬貨リストが順序付けされていると仮定
// coins リストはソート済みと仮定する
int i = coins.size() - 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;
}
/* ドライバーコード */
/* Driver Code */
int main() {
// 貪欲法：大域最適解の発見を保証できる
// 貪欲法：大域最適解を保証できる
vector<int> coins = {1, 5, 10, 20, 50, 100};
int amt = 186;
int res = coinChangeGreedy(coins, amt);
cout << "\ncoins = ";
printVector(coins);
cout << "amt = " << amt << endl;
cout << amt << " を作るのに必要な最小硬貨数は " << res << " です" << endl;
cout << amt << " を作るのに必要な最小硬貨枚数は " << res << endl;
// 貪欲法：大域最適解の発見を保証できない
// 貪欲法：大域最適解を保証できない
coins = {1, 20, 50};
amt = 60;
res = coinChangeGreedy(coins, amt);
cout << "\ncoins = ";
printVector(coins);
cout << "amt = " << amt << endl;
cout << amt << " を作るのに必要な最小硬貨数は " << res << " です" << endl;
cout << "実際には、最小必要数は 3 です。つまり、20 + 20 + 20" << endl;
cout << amt << " を作るのに必要な最小硬貨枚数は " << res << endl;
cout << "実際に必要な最小枚数は 3、つまり 20 + 20 + 20" << endl;
// 貪欲法：大域最適解の発見を保証できない
// 貪欲法：大域最適解を保証できない
coins = {1, 49, 50};
amt = 98;
res = coinChangeGreedy(coins, amt);
cout << "\ncoins = ";
printVector(coins);
cout << "amt = " << amt << endl;
cout << amt << " を作るのに必要な最小硬貨数は " << res << " です" << endl;
cout << "実際には、最小必要数は 2 です。つまり、49 + 49" << endl;
cout << amt << " を作るのに必要な最小硬貨枚数は " << res << endl;
cout << "実際に必要な最小枚数は 2、つまり 49 + 49" << endl;
return 0;
}
}

26
ja/codes/cpp/chapter_greedy/fractional_knapsack.cpp
View File

@@ -6,11 +6,11 @@
#include "../utils/common.hpp"
/* アイテム */
/* 品物 */
class Item {
public:
int w; // アイテムの重量
int v; // アイテムの価値
int w; // 品物の重さ
int v; // 品物の価値
Item(int w, int v) : w(w), v(v) {
}
@@ -18,39 +18,39 @@ class Item {
/* 分数ナップサック：貪欲法 */
double fractionalKnapsack(vector<int> &wgt, vector<int> &val, int cap) {
// アイテムリストを作成、2つの属性を含む：重量、価値
// 重さと価値の 2 属性を持つ品物リストを作成
vector<Item> items;
for (int i = 0; i < wgt.size(); i++) {
items.push_back(Item(wgt[i], val[i]));
}
// 単位価値 item.v / item.w で高い順にソート
// 単位価値 item.v / item.w の高い順にソートする
sort(items.begin(), items.end(), [](Item &a, Item &b) { return (double)a.v / a.w > (double)b.v / b.w; });
// 貪欲選択をループ
// 貪欲選択を繰り返す
double res = 0;
for (auto &item : items) {
if (item.w <= cap) {
// 残り容量が十分な場合、アイテム全体をナップサックに入れる
// 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる
res += item.v;
cap -= item.w;
} else {
// 残り容量が不十分な場合、アイテムの一部をナップサックに入れる
// 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる
res += (double)item.v / item.w * cap;
// 残り容量がなくなったため、ループを中断
// 残り容量がないため、ループを抜ける
break;
}
}
return res;
}
/* ドライバーコード */
/* Driver Code */
int main() {
vector<int> wgt = {10, 20, 30, 40, 50};
vector<int> val = {50, 120, 150, 210, 240};
int cap = 50;
// 貪欲アルゴリズム
// 貪欲法
double res = fractionalKnapsack(wgt, val, cap);
cout << "ナップサック容量内での最大値は " << res << " です" << endl;
cout << "ナップサック容量を超えない最大価値は " << res << endl;
return 0;
}
}

18
ja/codes/cpp/chapter_greedy/max_capacity.cpp
View File

@@ -8,16 +8,16 @@
/* 最大容量：貪欲法 */
int maxCapacity(vector<int> &ht) {
// i、j を初期化し、配列の両端で分割させる
// i, j を初期化し、それぞれ配列の両端に置く
int i = 0, j = ht.size() - 1;
// 初期最大容量は 0
// 初期の最大容量は 0
int res = 0;
// 2つの板が出会うまで貪欲選択をループ
// 2 枚の板が出会うまで貪欲選択を繰り返す
while (i < j) {
// 最大容量を更新
// 最大容量を更新する
int cap = min(ht[i], ht[j]) * (j - i);
res = max(res, cap);
// より短い板を内側に移動
// 短い方を内側へ動かす
if (ht[i] < ht[j]) {
i++;
} else {
@@ -27,13 +27,13 @@ int maxCapacity(vector<int> &ht) {
return res;
}
/* ドライバーコード */
/* Driver Code */
int main() {
vector<int> ht = {3, 8, 5, 2, 7, 7, 3, 4};
// 貪欲アルゴリズム
// 貪欲法
int res = maxCapacity(ht);
cout << "最大容量は " << res << " です" << endl;
cout << "最大容量は " << res << endl;
return 0;
}
}

20
ja/codes/cpp/chapter_greedy/max_product_cutting.cpp
View File

@@ -6,34 +6,34 @@
#include "../utils/common.hpp"
/* 最大積切断：貪欲法 */
/* 最大切断積：貪欲法 */
int maxProductCutting(int n) {
// n <= 3 の場合、1 を切り出す必要がある
// n <= 3 のときは、必ず 1 を切り出す
if (n <= 3) {
return 1 * (n - 1);
}
// 貪欲に 3 を切り出す。a は 3 の個数、b は余り
// 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする
int a = n / 3;
int b = n % 3;
if (b == 1) {
// 余りが 1 の場合、1 * 3 のペアを 2 * 2 に変換
// 余りが 1 のときは、1 * 3 を 2 * 2 に変える
return (int)pow(3, a - 1) * 2 * 2;
}
if (b == 2) {
// 余りが 2 の場合、何もしない
// 余りが 2 のときは、そのままにする
return (int)pow(3, a) * 2;
}
// 余りが 0 の場合、何もしない
// 余りが 0 のときは、そのままにする
return (int)pow(3, a);
}
/* ドライバーコード */
/* Driver Code */
int main() {
int n = 58;
// 貪欲アルゴリズム
// 貪欲法
int res = maxProductCutting(n);
cout << "分割の最大積は " << res << " です" << endl;
cout << "最大分割積は" << res << endl;
return 0;
}
}

6
ja/codes/cpp/chapter_hashing/CMakeLists.txt Normal file
View File

@@ -0,0 +1,6 @@
add_executable(hash_map hash_map.cpp)
add_executable(array_hash_map_test array_hash_map_test.cpp)
add_executable(hash_map_chaining hash_map_chaining.cpp)
add_executable(hash_map_open_addressing hash_map_open_addressing.cpp)
add_executable(simple_hash simple_hash.cpp)
add_executable(built_in_hash built_in_hash.cpp)

18
ja/codes/cpp/chapter_hashing/array_hash_map.cpp
View File

@@ -6,7 +6,7 @@
#include "../utils/common.hpp"
/* キー値ペア */
/* キーと値の組 */
struct Pair {
public:
int key;
@@ -17,19 +17,19 @@ struct Pair {
}
};
/* 配列実装に基づくハッシュテーブル */
/* 配列ベースのハッシュテーブル */
class ArrayHashMap {
private:
vector<Pair *> buckets;
public:
ArrayHashMap() {
// 配列を初期化、100個のバケットを含む
// 100 個のバケットを含む配列を初期化
buckets = vector<Pair *>(100);
}
~ArrayHashMap() {
// メモリを解放
// メモリを解放する
for (const auto &bucket : buckets) {
delete bucket;
}
@@ -42,7 +42,7 @@ class ArrayHashMap {
return index;
}
/* クエリ操作 */
/* 検索操作 */
string get(int key) {
int index = hashFunc(key);
Pair *pair = buckets[index];
@@ -61,12 +61,12 @@ class ArrayHashMap {
/* 削除操作 */
void remove(int key) {
int index = hashFunc(key);
// メモリを解放してnullptrに設定
// メモリを解放して nullptr に設定する
delete buckets[index];
buckets[index] = nullptr;
}
/* すべてのキー値ペアを取得 */
/* すべてのキーと値のペアを取得 */
vector<Pair *> pairSet() {
vector<Pair *> pairSet;
for (Pair *pair : buckets) {
@@ -99,7 +99,7 @@ class ArrayHashMap {
return valueSet;
}
/* ハッシュテーブルを印刷 */
/* ハッシュテーブルを出力 */
void print() {
for (Pair *kv : pairSet()) {
cout << kv->key << " -> " << kv->val << endl;
@@ -107,4 +107,4 @@ class ArrayHashMap {
}
};
// テストケースはarray_hash_map_test.cppを参照
// テストケースは `array_hash_map_test.cpp` を参照

34
ja/codes/cpp/chapter_hashing/array_hash_map_test.cpp
View File

@@ -6,47 +6,47 @@
#include "./array_hash_map.cpp"
/* ドライバーコード */
/* Driver Code */
int main() {
/* ハッシュテーブルを初期化 */
ArrayHashMap map = ArrayHashMap();
/* 追加操作 */
// キー値ペア(key, value)をハッシュテーブルに追加
map.put(12836, "Ha");
map.put(15937, "Luo");
map.put(16750, "Suan");
map.put(13276, "Fa");
map.put(10583, "Ya");
cout << "\nAfter adding, the hash table is\nKey -> Value" << endl;
// ハッシュテーブルにキーと値のペア (key, value) を追加
map.put(12836, "シャオハー");
map.put(15937, "シャオルオ");
map.put(16750, "シャオスワン");
map.put(13276, "シャオファー");
map.put(10583, "シャオヤー");
cout << "\n追加完了後、ハッシュテーブルは\nKey -> Value" << endl;
map.print();
/* クエリ操作 */
// ハッシュテーブルにキーを入力、値を取得
/* 検索操作 */
// キー key をハッシュテーブルに渡し、値 value を取得
string name = map.get(15937);
cout << "\nEnter student ID 15937, found name " << name << endl;
cout << "\n学籍番号 15937 を入力すると、氏名 " << name << endl;
/* 削除操作 */
// ハッシュテーブルからキー値ペア(key, value)を削除
// ハッシュテーブルからキーと値のペア (key, value) を削除
map.remove(10583);
cout << "\nAfter removing 10583, the hash table is\nKey -> Value" << endl;
cout << "\n10583 を削除した後、ハッシュテーブルは\nKey -> Value" << endl;
map.print();
/* ハッシュテーブルを走査 */
cout << "\nTraverse key-value pairs Key->Value" << endl;
cout << "\nキーと値のペア Key->Value を走査" << endl;
for (auto kv : map.pairSet()) {
cout << kv->key << " -> " << kv->val << endl;
}
cout << "\nIndividually traverse keys Key" << endl;
cout << "\nキー Key のみを走査" << endl;
for (auto key : map.keySet()) {
cout << key << endl;
}
cout << "\nIndividually traverse values Value" << endl;
cout << "\n値 Value のみを走査" << endl;
for (auto val : map.valueSet()) {
cout << val << endl;
}
return 0;
}
}

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

@@ -6,24 +6,24 @@
#include "../utils/common.hpp"
/* ドライバーコード */
/* Driver Code */
int main() {
int num = 3;
size_t hashNum = hash<int>()(num);
cout << "The hash value of integer " << num << " is " << hashNum << "\n";
cout << "整数 " << num << " のハッシュ値は " << hashNum << "\n";
bool bol = true;
size_t hashBol = hash<bool>()(bol);
cout << "The hash value of boolean " << bol << " is " << hashBol << "\n";
cout << "真偽値 " << bol << " のハッシュ値は " << hashBol << "\n";
double dec = 3.14159;
size_t hashDec = hash<double>()(dec);
cout << "The hash value of decimal " << dec << " is " << hashDec << "\n";
cout << "小数 " << dec << " のハッシュ値は " << hashDec << "\n";
string str = "Hello algorithm";
string str = "Hello アルゴリズム";
size_t hashStr = hash<string>()(str);
cout << "The hash value of string " << str << " is " << hashStr << "\n";
cout << "文字列 " << str << " のハッシュ値は " << hashStr << "\n";
// C++では、組み込みのstd:hash()は基本データ型のハッシュ値のみを提供
// 配列やオブジェクトのハッシュ値計算は手動で実装する必要がある
}
// C++ では、組み込みの std::hash() は基本データ型のハッシュ値計算しか提供しない
// 配列やオブジェクトのハッシュ値計算は自分で実装する必要がある
}

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

@@ -6,41 +6,41 @@
#include "../utils/common.hpp"
/* ドライバーコード */
/* Driver Code */
int main() {
/* ハッシュテーブルを初期化 */
unordered_map<int, string> map;
/* 追加操作 */
// キー値ペア(key, value)をハッシュテーブルに追加
map[12836] = "Ha";
map[15937] = "Luo";
map[16750] = "Suan";
map[13276] = "Fa";
map[10583] = "Ya";
cout << "\nAfter adding, the hash table is\nKey -> Value" << endl;
// ハッシュテーブルにキーと値のペア (key, value) を追加
map[12836] = "シャオハー";
map[15937] = "シャオルオ";
map[16750] = "シャオスワン";
map[13276] = "シャオファー";
map[10583] = "シャオヤー";
cout << "\n追加完了後、ハッシュテーブルは\nKey -> Value" << endl;
printHashMap(map);
/* クエリ操作 */
// ハッシュテーブルにキーを入力、値を取得
/* 検索操作 */
// キー key をハッシュテーブルに渡し、値 value を取得
string name = map[15937];
cout << "\nEnter student ID 15937, found name " << name << endl;
cout << "\n学籍番号 15937 を入力すると、氏名 " << name << endl;
/* 削除操作 */
// ハッシュテーブルからキー値ペア(key, value)を削除
// ハッシュテーブルからキーと値のペア (key, value) を削除
map.erase(10583);
cout << "\nAfter removing 10583, the hash table is\nKey -> Value" << endl;
cout << "\n10583 を削除した後、ハッシュテーブルは\nKey -> Value" << endl;
printHashMap(map);
/* ハッシュテーブルを走査 */
cout << "\nTraverse key-value pairs Key->Value" << endl;
cout << "\nキーと値のペア Key->Value を走査" << endl;
for (auto kv : map) {
cout << kv.first << " -> " << kv.second << endl;
}
cout << "\nIterate through Key->Value using an iterator" << endl;
cout << "\nイテレータで Key->Value を走査" << endl;
for (auto iter = map.begin(); iter != map.end(); iter++) {
cout << iter->first << "->" << iter->second << endl;
}
return 0;
}
}

64
ja/codes/cpp/chapter_hashing/hash_map_chaining.cpp
View File

@@ -9,9 +9,9 @@
/* チェイン法ハッシュテーブル */
class HashMapChaining {
private:
int size; // キー値ペアの数
int capacity; // ハッシュテーブルの容量
double loadThres; // 拡張をトリガーする負荷率の閾値
int size; // キーと値のペア数
int capacity; // ハッシュテーブル容量
double loadThres; // リサイズを発動する負荷率のしきい値
int extendRatio; // 拡張倍率
vector<vector<Pair *>> buckets; // バケット配列
@@ -21,11 +21,11 @@ class HashMapChaining {
buckets.resize(capacity);
}
/* デストラクタ */
/* デストラクタメソッド */
~HashMapChaining() {
for (auto &bucket : buckets) {
for (Pair *pair : bucket) {
// メモリを解放
// メモリを解放する
delete pair;
}
}
@@ -41,34 +41,34 @@ class HashMapChaining {
return (double)size / (double)capacity;
}
/* クエリ操作 */
/* 検索操作 */
string get(int key) {
int index = hashFunc(key);
// バケットを走査、キーが見つかった場合、対応するvalを返却
// バケットを走査し、key が見つかれば対応する val を返す
for (Pair *pair : buckets[index]) {
if (pair->key == key) {
return pair->val;
}
}
// キーが見つからない場合、空文字列を返却
// key が見つからない場合は空文字列を返す
return "";
}
/* 追加操作 */
void put(int key, string val) {
// 負荷率が閾値を超えた場合、拡張を実行
// 負荷率がしきい値を超えたら、リサイズを実行
if (loadFactor() > loadThres) {
extend();
}
int index = hashFunc(key);
// バケットを走査、指定キーに遭遇した場合、対応するvalを更新して返却
// バケットを走査し、指定した key が見つかれば対応する val を更新して返す
for (Pair *pair : buckets[index]) {
if (pair->key == key) {
pair->val = val;
return;
}
}
// キーが見つからない場合、キー値ペアを末尾に追加
// その key が存在しなければ、キーと値のペアを末尾に追加
buckets[index].push_back(new Pair(key, val));
size++;
}
@@ -77,12 +77,12 @@ class HashMapChaining {
void remove(int key) {
int index = hashFunc(key);
auto &bucket = buckets[index];
// バケットを走査、キー値ペアを削除
// バケットを走査してキーと値のペアを削除
for (int i = 0; i < bucket.size(); i++) {
if (bucket[i]->key == key) {
Pair *tmp = bucket[i];
bucket.erase(bucket.begin() + i); // キー値ペアを削除
delete tmp; // メモリを解放
bucket.erase(bucket.begin() + i); // そこからキーと値の組を削除する
delete tmp; // メモリを解放する
size--;
return;
}
@@ -93,22 +93,22 @@ class HashMapChaining {
void extend() {
// 元のハッシュテーブルを一時保存
vector<vector<Pair *>> bucketsTmp = buckets;
// 拡張された新しいハッシュテーブルを初期化
// リサイズ後の新しいハッシュテーブルを初期化
capacity *= extendRatio;
buckets.clear();
buckets.resize(capacity);
size = 0;
// 元のハッシュテーブルから新しいハッシュテーブルにキー値ペアを移動
// キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す
for (auto &bucket : bucketsTmp) {
for (Pair *pair : bucket) {
put(pair->key, pair->val);
// メモリを解放
// メモリを解放する
delete pair;
}
}
}
/* ハッシュテーブルを印刷 */
/* ハッシュテーブルを出力 */
void print() {
for (auto &bucket : buckets) {
cout << "[";
@@ -120,31 +120,31 @@ class HashMapChaining {
}
};
/* ドライバーコード */
/* Driver Code */
int main() {
/* ハッシュテーブルを初期化 */
HashMapChaining map = HashMapChaining();
/* 追加操作 */
// キー値ペア(key, value)をハッシュテーブルに追加
map.put(12836, "Ha");
map.put(15937, "Luo");
map.put(16750, "Suan");
map.put(13276, "Fa");
map.put(10583, "Ya");
cout << "\nAfter adding, the hash table is\nKey -> Value" << endl;
// ハッシュテーブルにキーと値のペア (key, value) を追加
map.put(12836, "シャオハー");
map.put(15937, "シャオルオ");
map.put(16750, "シャオスワン");
map.put(13276, "シャオファー");
map.put(10583, "シャオヤー");
cout << "\n追加完了後、ハッシュテーブルは\nKey -> Value" << endl;
map.print();
/* クエリ操作 */
// ハッシュテーブルにキーを入力、値を取得
/* 検索操作 */
// キー key をハッシュテーブルに渡し、値 value を取得
string name = map.get(13276);
cout << "\nEnter student ID 13276, found name " << name << endl;
cout << "\n学籍番号 13276 を入力すると、氏名 " << name << endl;
/* 削除操作 */
// ハッシュテーブルからキー値ペア(key, value)を削除
// ハッシュテーブルからキーと値のペア (key, value) を削除
map.remove(12836);
cout << "\nAfter removing 12836, the hash table is\nKey -> Value" << endl;
cout << "\n12836 を削除した後、ハッシュテーブルは\nKey -> Value" << endl;
map.print();
return 0;
}
}

82
ja/codes/cpp/chapter_hashing/hash_map_open_addressing.cpp
View File

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

16
ja/codes/cpp/chapter_hashing/simple_hash.cpp
View File

@@ -26,7 +26,7 @@ int mulHash(string key) {
return (int)hash;
}
/* XORハッシュ */
/* XOR ハッシュ */
int xorHash(string key) {
int hash = 0;
const int MODULUS = 1000000007;
@@ -46,21 +46,21 @@ int rotHash(string key) {
return (int)hash;
}
/* ドライバーコード */
/* Driver Code */
int main() {
string key = "Hello algorithm";
string key = "Hello アルゴリズム";
int hash = addHash(key);
cout << "Additive hash value is " << hash << endl;
cout << "加算ハッシュ値は " << hash << endl;
hash = mulHash(key);
cout << "Multiplicative hash value is " << hash << endl;
cout << "乗算ハッシュ値は " << hash << endl;
hash = xorHash(key);
cout << "XOR hash value is " << hash << endl;
cout << "XORハッシュ値は " << hash << endl;
hash = rotHash(key);
cout << "Rotational hash value is " << hash << endl;
cout << "回転ハッシュ値は " << hash << endl;
return 0;
}
}

3
ja/codes/cpp/chapter_heap/CMakeLists.txt Normal file
View File

@@ -0,0 +1,3 @@
add_executable(heap heap.cpp)
add_executable(my_heap my_heap.cpp)
add_executable(top_k top_k.cpp)

34
ja/codes/cpp/chapter_heap/heap.cpp
View File

@@ -7,40 +7,40 @@
#include "../utils/common.hpp"
void testPush(priority_queue<int> &heap, int val) {
heap.push(val); // 要素をヒープにプッシュ
cout << "\n要素 " << val << " をヒープに追加後" << endl;
heap.push(val); // 要素をヒープに追加
cout << "\n要素 " << val << " をヒープに追加した後" << endl;
printHeap(heap);
}
void testPop(priority_queue<int> &heap) {
int val = heap.top();
heap.pop();
cout << "\nヒープから先頭要素 " << val << " を削除後" << endl;
cout << "\nヒープ先頭要素 " << val << " を取り出した後" << endl;
printHeap(heap);
}
/* ドライバーコード */
/* Driver Code */
int main() {
/* ヒープを初期化 */
// 最小ヒープを初期化
// 最小ヒープを初期化する
// priority_queue<int, vector<int>, greater<int>> minHeap;
// 最大ヒープを初期化
// 最大ヒープを初期化する
priority_queue<int, vector<int>, less<int>> maxHeap;
cout << "\n以下のテストケースは最大ヒープ用です" << endl;
cout << "\n以下のテスト例は最大ヒープです" << endl;
/* ヒープに要素をプッシュ */
/* 要素をヒープに追加 */
testPush(maxHeap, 1);
testPush(maxHeap, 3);
testPush(maxHeap, 2);
testPush(maxHeap, 5);
testPush(maxHeap, 4);
/* ヒープの先頭要素にアクセス */
/* ヒープ頂点の要素を取得 */
int peek = maxHeap.top();
cout << "\nヒープの先頭要素は " << peek << endl;
cout << "\nヒープ先頭要素は " << peek << endl;
/* ヒープ先頭の要素をポップ */
/* ヒープ頂点の要素を取り出す */
testPop(maxHeap);
testPop(maxHeap);
testPop(maxHeap);
@@ -49,18 +49,18 @@ int main() {
/* ヒープのサイズを取得 */
int size = maxHeap.size();
cout << "\nヒープ内の要素数は " << size << endl;
cout << "\nヒープ要素数は " << size << endl;
/* ヒープが空かどうか判定 */
/* ヒープが空かどうかを判定 */
bool isEmpty = maxHeap.empty();
cout << "\nヒープが空かどうか " << isEmpty << endl;
cout << "\nヒープが空かどうかは " << isEmpty << endl;
/* リストを入力してヒープを構築 */
// 時間計算量はO(n)、O(nlogn)ではない
// 時間計算量は O(n) であり、O(nlogn) ではない
vector<int> input{1, 3, 2, 5, 4};
priority_queue<int, vector<int>, greater<int>> minHeap(input.begin(), input.end());
cout << "リストを入力して最小ヒープを構築後" << endl;
cout << "リストを入力して最小ヒープを構築した後" << endl;
printHeap(minHeap);
return 0;
}
}

76
ja/codes/cpp/chapter_heap/my_heap.cpp
View File

@@ -9,63 +9,63 @@
/* 最大ヒープ */
class MaxHeap {
private:
// 動的配列を使用してサイズ変更の必要性を回避
// 動的配列を使うことで、拡張を考慮せずに済む
vector<int> maxHeap;
/* 左の子ノードのインデックスを取得 */
/* 左子ノードのインデックスを取得 */
int left(int i) {
return 2 * i + 1;
}
/* 右の子ノードのインデックスを取得 */
/* 右子ノードのインデックスを取得 */
int right(int i) {
return 2 * i + 2;
}
/* 親ノードのインデックスを取得 */
int parent(int i) {
return (i - 1) / 2; // 整数除算で切り下げ
return (i - 1) / 2; // 切り捨て除算
}
/* ノードiから上向きにヒープ化を開始 */
/* ノード i から始めて、下から上へヒープ化 */
void siftUp(int i) {
while (true) {
// ノードiの親ノードを取得
// ノード i の親ノードを取得
int p = parent(i);
// 「ルートノードを超える」または「ノードが修復不要」の場合、ヒープ化を終了
// 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了
if (p < 0 || maxHeap[i] <= maxHeap[p])
break;
// 2つのノードを交換
// 2 つのノードを交換
swap(maxHeap[i], maxHeap[p]);
// 上向きにループしてヒープ化
// ループで下から上へヒープ化
i = p;
}
}
/* ノードiから下向きにヒープ化を開始 */
/* ノード i から始めて、上から下へヒープ化 */
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[l] > maxHeap[ma])
ma = l;
if (r < size() && maxHeap[r] > maxHeap[ma])
ma = r;
// ノードiが最大、またはインデックスl、rが範囲外の場合、これ以上のヒープ化は不要、ブレーク
// ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける
if (ma == i)
break;
swap(maxHeap[i], maxHeap[ma]);
// 下向きにループしてヒープ化
// ループで上から下へヒープ化
i = ma;
}
}
public:
/* コンストラクタ、入力リストに基づいてヒープを構築 */
/* コンストラクタ。入力リストに基づいてヒープを構築する */
MaxHeap(vector<int> nums) {
// すべてのリスト要素をヒープに追加
// リスト要素をそのままヒープに追加
maxHeap = nums;
// 葉以外のすべてのノードをヒープ化
// 葉ノード以外のすべてのノードをヒープ化
for (int i = parent(size() - 1); i >= 0; i--) {
siftDown(i);
}
@@ -76,17 +76,17 @@ class MaxHeap {
return maxHeap.size();
}
/* ヒープが空かどうか判定 */
/* ヒープが空かどうかを判定 */
bool isEmpty() {
return size() == 0;
}
/* ヒープの先頭要素にアクセス */
/* ヒープ先頭要素にアクセス */
int peek() {
return maxHeap[0];
}
/* ヒープに要素をプッシュ */
/* 要素をヒープに追加 */
void push(int val) {
// ノードを追加
maxHeap.push_back(val);
@@ -94,13 +94,13 @@ class MaxHeap {
siftUp(size() - 1);
}
/* 要素がヒープから退出 */
/* 要素をヒープから取り出す */
void pop() {
// 空の処理
// 空判定の処理
if (isEmpty()) {
throw out_of_range("Heap is empty");
throw out_of_range("ヒープが空です");
}
// ルートノードを最も右の葉ノードと交換（最初の要素と最後の要素を交換）
// 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）
swap(maxHeap[0], maxHeap[size() - 1]);
// ノードを削除
maxHeap.pop_back();
@@ -108,48 +108,48 @@ class MaxHeap {
siftDown(0);
}
/* ヒープを印刷（二分木）*/
/* ヒープ（二分木）を出力 */
void print() {
cout << "ヒープの配列表現:";
cout << "ヒープの配列表現：";
printVector(maxHeap);
cout << "ヒープの木表現:" << endl;
cout << "ヒープの木構造表現：" << endl;
TreeNode *root = vectorToTree(maxHeap);
printTree(root);
freeMemoryTree(root);
}
};
/* ドライバーコード */
/* Driver Code */
int main() {
/* 最大ヒープを初期化 */
vector<int> vec{9, 8, 6, 6, 7, 5, 2, 1, 4, 3, 6, 2};
MaxHeap maxHeap(vec);
cout << "\nリストを入力してヒープを構築" << endl;
cout << "\nリストを入力してヒープを構築した後" << endl;
maxHeap.print();
/* ヒープの先頭要素にアクセス */
/* ヒープ頂点の要素を取得 */
int peek = maxHeap.peek();
cout << "\nヒープの先頭要素は " << peek << endl;
cout << "\nヒープ先頭要素は " << peek << endl;
/* ヒープに要素をプッシュ */
/* 要素をヒープに追加 */
int val = 7;
maxHeap.push(val);
cout << "\n要素 " << val << " をヒープに追加後" << endl;
cout << "\n要素 " << val << " をヒープに追加した後" << endl;
maxHeap.print();
/* ヒープ先頭の要素をポップ */
/* ヒープ頂点の要素を取り出す */
peek = maxHeap.peek();
maxHeap.pop();
cout << "\nヒープから先頭要素 " << peek << " を削除後" << endl;
cout << "\nヒープの先頭要素 " << peek << " を取り出した後" << endl;
maxHeap.print();
/* ヒープのサイズを取得 */
int size = maxHeap.size();
cout << "\nヒープ内の要素数は " << size << endl;
cout << "\nヒープ要素数は " << size << endl;
/* ヒープが空かどうか判定 */
/* ヒープが空かどうかを判定 */
bool isEmpty = maxHeap.isEmpty();
cout << "\nヒープが空かどうか " << isEmpty << endl;
cout << "\nヒープが空かどうかは " << isEmpty << endl;
return 0;
}
}

14
ja/codes/cpp/chapter_heap/top_k.cpp
View File

@@ -6,17 +6,17 @@
#include "../utils/common.hpp"
/* ヒープを使用して配列内の最大k個の要素を見つける */
/* ヒープに基づいて配列中の最大の k 個の要素を探す */
priority_queue<int, vector<int>, greater<int>> topKHeap(vector<int> &nums, int k) {
// 最小ヒープを初期化
priority_queue<int, vector<int>, greater<int>> heap;
// 配列の最初のk個の要素をヒープに入力
// 配列の先頭 k 個の要素をヒープに追加
for (int i = 0; i < k; i++) {
heap.push(nums[i]);
}
// k+1番目の要素から、ヒープの長さをkに保つ
// k+1 番目の要素から開始し、ヒープ長を k に保つ
for (int i = k; i < nums.size(); i++) {
// 現在の要素がヒープの先頭要素より大きい場合、ヒープの先頭要素を削除し、現在の要素をヒープに入力
// 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する
if (nums[i] > heap.top()) {
heap.pop();
heap.push(nums[i]);
@@ -25,14 +25,14 @@ priority_queue<int, vector<int>, greater<int>> topKHeap(vector<int> &nums, int k
return heap;
}
// ドライバーコード
// Driver Code
int main() {
vector<int> nums = {1, 7, 6, 3, 2};
int k = 3;
priority_queue<int, vector<int>, greater<int>> res = topKHeap(nums, k);
cout << "最大 " << k << " 個の要素は:";
cout << "最大の " << k << " 個の要素は: ";
printHeap(res);
return 0;
}
}

4
ja/codes/cpp/chapter_searching/CMakeLists.txt Normal file
View File

@@ -0,0 +1,4 @@
add_executable(binary_search binary_search.cpp)
add_executable(binary_search_insertion binary_search_insertion.cpp)
add_executable(binary_search_edge binary_search_edge.cpp)
add_executable(two_sum two_sum.cpp)

40
ja/codes/cpp/chapter_searching/binary_search.cpp
View File

@@ -6,54 +6,54 @@
#include "../utils/common.hpp"
/* 二分探索（両端閉区間） */
/* 二分探索（両閉区間） */
int binarySearch(vector<int> &nums, int target) {
// 両端閉区間[0, n-1]を初期化、すなわちi、jはそれぞれ配列の最初の要素と最後の要素を指す
// 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す
int i = 0, j = nums.size() - 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;
}
/* 二分探索（左閉右開区間） */
int binarySearchLCRO(vector<int> &nums, int target) {
// 左閉右開区間[0, n)を初期化、すなわちi、jはそれぞれ配列の最初の要素と最後の要素+1を指す
// 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す
int i = 0, j = nums.size();
// 探索区間が空になるまでループ（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;
}
/* ドライバコード */
/* Driver Code */
int main() {
int target = 6;
vector<int> nums = {1, 3, 6, 8, 12, 15, 23, 26, 31, 35};
/* 二分探索（両端閉区間） */
/* 二分探索（両閉区間） */
int index = binarySearch(nums, target);
cout << "ターゲット要素6のインデックス =" << index << endl;
cout << "対象要素 6 のインデックス = " << index << endl;
/* 二分探索（左閉右開区間） */
index = binarySearchLCRO(nums, target);
cout << "ターゲット要素6のインデックス =" << index << endl;
cout << "対象要素 6 のインデックス = " << index << endl;
return 0;
}
}

40
ja/codes/cpp/chapter_searching/binary_search_edge.cpp
View File

@@ -6,61 +6,61 @@
#include "../utils/common.hpp"
/* 挿入ポイントの二分探索（重複要素あり） */
/* 二分探索で挿入位置を探す（重複要素あり） */
int binarySearchInsertion(const vector<int> &nums, int target) {
int i = 0, j = nums.size() - 1; // 両端閉区間[0, n-1]を初期化
int i = 0, j = nums.size() - 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; // ターゲットは区間[m+1, j]にある
i = m + 1; // target は区間 [m+1, j] にある
} else {
j = m - 1; // ターゲット未満の最初の要素は区間[i, m-1]にある
j = m - 1; // target より小さい最初の要素は区間 [i, m-1] にある
}
}
// 挿入ポイントiを返す
// 挿入位置 i を返す
return i;
}
/* 最左のターゲットの二分探索 */
/* 最も左の target を二分探索 */
int binarySearchLeftEdge(vector<int> &nums, int target) {
// targetの挿入ポイントを見つけることと等価
// target の挿入位置を探すのと等価
int i = binarySearchInsertion(nums, target);
// targetが見つからなかったため、-1を返す
// target が見つからなければ、-1 を返す
if (i == nums.size() || nums[i] != target) {
return -1;
}
// targetが見つかったため、インデックスiを返す
// target が見つかったら、インデックス i を返す
return i;
}
/* 最右のターゲットの二分探索 */
/* 最も右の target を二分探索 */
int binarySearchRightEdge(vector<int> &nums, int target) {
// 最左のtarget + 1を見つけることに変換
// 最左の target + 1 を探す問題に変換する
int i = binarySearchInsertion(nums, target + 1);
// jは最右のターゲットを指し、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;
}
/* ドライバコード */
/* Driver Code */
int main() {
// 重複要素を含む配列
vector<int> nums = {1, 3, 6, 6, 6, 6, 6, 10, 12, 15};
cout << "\n配列 nums = ";
printVector(nums);
// 左右の境界の二分探索
// 二分探索で左端と右端を探す
for (int target : {6, 7}) {
int index = binarySearchLeftEdge(nums, target);
cout << "要素 " << target << " の最左インデックスは " << index << " です" << endl;
cout << "一番左の要素 " << target << " のインデックスは " << index << endl;
index = binarySearchRightEdge(nums, target);
cout << "要素 " << target << " の最右インデックスは " << index << " です" << endl;
cout << "一番右の要素 " << target << " のインデックスは " << index << endl;
}
return 0;
}
}

40
ja/codes/cpp/chapter_searching/binary_search_insertion.cpp
View File

@@ -6,61 +6,61 @@
#include "../utils/common.hpp"
/* 挿入ポイントの二分探索（重複要素なし） */
/* 二分探索で挿入位置を探す（重複要素なし） */
int binarySearchInsertionSimple(vector<int> &nums, int target) {
int i = 0, j = nums.size() - 1; // 両端閉区間[0, n-1]を初期化
int i = 0, j = nums.size() - 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; // ターゲットは区間[m+1, j]にある
i = m + 1; // target は区間 [m+1, j] にある
} else if (nums[m] > target) {
j = m - 1; // ターゲットは区間[i, m-1]にある
j = m - 1; // target は区間 [i, m-1] にある
} else {
return m; // ターゲットが見つかったため、挿入ポイントmを返す
return m; // target が見つかったら、挿入位置 m を返す
}
}
// ターゲットが見つからなかったため、挿入ポイントiを返す
// target が見つからなければ、挿入位置 i を返す
return i;
}
/* 挿入ポイントの二分探索（重複要素あり） */
/* 二分探索で挿入位置を探す（重複要素あり） */
int binarySearchInsertion(vector<int> &nums, int target) {
int i = 0, j = nums.size() - 1; // 両端閉区間[0, n-1]を初期化
int i = 0, j = nums.size() - 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; // ターゲットは区間[m+1, j]にある
i = m + 1; // target は区間 [m+1, j] にある
} else if (nums[m] > target) {
j = m - 1; // ターゲットは区間[i, m-1]にある
j = m - 1; // target は区間 [i, m-1] にある
} else {
j = m - 1; // ターゲット未満の最初の要素は区間[i, m-1]にある
j = m - 1; // target より小さい最初の要素は区間 [i, m-1] にある
}
}
// 挿入ポイントiを返す
// 挿入位置 i を返す
return i;
}
/* ドライバコード */
/* Driver Code */
int main() {
// 重複要素のない配列
vector<int> nums = {1, 3, 6, 8, 12, 15, 23, 26, 31, 35};
cout << "\n配列 nums = ";
printVector(nums);
// 挿入ポイントの二分探索
// 二分探索で挿入位置を探す
for (int target : {6, 9}) {
int index = binarySearchInsertionSimple(nums, target);
cout << "要素 " << target << " の挿入ポイントインデックスは " << index << " です" << endl;
cout << "要素 " << target << " の挿入位置のインデックスは " << index << endl;
}
// 重複要素を含む配列
nums = {1, 3, 6, 6, 6, 6, 6, 10, 12, 15};
cout << "\n配列 nums = ";
printVector(nums);
// 挿入ポイントの二分探索
// 二分探索で挿入位置を探す
for (int target : {2, 6, 20}) {
int index = binarySearchInsertion(nums, target);
cout << "要素 " << target << " の挿入ポイントインデックスは " << index << " です" << endl;
cout << "要素 " << target << " の挿入位置のインデックスは " << index << endl;
}
return 0;
}
}

20
ja/codes/cpp/chapter_searching/hashing_search.cpp
View File

@@ -8,8 +8,8 @@
/* ハッシュ探索（配列） */
int hashingSearchArray(unordered_map<int, int> map, int target) {
// ハッシュテーブルのキー：ターゲット要素、値：インデックス
// ハッシュテーブルにこのキーが含まれていない場合、-1を返す
// ハッシュテーブルの key: 目標要素、value: インデックス
// ハッシュテーブルにこの key がなければ -1 を返す
if (map.find(target) == map.end())
return -1;
return map[target];
@@ -17,14 +17,14 @@ int hashingSearchArray(unordered_map<int, int> map, int target) {
/* ハッシュ探索（連結リスト） */
ListNode *hashingSearchLinkedList(unordered_map<int, ListNode *> map, int target) {
// ハッシュテーブルのキー：ターゲットノード値、値：ノードオブジェクト
// キーがハッシュテーブルにない場合、nullptrを返す
// ハッシュテーブルの key: 対象ノードの値、value: ノードオブジェクト
// ハッシュテーブルにその key がなければ nullptr を返す
if (map.find(target) == map.end())
return nullptr;
return map[target];
}
/* ドライバコード */
/* Driver Code */
int main() {
int target = 3;
@@ -33,21 +33,21 @@ int main() {
// ハッシュテーブルを初期化
unordered_map<int, int> map;
for (int i = 0; i < nums.size(); i++) {
map[nums[i]] = i; // キー：要素、値：インデックス
map[nums[i]] = i; // key: 要素、value: インデックス
}
int index = hashingSearchArray(map, target);
cout << "ターゲット要素3のインデックスは " << index << " です" << endl;
cout << "対象要素 3 のインデックス = " << index << endl;
/* ハッシュ探索（連結リスト） */
ListNode *head = vecToLinkedList(nums);
// ハッシュテーブルを初期化
unordered_map<int, ListNode *> map1;
while (head != nullptr) {
map1[head->val] = head; // キー：ノード値、値：ノード
map1[head->val] = head; // key: ノード値、value: ノード
head = head->next;
}
ListNode *node = hashingSearchLinkedList(map1, target);
cout << "ターゲットノード値3に対応するノードオブジェクトは " << node << " です" << endl;
cout << "対象ノード値 3 に対応するノードオブジェクトは " << node << endl;
return 0;
}
}

22
ja/codes/cpp/chapter_searching/linear_search.cpp
View File

@@ -10,40 +10,40 @@
int linearSearchArray(vector<int> &nums, int target) {
// 配列を走査
for (int i = 0; i < nums.size(); i++) {
// ターゲット要素が見つかったため、そのインデックスを返す
// 目標要素が見つかったらそのインデックスを返す
if (nums[i] == target)
return i;
}
// ターゲット要素が見つからなかったため、-1を返す
// 目標要素が見つからなければ -1 を返す
return -1;
}
/* 線形探索（連結リスト） */
ListNode *linearSearchLinkedList(ListNode *head, int target) {
// リストを走査
// 連結リストを走査
while (head != nullptr) {
// ターゲットノードが見つかった場合、それを返す
// 対象ノードが見つかったら、それを返す
if (head->val == target)
return head;
head = head->next;
}
// ターゲットノードが見つからない場合、nullptrを返す
// 対象ノードが見つからない場合は `nullptr` を返す
return nullptr;
}
/* ドライバコード */
/* Driver Code */
int main() {
int target = 3;
/* 配列で線形探索を実行 */
/* 配列で線形探索を行う */
vector<int> nums = {1, 5, 3, 2, 4, 7, 5, 9, 10, 8};
int index = linearSearchArray(nums, target);
cout << "ターゲット要素3のインデックスは " << index << " です" << endl;
cout << "対象要素 3 のインデックス = " << index << endl;
/* 連結リストで線形探索を実行 */
/* 連結リストで線形探索を行う */
ListNode *head = vecToLinkedList(nums);
ListNode *node = linearSearchLinkedList(head, target);
cout << "ターゲットノード値3に対応するノードオブジェクトは " << node << " です" << endl;
cout << "対象ノード値 3 に対応するノードオブジェクトは " << node << endl;
return 0;
}
}

26
ja/codes/cpp/chapter_searching/two_sum.cpp
View File

@@ -6,10 +6,10 @@
#include "../utils/common.hpp"
/* 方法一：ブルートフォース列挙 */
/* 方法 1：総当たり列挙 */
vector<int> twoSumBruteForce(vector<int> &nums, int target) {
int size = nums.size();
// 二重ループ、時間計算量はO(n^2)
// 2重ループのため、時間計算量は O(n^2)
for (int i = 0; i < size - 1; i++) {
for (int j = i + 1; j < size; j++) {
if (nums[i] + nums[j] == target)
@@ -19,12 +19,12 @@ vector<int> twoSumBruteForce(vector<int> &nums, int target) {
return {};
}
/* 方法二：補助ハッシュテーブル */
/* 方法 2：補助ハッシュテーブル */
vector<int> twoSumHashTable(vector<int> &nums, int target) {
int size = nums.size();
// 補助ハッシュテーブル、空間計算量はO(n)
// 補助ハッシュテーブルを使用し、空間計算量は O(n)
unordered_map<int, int> dic;
// 単層ループ、時間計算量はO(n)
// 単一ループで、時間計算量は O(n)
for (int i = 0; i < size; i++) {
if (dic.find(target - nums[i]) != dic.end()) {
return {dic[target - nums[i]], i};
@@ -34,21 +34,21 @@ vector<int> twoSumHashTable(vector<int> &nums, int target) {
return {};
}
/* ドライバコード */
/* Driver Code */
int main() {
// ======= テストケース =======
// ======= Test Case =======
vector<int> nums = {2, 7, 11, 15};
int target = 13;
// ====== ドライバコード ======
// 方法一
// ====== Driver Code ======
// 方法 1
vector<int> res = twoSumBruteForce(nums, target);
cout << "方法一 res = ";
cout << "方法1 res = ";
printVector(res);
// 方法二
// 方法 2
res = twoSumHashTable(nums, target);
cout << "方法二 res = ";
cout << "方法2 res = ";
printVector(res);
return 0;
}
}

6
ja/codes/cpp/chapter_sorting/CMakeLists.txt Normal file
View File

@@ -0,0 +1,6 @@
add_executable(selection_sort selection_sort.cpp)
add_executable(bubble_sort bubble_sort.cpp)
add_executable(insertion_sort insertion_sort.cpp)
add_executable(merge_sort merge_sort.cpp)
add_executable(quick_sort quick_sort.cpp)
add_executable(heap_sort heap_sort.cpp)

32
ja/codes/cpp/chapter_sorting/bubble_sort.cpp
View File

@@ -8,49 +8,49 @@
/* バブルソート */
void bubbleSort(vector<int> &nums) {
// 外側ループ：未ソート範囲は[0, i]
// 外側のループ：未ソート区間は [0, i]
for (int i = nums.size() - 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]を交換
// ここではstdのswapを使用
// nums[j] と nums[j + 1] を交換する
// ここでは std::swap() 関数を使用する
swap(nums[j], nums[j + 1]);
}
}
}
}
/* バブルソート（フラグ最適化版）*/
/* バブルソート（フラグ最適化） */
void bubbleSortWithFlag(vector<int> &nums) {
// 外側ループ：未ソート範囲は[0, i]
// 外側のループ：未ソート区間は [0, i]
for (int i = nums.size() - 1; i > 0; i--) {
bool flag = false; // フラグを初期化
// 内側ループ：未ソート範囲[0, i]内の最大要素を範囲の右端に交換
bool flag = false; // フラグを初期化する
// 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換
for (int j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// nums[j]とnums[j + 1]を交換
// ここではstdのswapを使用
// nums[j] と nums[j + 1] を交換する
// ここでは std::swap() 関数を使用する
swap(nums[j], nums[j + 1]);
flag = true; // 交換された要素を記録
flag = true; // 交換する要素を記録
}
}
if (!flag)
break; // この回の「バブリング」で要素が交換されなかった場合、終了
break; // このバブル処理で要素交換が一度もなければそのまま終了
}
}
/* ドライバコード */
/* Driver Code */
int main() {
vector<int> nums = {4, 1, 3, 1, 5, 2};
bubbleSort(nums);
cout << "バブルソート後、nums = ";
cout << "バブルソート完了後 nums = ";
printVector(nums);
vector<int> nums1 = {4, 1, 3, 1, 5, 2};
bubbleSortWithFlag(nums1);
cout << "バブルソート後、nums1 = ";
cout << "バブルソート完了後 nums1 = ";
printVector(nums1);
return 0;
}
}

22
ja/codes/cpp/chapter_sorting/bucket_sort.cpp
View File

@@ -8,22 +8,22 @@
/* バケットソート */
void bucketSort(vector<float> &nums) {
// k = n/2個のバケットを初期化、各バケットに2つの要素を割り当てることを期待
// k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする
int k = nums.size() / 2;
vector<vector<float>> buckets(k);
// 1. 配列要素を各バケットに分配
// 1. 配列要素を各バケットに振り分ける
for (float num : nums) {
// 入力データ範囲は[0, 1)、num * kを使用してインデックス範囲[0, k-1]にマップ
// 入力データの範囲は [0, 1) であり、num * k を用いてインデックス範囲 [0, k-1] に写像する
int i = num * k;
// bucket_idxバケットに数値を追加
// num をバケット bucket_idx に追加
buckets[i].push_back(num);
}
// 2. 各バケットをソート
// 2. 各バケットをソートする
for (vector<float> &bucket : buckets) {
// 組み込みソート関数を使用、他のソートアルゴリズムに置き換えることも可能
// 組み込みのソート関数を使う。他のソートアルゴリズムに置き換えてもよい
sort(bucket.begin(), bucket.end());
}
// 3. バケットを走査して結果をマージ
// 3. バケットを走査して結果を結合
int i = 0;
for (vector<float> &bucket : buckets) {
for (float num : bucket) {
@@ -32,13 +32,13 @@ void bucketSort(vector<float> &nums) {
}
}
/* ドライバコード */
/* Driver Code */
int main() {
// 入力データが浮動小数点数、範囲[0, 1)と仮定
// 入力データは範囲 [0, 1) の浮動小数点数とする
vector<float> nums = {0.49f, 0.96f, 0.82f, 0.09f, 0.57f, 0.43f, 0.91f, 0.75f, 0.15f, 0.37f};
bucketSort(nums);
cout << "バケットソート後、nums = ";
cout << "バケットソート完了後 nums = ";
printVector(nums);
return 0;
}
}

44
ja/codes/cpp/chapter_sorting/counting_sort.cpp
View File

@@ -6,21 +6,21 @@
#include "../utils/common.hpp"
/* カウントソート */
// 簡単な実装、オブジェクトのソートには使用できない
/* 計数ソート */
// 簡易実装のため、オブジェクトのソートには使えない
void countingSortNaive(vector<int> &nums) {
// 1. 配列の最大要素mを統計
// 1. 配列の最大要素 m を求める
int m = 0;
for (int num : nums) {
m = max(m, num);
}
// 2. 各数字の出現回数を統計
// counter[num]はnumの出現回数を表す
// 2. 各数値の出現回数を数える
// counter[num] は num の出現回数を表す
vector<int> counter(m + 1, 0);
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++) {
@@ -29,49 +29,49 @@ void countingSortNaive(vector<int> &nums) {
}
}
/* カウントソート */
// 完全な実装、オブジェクトのソートが可能で安定ソート
/* 計数ソート */
// 完全な実装で、オブジェクトをソートでき、かつ安定ソートである
void countingSort(vector<int> &nums) {
// 1. 配列の最大要素mを統計
// 1. 配列の最大要素 m を求める
int m = 0;
for (int num : nums) {
m = max(m, num);
}
// 2. 各数字の出現回数を統計
// counter[num]はnumの出現回数を表す
// 2. 各数値の出現回数を数える
// counter[num] は num の出現回数を表す
vector<int> counter(m + 1, 0);
for (int num : nums) {
counter[num]++;
}
// 3. counterの前缀和を計算し、「出現回数」を「末尾インデックス」に変換
// counter[num]-1はnumがresで現れる最後のインデックス
// 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する
// つまり counter[num]-1 は、num が res に最後に現れるインデックス
for (int i = 0; i < m; i++) {
counter[i + 1] += counter[i];
}
// 4. numsを逆順で走査し、各要素を結果配列resに配置
// 結果を記録する配列resを初期化
// 4. nums を逆順に走査し、各要素を結果配列 res に格納する
// 結果を記録するための配列 res を初期化
int n = nums.size();
vector<int> res(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を上書き
// 結果配列 res で元の配列 nums を上書きする
nums = res;
}
/* ドライバコード */
/* Driver Code */
int main() {
vector<int> nums = {1, 0, 1, 2, 0, 4, 0, 2, 2, 4};
countingSortNaive(nums);
cout << "カウントソート（オブジェクトソート不可）後、nums = ";
cout << "カウントソート（オブジェクトはソートできない）完了後 nums = ";
printVector(nums);
vector<int> nums1 = {1, 0, 1, 2, 0, 4, 0, 2, 2, 4};
countingSort(nums1);
cout << "カウントソート後、nums1 = ";
cout << "カウントソート完了後 nums1 = ";
printVector(nums1);
return 0;
}
}

24
ja/codes/cpp/chapter_sorting/heap_sort.cpp
View File

@@ -6,10 +6,10 @@
#include "../utils/common.hpp"
/* ヒープの長さはn、ノードiから上から下へヒープ化を開始 */
/* ヒープの長さは n。ノード i から下方向にヒープ化 */
void siftDown(vector<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;
@@ -17,38 +17,38 @@ void siftDown(vector<int> &nums, int n, int i) {
ma = l;
if (r < n && nums[r] > nums[ma])
ma = r;
// ノードiが最大か、インデックスl、rが境界外の場合、それ以上のヒープ化は不要で終了
// ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける
if (ma == i) {
break;
}
// 二つのノードを交換
// 2 つのノードを交換
swap(nums[i], nums[ma]);
// 下向きにヒープ化をループ
// ループで上から下へヒープ化
i = ma;
}
}
/* ヒープソート */
void heapSort(vector<int> &nums) {
// ヒープ構築操作：葉以外のすべてのノードをヒープ化
// ヒープ構築：葉ノード以外のすべてのノードをヒープ化する
for (int i = nums.size() / 2 - 1; i >= 0; --i) {
siftDown(nums, nums.size(), i);
}
// ヒープから最大要素を抽出し、n-1回繰り返す
// ヒープから最大要素を取り出し、n-1 回繰り返す
for (int i = nums.size() - 1; i > 0; --i) {
// ルートノードを最右葉ノードと交換（最初の要素を最後の要素と交換）
// 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）
swap(nums[0], nums[i]);
// ルートノードから上から下へヒープ化を開始
// 根ノードを起点に、上から下へヒープ化
siftDown(nums, i, 0);
}
}
/* ドライバコード */
/* Driver Code */
int main() {
vector<int> nums = {4, 1, 3, 1, 5, 2};
heapSort(nums);
cout << "ヒープソート後、nums = ";
cout << "ヒープソート完了後 nums = ";
printVector(nums);
return 0;
}
}

14
ja/codes/cpp/chapter_sorting/insertion_sort.cpp
View File

@@ -8,24 +8,24 @@
/* 挿入ソート */
void insertionSort(vector<int> &nums) {
// 外側ループ：ソート済み範囲は[0, i-1]
// 外側ループ：整列済み区間は [0, i-1]
for (int i = 1; i < nums.size(); i++) {
int base = nums[i], j = i - 1;
// 内側ループ：baseをソート済み範囲[0, i-1]内の正しい位置に挿入
// 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する
while (j >= 0 && nums[j] > base) {
nums[j + 1] = nums[j]; // nums[j]を一つ右に移動
nums[j + 1] = nums[j]; // nums[j] を 1 つ右へ移動する
j--;
}
nums[j + 1] = base; // baseを正しい位置に代入
nums[j + 1] = base; // base を正しい位置に配置する
}
}
/* ドライバコード */
/* Driver Code */
int main() {
vector<int> nums = {4, 1, 3, 1, 5, 2};
insertionSort(nums);
cout << "挿入ソート後、nums = ";
cout << "挿入ソート完了後 nums = ";
printVector(nums);
return 0;
}
}

30
ja/codes/cpp/chapter_sorting/merge_sort.cpp
View File

@@ -6,28 +6,28 @@
#include "../utils/common.hpp"
/* 左サブ配列と右サブ配列をマージ */
/* 左部分配列と右部分配列をマージ */
void merge(vector<int> &nums, int left, int mid, int right) {
// 左サブ配列の区間は[left, mid]、右サブ配列の区間は[mid+1, right]
// マージ結果を保存する一時配列tmpを作成
// 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]
// マージ結果を格納する一時配列 tmp を作成
vector<int> tmp(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.size(); k++) {
nums[left + k] = tmp[k];
}
@@ -37,22 +37,22 @@ void merge(vector<int> &nums, int left, int mid, int right) {
void mergeSort(vector<int> &nums, int left, int right) {
// 終了条件
if (left >= right)
return; // サブ配列の長さが1の時、再帰を終了
// 分割段階
return; // 部分配列の長さが 1 になったら再帰を終了
// 分割フェーズ
int mid = left + (right - left) / 2; // 中点を計算
mergeSort(nums, left, mid); // 左サブ配列を再帰的に処理
mergeSort(nums, mid + 1, right); // 右サブ配列を再帰的に処理
// マージ段階
mergeSort(nums, left, mid); // 左部分配列を再帰処理
mergeSort(nums, mid + 1, right); // 右部分配列を再帰処理
// マージフェーズ
merge(nums, left, mid, right);
}
/* ドライバコード */
/* Driver Code */
int main() {
/* マージソート */
vector<int> nums = {7, 3, 2, 6, 0, 1, 5, 4};
mergeSort(nums, 0, nums.size() - 1);
cout << "マージソート後、nums = ";
cout << "マージソート完了後 nums = ";
printVector(nums);
return 0;
}
}

119
ja/codes/cpp/chapter_sorting/quick_sort.cpp
View File

@@ -9,37 +9,30 @@
/* クイックソートクラス */
class QuickSort {
private:
/* 要素を交換 */
static void swap(vector<int> &nums, int i, int j) {
int tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
/* 分割 */
/* 番兵分割 */
static int partition(vector<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); // これら二つの要素を交換
i++; // 左から右へ基準値より大きい最初の要素を探す
swap(nums[i], nums[j]); // この 2 つの要素を交換
}
swap(nums, i, left); // ピボットを二つのサブ配列の境界に交換
return i; // ピボットのインデックスを返す
swap(nums[i], nums[left]); // 基準値を 2 つの部分配列の境界へ交換する
return i; // 基準値のインデックスを返す
}
public:
/* クイックソート */
static void quickSort(vector<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);
}
@@ -48,119 +41,105 @@ class QuickSort {
/* クイックソートクラス（中央値ピボット最適化） */
class QuickSortMedian {
private:
/* 要素を交換 */
static void swap(vector<int> &nums, int i, int j) {
int tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
/* 三つの候補要素の中央値を選択 */
/* 3つの候補要素の中央値を選ぶ */
static int medianThree(vector<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 点中央値） */
static int partition(vector<int> &nums, int left, int right) {
// 三つの候補要素の中央値を選択
// 3つの候補要素の中央値を選ぶ
int med = medianThree(nums, left, (left + right) / 2, right);
// 中央値を配列の最左位置に交換
swap(nums, left, med);
// nums[left]をピボットとして使用
// 中央値を配列の最左端に交換する
swap(nums[left], nums[med]);
// 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); // これら二つの要素を交換
i++; // 左から右へ基準値より大きい最初の要素を探す
swap(nums[i], nums[j]); // この 2 つの要素を交換
}
swap(nums, i, left); // ピボットを二つのサブ配列の境界に交換
return i; // ピボットのインデックスを返す
swap(nums[i], nums[left]); // 基準値を 2 つの部分配列の境界へ交換する
return i; // 基準値のインデックスを返す
}
public:
/* クイックソート */
static void quickSort(vector<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 {
private:
/* 要素を交換 */
static void swap(vector<int> &nums, int i, int j) {
int tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
/* 分割 */
/* 番兵分割 */
static int partition(vector<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); // これら二つの要素を交換
i++; // 左から右へ基準値より大きい最初の要素を探す
swap(nums[i], nums[j]); // この 2 つの要素を交換
}
swap(nums, i, left); // ピボットを二つのサブ配列の境界に交換
return i; // ピボットのインデックスを返す
swap(nums[i], nums[left]); // 基準値を 2 つの部分配列の境界へ交換する
return i; // 基準値のインデックスを返す
}
public:
/* クイックソート（末尾再帰最適化） */
/* クイックソート（再帰深度最適化） */
static void quickSort(vector<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]
}
}
}
};
/* ドライバコード */
/* Driver Code */
int main() {
/* クイックソート */
vector<int> nums{2, 4, 1, 0, 3, 5};
QuickSort::quickSort(nums, 0, nums.size() - 1);
cout << "クイックソート後、nums = ";
cout << "クイックソート完了後 nums = ";
printVector(nums);
/* クイックソート（中央値ピボット最適化） */
/* クイックソート（中央値の基準値で最適化） */
vector<int> nums1 = {2, 4, 1, 0, 3, 5};
QuickSortMedian::quickSort(nums1, 0, nums1.size() - 1);
cout << "クイックソート（中央値ピボット最適化）完了、nums = ";
cout << "クイックソート（中央値ピボット最適化）完了後 nums = ";
printVector(nums1);
/* クイックソート（末尾再帰最適化） */
/* クイックソート（再帰深度最適化） */
vector<int> nums2 = {2, 4, 1, 0, 3, 5};
QuickSortTailCall::quickSort(nums2, 0, nums2.size() - 1);
cout << "クイックソート（末尾再帰最適化）完了、nums = ";
cout << "クイックソート（再帰深度最適化）完了後 nums = ";
printVector(nums2);
return 0;
}
}

40
ja/codes/cpp/chapter_sorting/radix_sort.cpp
View File

@@ -6,60 +6,60 @@
#include "../utils/common.hpp"
/* 要素numのk番目の桁を取得、exp = 10^(k-1) */
/* 要素 num の下から k 桁目を取得（exp = 10^(k-1)） */
int digit(int num, int exp) {
// kの代わりにexpを渡すことで、ここで繰り返される高価な冪乗計算を避けることができる
// ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す
return (num / exp) % 10;
}
/* カウントソート（numsのk番目の桁に基づく） */
/* 計数ソート（nums の k 桁目でソート） */
void countingSortDigit(vector<int> &nums, int exp) {
// 10進数の桁範囲は0~9なので、長さ10のバケット配列が必要
// 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要
vector<int> counter(10, 0);
int n = nums.size();
// 数字0~9の出現回数を統計
// 0~9 の各数字の出現回数を集計する
for (int i = 0; i < n; i++) {
int d = digit(nums[i], exp); // nums[i]のk番目の桁を取得、dとして記録
counter[d]++; // 数字dの出現回数を統計
int d = digit(nums[i], exp); // nums[i] の第 k 位を取得し、d とする
counter[d]++; // 数字 d の出現回数を数える
}
// 前缀和を計算し、「出現回数」を「配列インデックス」に変換
// 累積和を求め、「出現回数」を「配列インデックス」に変換する
for (int i = 1; i < 10; i++) {
counter[i] += counter[i - 1];
}
// 逆順で走査し、バケット統計に基づいて各要素をresに配置
// 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する
vector<int> res(n, 0);
for (int i = n - 1; i >= 0; i--) {
int d = digit(nums[i], exp);
int j = counter[d] - 1; // dが配列内にあるインデックスjを取得
res[j] = nums[i]; // 現在の要素をインデックスjに配置
counter[d]--; // dのカウントを1減らす
int j = counter[d] - 1; // d の配列内インデックス j を取得する
res[j] = nums[i]; // 現在の要素をインデックス j に格納する
counter[d]--; // d の個数を 1 減らす
}
// 結果で元の配列numsを上書き
// 結果で元の配列 nums を上書きする
for (int i = 0; i < n; i++)
nums[i] = res[i];
}
/* 基数ソート */
void radixSort(vector<int> &nums) {
// 配列の最大要素を取得、最大桁数を判定するために使用
// 最大桁数の判定用に配列の最大要素を取得
int m = *max_element(nums.begin(), nums.end());
// 最下位桁から最上位桁まで走査
// 下位桁から上位桁の順に走査する
for (int exp = 1; exp <= m; exp *= 10)
// 配列要素のk番目の桁でカウントソートを実行
// 配列要素の k 桁目に対して計数ソートを行う
// k = 1 -> exp = 1
// k = 2 -> exp = 10
// つまり、exp = 10^(k-1)
// つまり exp = 10^(k-1)
countingSortDigit(nums, exp);
}
/* ドライバコード */
/* Driver Code */
int main() {
// 基数ソート
vector<int> nums = {10546151, 35663510, 42865989, 34862445, 81883077,
88906420, 72429244, 30524779, 82060337, 63832996};
radixSort(nums);
cout << "基数ソート後、nums = ";
cout << "基数ソート完了後 nums = ";
printVector(nums);
return 0;
}
}

12
ja/codes/cpp/chapter_sorting/selection_sort.cpp
View File

@@ -9,26 +9,26 @@
/* 選択ソート */
void selectionSort(vector<int> &nums) {
int n = nums.size();
// 外側ループ：未ソート範囲は[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; // 最小要素のインデックスを記録
}
// 最小要素を未ソート範囲の最初の要素と交換
// その最小要素を未整列区間の先頭要素と交換する
swap(nums[i], nums[k]);
}
}
/* ドライバコード */
/* Driver Code */
int main() {
vector<int> nums = {4, 1, 3, 1, 5, 2};
selectionSort(nums);
cout << "選択ソート後、nums = ";
cout << "選択ソート完了後 nums = ";
printVector(nums);
return 0;
}
}

9
ja/codes/cpp/chapter_stack_and_queue/CMakeLists.txt Normal file
View File

@@ -0,0 +1,9 @@
add_executable(array_deque array_deque.cpp)
add_executable(array_queue array_queue.cpp)
add_executable(array_stack array_stack.cpp)
add_executable(deque deque.cpp)
add_executable(linkedlist_deque linkedlist_deque.cpp)
add_executable(linkedlist_queue linkedlist_queue.cpp)
add_executable(linkedlist_stack linkedlist_stack.cpp)
add_executable(queue queue.cpp)
add_executable(stack stack.cpp)

72
ja/codes/cpp/chapter_stack_and_queue/array_deque.cpp
View File

@@ -6,11 +6,11 @@
#include "../utils/common.hpp"
/* 循環配列に基づく両端キュークラス */
/* 循環配列ベースの両端キュー */
class ArrayDeque {
private:
vector<int> nums; // 両端キューの要素を格納する配列
int front; // 先頭ポインタ、先頭要素を指す
int front; // 先頭ポインタ。先頭要素を指す
int queSize; // 両端キューの長さ
public:
@@ -37,74 +37,74 @@ class ArrayDeque {
/* 循環配列のインデックスを計算 */
int index(int i) {
// 剰余演算で循環配列を実現
// iが配列の末尾を超えた場合、先頭に戻る
// iが配列の先頭を超えた場合、末尾に戻る
// 剰余演算により配列の先頭と末尾をつなげる
// i が配列の末尾を越えたら先頭に戻る
// i が配列の先頭を越えて前に出たら末尾に戻る
return (i + capacity()) % capacity();
}
/* 先頭エンキュー */
/* キュー先頭にエンキュー */
void pushFirst(int num) {
if (queSize == capacity()) {
cout << "Double-ended queue is full" << endl;
cout << "両端キューがいっぱいです" << endl;
return;
}
// 先頭ポインタを1つ左に移動
// 剰余演算でfrontが配列の先頭を越えて末尾に戻ることを実現
// 先頭ポインタを左に 1 つ移動する
// 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする
front = index(front - 1);
// numを先頭に追加
// num をキュー先頭に追加
nums[front] = num;
queSize++;
}
/* 末尾エンキュー */
/* キュー末尾にエンキュー */
void pushLast(int num) {
if (queSize == capacity()) {
cout << "Double-ended queue is full" << endl;
cout << "両端キューがいっぱいです" << endl;
return;
}
// 末尾ポインタを計算、末尾インデックス + 1を指す
// キュー末尾ポインタを計算し、末尾インデックス + 1 を指す
int rear = index(front + queSize);
// numを末尾に追加
// num をキュー末尾に追加
nums[rear] = num;
queSize++;
}
/* 先頭デキュー */
/* キュー先頭からデキュー */
int popFirst() {
int num = peekFirst();
// 先頭ポインタを1つ後ろに移動
// 先頭ポインタを 1 つ後ろへ進める
front = index(front + 1);
queSize--;
return num;
}
/* 末尾デキュー */
/* キュー末尾からデキュー */
int popLast() {
int num = peekLast();
queSize--;
return num;
}
/* 先頭要素にアクセス */
/* キュー先頭の要素にアクセス */
int peekFirst() {
if (isEmpty())
throw out_of_range("Double-ended queue is empty");
throw out_of_range("両端キューが空です");
return nums[front];
}
/* 末尾要素にアクセス */
/* キュー末尾の要素にアクセス */
int peekLast() {
if (isEmpty())
throw out_of_range("Double-ended queue is empty");
throw out_of_range("両端キューが空です");
// 末尾要素のインデックスを計算
int last = index(front + queSize - 1);
return nums[last];
}
/* 印刷用に配列を返却 */
/* 出力用の配列を返す */
vector<int> toVector() {
// 有効な長さ範囲内の要素のみを変換
// 有効長の範囲内のリスト要素のみを変換
vector<int> res(queSize);
for (int i = 0, j = front; i < queSize; i++, j++) {
res[i] = nums[index(j)];
@@ -113,44 +113,44 @@ class ArrayDeque {
}
};
/* ドライバーコード */
/* Driver Code */
int main() {
/* 両端キューを初期化 */
ArrayDeque *deque = new ArrayDeque(10);
deque->pushLast(3);
deque->pushLast(2);
deque->pushLast(5);
cout << "Double-ended queue deque = ";
cout << "両端キュー deque = ";
printVector(deque->toVector());
/* 要素にアクセス */
int peekFirst = deque->peekFirst();
cout << "Front element peekFirst = " << peekFirst << endl;
cout << "先頭要素 peekFirst = " << peekFirst << endl;
int peekLast = deque->peekLast();
cout << "Back element peekLast = " << peekLast << endl;
cout << "末尾要素 peekLast = " << peekLast << endl;
/* 要素エンキュー */
/* 要素をエンキュー */
deque->pushLast(4);
cout << "Element 4 enqueued at the tail, deque = ";
cout << "要素 4 を末尾に追加した後 deque = ";
printVector(deque->toVector());
deque->pushFirst(1);
cout << "Element 1 enqueued at the head, deque = ";
cout << "要素 1 を先頭に追加した後 deque = ";
printVector(deque->toVector());
/* 要素デキュー */
/* 要素をデキュー */
int popLast = deque->popLast();
cout << "Deque tail element = " << popLast << ", after dequeuing from the tail";
cout << "末尾から取り出した要素 = " << popLast << "、末尾から取り出した後 deque = ";
printVector(deque->toVector());
int popFirst = deque->popFirst();
cout << "Deque front element = " << popFirst << ", after dequeuing from the front";
cout << "先頭から取り出した要素 = " << popFirst << "、先頭から取り出した後 deque = ";
printVector(deque->toVector());
/* 両端キューの長さを取得 */
int size = deque->size();
cout << "Length of the double-ended queue size = " << size << endl;
cout << "両端キューの長さ size = " << size << endl;
/* 両端キューが空かどうかを判定 */
bool isEmpty = deque->isEmpty();
cout << "Is the double-ended queue empty = " << boolalpha << isEmpty << endl;
cout << "両端キューが空かどうか = " << boolalpha << isEmpty << endl;
return 0;
}
}

48
ja/codes/cpp/chapter_stack_and_queue/array_queue.cpp
View File

@@ -6,11 +6,11 @@
#include "../utils/common.hpp"
/* 循環配列に基づくキュークラス */
/* 循環配列ベースのキュー */
class ArrayQueue {
private:
int *nums; // キュー要素を格納する配列
int front; // 先頭ポインタ、先頭要素を指す
int front; // 先頭ポインタ。先頭要素を指す
int queSize; // キューの長さ
int queCapacity; // キューの容量
@@ -44,13 +44,13 @@ class ArrayQueue {
/* エンキュー */
void push(int num) {
if (queSize == queCapacity) {
cout << "Queue is full" << endl;
cout << "キューがいっぱいです" << endl;
return;
}
// 末尾ポインタを計算、末尾インデックス + 1を指す
// 剰余演算を使用して末尾ポインタが配列の末尾から先頭に戻るようにラップ
// 末尾ポインタを計算し、末尾インデックス + 1 を指す
// 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする
int rear = (front + queSize) % queCapacity;
// numを末尾に追加
// num をキュー末尾に追加
nums[rear] = num;
queSize++;
}
@@ -58,22 +58,22 @@ class ArrayQueue {
/* デキュー */
int pop() {
int num = peek();
// 先頭ポインタを1つ後ろに移動、末尾を超えた場合は配列の先頭に戻る
// 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す
front = (front + 1) % queCapacity;
queSize--;
return num;
}
/* 先頭要素にアクセス */
/* キュー先頭の要素にアクセス */
int peek() {
if (isEmpty())
throw out_of_range("Queue is empty");
throw out_of_range("キューが空です");
return nums[front];
}
/* 配列をVectorに変換して返却 */
/* 配列を Vector に変換して返す */
vector<int> toVector() {
// 有効な長さ範囲内の要素のみを変換
// 有効長の範囲内のリスト要素のみを変換
vector<int> arr(queSize);
for (int i = 0, j = front; i < queSize; i++, j++) {
arr[i] = nums[j % queCapacity];
@@ -82,48 +82,48 @@ class ArrayQueue {
}
};
/* ドライバーコード */
/* Driver Code */
int main() {
/* キューを初期化 */
int capacity = 10;
ArrayQueue *queue = new ArrayQueue(capacity);
/* 要素エンキュー */
/* 要素をエンキュー */
queue->push(1);
queue->push(3);
queue->push(2);
queue->push(5);
queue->push(4);
cout << "Queue queue = ";
cout << "キュー queue = ";
printVector(queue->toVector());
/* 先頭要素にアクセス */
/* キュー先頭の要素にアクセス */
int peek = queue->peek();
cout << "Front element peek = " << peek << endl;
cout << "先頭要素 peek = " << peek << endl;
/* 要素デキュー */
/* 要素をデキュー */
peek = queue->pop();
cout << "Element dequeued = " << peek << ", after dequeuing";
cout << "取り出した要素 pop = " << peek << "、取り出し後の queue = ";
printVector(queue->toVector());
/* キューの長さを取得 */
int size = queue->size();
cout << "Length of the queue size = " << size << endl;
cout << "キューの長さ size = " << size << endl;
/* キューが空かどうかを判定 */
bool empty = queue->isEmpty();
cout << "Is the queue empty = " << empty << endl;
cout << "キューが空かどうか = " << empty << endl;
/* 循環配列をテスト */
/* 循環配列をテストする */
for (int i = 0; i < 10; i++) {
queue->push(i);
queue->pop();
cout << "After the " << i << "th round of enqueueing + dequeuing, queue = ";
cout << "第 " << i << " 回のエンキュー + デキュー後の queue = ";
printVector(queue->toVector());
}
// メモリを解放
// メモリを解放する
delete queue;
return 0;
}
}

30
ja/codes/cpp/chapter_stack_and_queue/array_stack.cpp
View File

@@ -6,7 +6,7 @@
#include "../utils/common.hpp"
/* 配列に基づくスタッククラス */
/* 配列ベースのスタック */
class ArrayStack {
private:
vector<int> stack;
@@ -34,52 +34,52 @@ class ArrayStack {
return num;
}
/* スタックトップ要素にアクセス */
/* スタックトップの要素にアクセス */
int top() {
if (isEmpty())
throw out_of_range("Stack is empty");
throw out_of_range("スタックが空です");
return stack.back();
}
/* Vectorを返却 */
/* Vector を返す */
vector<int> toVector() {
return stack;
}
};
/* ドライバーコード */
/* Driver Code */
int main() {
/* スタックを初期化 */
ArrayStack *stack = new ArrayStack();
/* 要素プッシュ */
/* 要素をプッシュ */
stack->push(1);
stack->push(3);
stack->push(2);
stack->push(5);
stack->push(4);
cout << "Stack stack = ";
cout << "スタック stack = ";
printVector(stack->toVector());
/* スタックトップ要素にアクセス */
/* スタックトップの要素にアクセス */
int top = stack->top();
cout << "Top element of the stack top = " << top << endl;
cout << "トップ要素 top = " << top << endl;
/* 要素ポップ */
/* 要素をポップ */
top = stack->pop();
cout << "Element popped from the stack = " << top << ", after popping";
cout << "取り出した要素 pop = " << top << "、取り出し後の stack = ";
printVector(stack->toVector());
/* スタックの長さを取得 */
int size = stack->size();
cout << "Length of the stack size = " << size << endl;
cout << "スタックの長さ size = " << size << endl;
/* 空かどうかを判定 */
bool empty = stack->isEmpty();
cout << "Is the stack empty = " << empty << endl;
cout << "スタックが空かどうか = " << empty << endl;
// メモリを解放
// メモリを解放する
delete stack;
return 0;
}
}

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

@@ -6,41 +6,41 @@
#include "../utils/common.hpp"
/* ドライバーコード */
/* Driver Code */
int main() {
/* 両端キューを初期化 */
deque<int> deque;
/* 要素エンキュー */
/* 要素をエンキュー */
deque.push_back(2);
deque.push_back(5);
deque.push_back(4);
deque.push_front(3);
deque.push_front(1);
cout << "Double-ended queue deque = ";
cout << "両端キュー deque = ";
printDeque(deque);
/* 要素にアクセス */
int front = deque.front();
cout << "Front element of the queue front = " << front << endl;
cout << "先頭要素 front = " << front << endl;
int back = deque.back();
cout << "Back element of the queue back = " << back << endl;
cout << "末尾要素 back = " << back << endl;
/* 要素デキュー */
/* 要素をデキュー */
deque.pop_front();
cout << "Front element dequeued = " << front << ", after dequeuing from the front";
cout << "先頭から取り出した要素 popFront = " << front << "、先頭から取り出した後の deque = ";
printDeque(deque);
deque.pop_back();
cout << "Back element dequeued = " << back << ", after dequeuing from the back";
cout << "末尾から取り出した要素 popLast = " << back << "、末尾から取り出した後の deque = ";
printDeque(deque);
/* 両端キューの長さを取得 */
int size = deque.size();
cout << "Length of the double-ended queue size = " << size << endl;
cout << "両端キューの長さ size = " << size << endl;
/* 両端キューが空かどうかを判定 */
bool empty = deque.empty();
cout << "Is the double-ended queue empty = " << empty << endl;
cout << "両端キューが空かどうか = " << empty << endl;
return 0;
}
}

88
ja/codes/cpp/chapter_stack_and_queue/linkedlist_deque.cpp
View File

@@ -8,17 +8,17 @@
/* 双方向連結リストノード */
struct DoublyListNode {
int val; // ノードの値
DoublyListNode *next; // 後続ノードへのポインタ
DoublyListNode *prev; // 前続ノードへのポインタ
int val; // ノード値
DoublyListNode *next; // 後継ノードへのポインタ
DoublyListNode *prev; // 前駆ノードへのポインタ
DoublyListNode(int val) : val(val), prev(nullptr), next(nullptr) {
}
};
/* 双方向連結リストに基づく両端キュークラス */
/* 双方向連結リストベースの両端キュー */
class LinkedListDeque {
private:
DoublyListNode *front, *rear; // 先頭ノードfront、末尾ノードrear
DoublyListNode *front, *rear; // 先頭ノード front、末尾ノード rear
int queSize = 0; // 両端キューの長さ
public:
@@ -26,9 +26,9 @@ class LinkedListDeque {
LinkedListDeque() : front(nullptr), rear(nullptr) {
}
/* デストラクタ */
/* デストラクタメソッド */
~LinkedListDeque() {
// 連結リストを走査、ノードを削除、メモリを解放
// 連結リストを走査してノードを削除し、メモリを解放する
DoublyListNode *pre, *cur = front;
while (cur != nullptr) {
pre = cur;
@@ -50,31 +50,31 @@ class LinkedListDeque {
/* エンキュー操作 */
void push(int num, bool isFront) {
DoublyListNode *node = new DoublyListNode(num);
// リストが空の場合、frontとrearの両方をnodeに向ける
// 連結リストが空なら、front と rear の両方を node に向ける
if (isEmpty())
front = rear = node;
// 先頭エンキュー操作
// 先頭へのエンキュー操作
else if (isFront) {
// ノードをリストの先頭に追加
// node を連結リストの先頭に追加
front->prev = node;
node->next = front;
front = node; // 先頭ノードを更新
// 末尾エンキュー操作
front = node; // 先頭ノードを更新する
// 末尾へのエンキュー操作
} else {
// ノードをリストの末尾に追加
// node を連結リストの末尾に追加
rear->next = node;
node->prev = rear;
rear = node; // 末尾ノードを更新
rear = node; // 末尾ノードを更新する
}
queSize++; // キュー長を更新
queSize++; // キューの長さを更新
}
/* 先頭エンキュー */
/* キュー先頭にエンキュー */
void pushFirst(int num) {
push(num, true);
}
/* 末尾エンキュー */
/* キュー末尾にエンキュー */
void pushLast(int num) {
push(num, false);
}
@@ -82,9 +82,9 @@ class LinkedListDeque {
/* デキュー操作 */
int pop(bool isFront) {
if (isEmpty())
throw out_of_range("Queue is empty");
throw out_of_range("キューが空です");
int val;
// 先頭デキュー操作
// キュー先頭からの取り出し
if (isFront) {
val = front->val; // 先頭ノードの値を一時保存
// 先頭ノードを削除
@@ -94,8 +94,8 @@ class LinkedListDeque {
front->next = nullptr;
}
delete front;
front = fNext; // 先頭ノードを更新
// 末尾デキュー操作
front = fNext; // 先頭ノードを更新する
// キュー末尾からの取り出し
} else {
val = rear->val; // 末尾ノードの値を一時保存
// 末尾ノードを削除
@@ -105,37 +105,37 @@ class LinkedListDeque {
rear->prev = nullptr;
}
delete rear;
rear = rPrev; // 末尾ノードを更新
rear = rPrev; // 末尾ノードを更新する
}
queSize--; // キュー長を更新
queSize--; // キューの長さを更新
return val;
}
/* 先頭デキュー */
/* キュー先頭からデキュー */
int popFirst() {
return pop(true);
}
/* 末尾デキュー */
/* キュー末尾からデキュー */
int popLast() {
return pop(false);
}
/* 先頭要素にアクセス */
/* キュー先頭の要素にアクセス */
int peekFirst() {
if (isEmpty())
throw out_of_range("Double-ended queue is empty");
throw out_of_range("両端キューが空です");
return front->val;
}
/* 末尾要素にアクセス */
/* キュー末尾の要素にアクセス */
int peekLast() {
if (isEmpty())
throw out_of_range("Double-ended queue is empty");
throw out_of_range("両端キューが空です");
return rear->val;
}
/* 印刷用に配列を返却 */
/* 出力用の配列を返す */
vector<int> toVector() {
DoublyListNode *node = front;
vector<int> res(size());
@@ -147,48 +147,48 @@ class LinkedListDeque {
}
};
/* ドライバーコード */
/* Driver Code */
int main() {
/* 両端キューを初期化 */
LinkedListDeque *deque = new LinkedListDeque();
deque->pushLast(3);
deque->pushLast(2);
deque->pushLast(5);
cout << "Double-ended queue deque = ";
cout << "両端キュー deque = ";
printVector(deque->toVector());
/* 要素にアクセス */
int peekFirst = deque->peekFirst();
cout << "Front element peekFirst = " << peekFirst << endl;
cout << "先頭要素 peekFirst = " << peekFirst << endl;
int peekLast = deque->peekLast();
cout << "Back element peekLast = " << peekLast << endl;
cout << "末尾要素 peekLast = " << peekLast << endl;
/* 要素エンキュー */
/* 要素をエンキュー */
deque->pushLast(4);
cout << "Element 4 rear enqueued, deque =";
cout << "要素 4 を末尾に追加した後の deque =";
printVector(deque->toVector());
deque->pushFirst(1);
cout << "Element 1 enqueued at the head, deque = ";
cout << "要素 1 を先頭に追加した後 deque = ";
printVector(deque->toVector());
/* 要素デキュー */
/* 要素をデキュー */
int popLast = deque->popLast();
cout << "Deque tail element = " << popLast << ", after dequeuing from the tail";
cout << "末尾から取り出した要素 = " << popLast << "、末尾から取り出した後 deque = ";
printVector(deque->toVector());
int popFirst = deque->popFirst();
cout << "Deque front element = " << popFirst << ", after dequeuing from the front";
cout << "先頭から取り出した要素 = " << popFirst << "、先頭から取り出した後 deque = ";
printVector(deque->toVector());
/* 両端キューの長さを取得 */
int size = deque->size();
cout << "Length of the double-ended queue size = " << size << endl;
cout << "両端キューの長さ size = " << size << endl;
/* 両端キューが空かどうかを判定 */
bool isEmpty = deque->isEmpty();
cout << "Is the double-ended queue empty = " << boolalpha << isEmpty << endl;
cout << "両端キューが空かどうか = " << boolalpha << isEmpty << endl;
// メモリを解放
// メモリを解放する
delete deque;
return 0;
}
}

42
ja/codes/cpp/chapter_stack_and_queue/linkedlist_queue.cpp
View File

@@ -6,10 +6,10 @@
#include "../utils/common.hpp"
/* 連結リストに基づくキュークラス */
/* 連結リストベースのキュー */
class LinkedListQueue {
private:
ListNode *front, *rear; // 先頭ノードfront、末尾ノードrear
ListNode *front, *rear; // 先頭ノード front、末尾ノード rear
int queSize;
public:
@@ -20,7 +20,7 @@ class LinkedListQueue {
}
~LinkedListQueue() {
// 連結リストを走査、ノードを削除、メモリを解放
// 連結リストを走査してノードを削除し、メモリを解放する
freeMemoryLinkedList(front);
}
@@ -36,14 +36,14 @@ class LinkedListQueue {
/* エンキュー */
void push(int num) {
// 末尾ノードの後ろにnumを追加
// 末尾ノードの後ろに num を追加
ListNode *node = new ListNode(num);
// キューが空の場合、先頭と末尾ノードの両方をそのノードに向ける
// キューが空なら、先頭・末尾ノードをともにそのノードに設定
if (front == nullptr) {
front = node;
rear = node;
}
// キューが空でない場合、そのノードを末尾ノードの後ろに追加
// キューが空でなければ、そのノードを末尾ノードの後ろに追加
else {
rear->next = node;
rear = node;
@@ -57,20 +57,20 @@ class LinkedListQueue {
// 先頭ノードを削除
ListNode *tmp = front;
front = front->next;
// メモリを解放
// メモリを解放する
delete tmp;
queSize--;
return num;
}
/* 先頭要素にアクセス */
/* キュー先頭の要素にアクセス */
int peek() {
if (size() == 0)
throw out_of_range("Queue is empty");
throw out_of_range("キューが空です");
return front->val;
}
/* 連結リストをVectorに変換して返却 */
/* 連結リストを Vector に変換して返す */
vector<int> toVector() {
ListNode *node = front;
vector<int> res(size());
@@ -82,39 +82,39 @@ class LinkedListQueue {
}
};
/* ドライバーコード */
/* Driver Code */
int main() {
/* キューを初期化 */
LinkedListQueue *queue = new LinkedListQueue();
/* 要素エンキュー */
/* 要素をエンキュー */
queue->push(1);
queue->push(3);
queue->push(2);
queue->push(5);
queue->push(4);
cout << "Queue queue = ";
cout << "キュー queue = ";
printVector(queue->toVector());
/* 先頭要素にアクセス */
/* キュー先頭の要素にアクセス */
int peek = queue->peek();
cout << "Front element peek = " << peek << endl;
cout << "先頭要素 peek = " << peek << endl;
/* 要素デキュー */
/* 要素をデキュー */
peek = queue->pop();
cout << "Element dequeued = " << peek << ", after dequeuing";
cout << "取り出した要素 pop = " << peek << "、取り出し後の queue = ";
printVector(queue->toVector());
/* キューの長さを取得 */
int size = queue->size();
cout << "Length of the queue size = " << size << endl;
cout << "キューの長さ size = " << size << endl;
/* キューが空かどうかを判定 */
bool empty = queue->isEmpty();
cout << "Is the queue empty = " << empty << endl;
cout << "キューが空かどうか = " << empty << endl;
// メモリを解放
// メモリを解放する
delete queue;
return 0;
}
}

36
ja/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp
View File

@@ -6,10 +6,10 @@
#include "../utils/common.hpp"
/* 連結リストに基づくスタッククラス */
/* 連結リストベースのスタック */
class LinkedListStack {
private:
ListNode *stackTop; // 先頭ノードをスタックトップとして使用
ListNode *stackTop; // 先頭ノードをスタックトップとする
int stkSize; // スタックの長さ
public:
@@ -19,7 +19,7 @@ class LinkedListStack {
}
~LinkedListStack() {
// 連結リストを走査、ノードを削除、メモリを解放
// 連結リストを走査してノードを削除し、メモリを解放する
freeMemoryLinkedList(stackTop);
}
@@ -46,20 +46,20 @@ class LinkedListStack {
int num = top();
ListNode *tmp = stackTop;
stackTop = stackTop->next;
// メモリを解放
// メモリを解放する
delete tmp;
stkSize--;
return num;
}
/* スタックトップ要素にアクセス */
/* スタックトップの要素にアクセス */
int top() {
if (isEmpty())
throw out_of_range("Stack is empty");
throw out_of_range("スタックが空です");
return stackTop->val;
}
/* リストを配列に変換して返却 */
/* List を Array に変換して返す */
vector<int> toVector() {
ListNode *node = stackTop;
vector<int> res(size());
@@ -71,39 +71,39 @@ class LinkedListStack {
}
};
/* ドライバーコード */
/* Driver Code */
int main() {
/* スタックを初期化 */
LinkedListStack *stack = new LinkedListStack();
/* 要素プッシュ */
/* 要素をプッシュ */
stack->push(1);
stack->push(3);
stack->push(2);
stack->push(5);
stack->push(4);
cout << "Stack stack = ";
cout << "スタック stack = ";
printVector(stack->toVector());
/* スタックトップ要素にアクセス */
/* スタックトップの要素にアクセス */
int top = stack->top();
cout << "Top element of the stack top = " << top << endl;
cout << "トップ要素 top = " << top << endl;
/* 要素ポップ */
/* 要素をポップ */
top = stack->pop();
cout << "Element popped from the stack = " << top << ", after popping";
cout << "取り出した要素 pop = " << top << "、取り出し後の stack = ";
printVector(stack->toVector());
/* スタックの長さを取得 */
int size = stack->size();
cout << "Length of the stack size = " << size << endl;
cout << "スタックの長さ size = " << size << endl;
/* 空かどうかを判定 */
bool empty = stack->isEmpty();
cout << "Is the stack empty = " << empty << endl;
cout << "スタックが空かどうか = " << empty << endl;
// メモリを解放
// メモリを解放する
delete stack;
return 0;
}
}

20
ja/codes/cpp/chapter_stack_and_queue/queue.cpp
View File

@@ -6,36 +6,36 @@
#include "../utils/common.hpp"
/* ドライバーコード */
/* Driver Code */
int main() {
/* キューを初期化 */
queue<int> queue;
/* 要素エンキュー */
/* 要素をエンキュー */
queue.push(1);
queue.push(3);
queue.push(2);
queue.push(5);
queue.push(4);
cout << "Queue queue = ";
cout << "キュー queue = ";
printQueue(queue);
/* 先頭要素にアクセス */
/* キュー先頭の要素にアクセス */
int front = queue.front();
cout << "Front element of the queue front = " << front << endl;
cout << "先頭要素 front = " << front << endl;
/* 要素デキュー */
/* 要素をデキュー */
queue.pop();
cout << "Element dequeued = " << front << ", after dequeuing";
cout << "取り出した要素 front = " << front << "、取り出し後の queue = ";
printQueue(queue);
/* キューの長さを取得 */
int size = queue.size();
cout << "Length of the queue size = " << size << endl;
cout << "キューの長さ size = " << size << endl;
/* キューが空かどうかを判定 */
bool empty = queue.empty();
cout << "Is the queue empty = " << empty << endl;
cout << "キューが空かどうか = " << empty << endl;
return 0;
}
}

20
ja/codes/cpp/chapter_stack_and_queue/stack.cpp
View File

@@ -6,36 +6,36 @@
#include "../utils/common.hpp"
/* ドライバーコード */
/* Driver Code */
int main() {
/* スタックを初期化 */
stack<int> stack;
/* 要素プッシュ */
/* 要素をプッシュ */
stack.push(1);
stack.push(3);
stack.push(2);
stack.push(5);
stack.push(4);
cout << "Stack stack = ";
cout << "スタック stack = ";
printStack(stack);
/* スタックトップ要素にアクセス */
/* スタックトップの要素にアクセス */
int top = stack.top();
cout << "Top element of the stack top = " << top << endl;
cout << "トップ要素 top = " << top << endl;
/* 要素ポップ */
/* 要素をポップ */
stack.pop(); // 戻り値なし
cout << "Element popped from the stack = " << top << ", after popping";
cout << "取り出した要素 pop = " << top << "、取り出し後の stack = ";
printStack(stack);
/* スタックの長さを取得 */
int size = stack.size();
cout << "Length of the stack size = " << size << endl;
cout << "スタックの長さ size = " << size << endl;
/* 空かどうかを判定 */
bool empty = stack.empty();
cout << "Is the stack empty = " << empty << endl;
cout << "スタックが空かどうか = " << empty << endl;
return 0;
}
}

6
ja/codes/cpp/chapter_tree/CMakeLists.txt Normal file
View File

@@ -0,0 +1,6 @@
add_executable(avl_tree avl_tree.cpp)
add_executable(binary_search_tree binary_search_tree.cpp)
add_executable(binary_tree binary_tree.cpp)
add_executable(binary_tree_bfs binary_tree_bfs.cpp)
add_executable(binary_tree_dfs binary_tree_dfs.cpp)
add_executable(array_binary_tree array_binary_tree.cpp)

52
ja/codes/cpp/chapter_tree/array_binary_tree.cpp
View File

@@ -6,7 +6,7 @@
#include "../utils/common.hpp"
/* 配列ベースの二分木クラス */
/* 配列表現による二分木クラス */
class ArrayBinaryTree {
public:
/* コンストラクタ */
@@ -14,30 +14,30 @@ class ArrayBinaryTree {
tree = arr;
}
/* リストの容量 */
/* リスト容量 */
int size() {
return tree.size();
}
/* インデックス i のノードの値を取得 */
int val(int i) {
// インデックスが範囲外の場合、INT_MAX を返す（null を表す）
// インデックスが範囲外なら、空きを表す INT_MAX を返す
if (i < 0 || i >= size())
return INT_MAX;
return tree[i];
}
/* インデックス i のノードの左の子のインデックスを取得 */
/* インデックス i のノードの左子ノードのインデックスを取得 */
int left(int i) {
return 2 * i + 1;
}
/* インデックス i のノードの右の子のインデックスを取得 */
/* インデックス i のノードの右子ノードのインデックスを取得 */
int right(int i) {
return 2 * i + 2;
}
/* インデックス i のノードの親のインデックスを取得 */
/* インデックス i のノードの親ノードのインデックスを取得 */
int parent(int i) {
return (i - 1) / 2;
}
@@ -45,7 +45,7 @@ class ArrayBinaryTree {
/* レベル順走査 */
vector<int> levelOrder() {
vector<int> res;
// 配列を走査
// 配列を直接走査する
for (int i = 0; i < size(); i++) {
if (val(i) != INT_MAX)
res.push_back(val(i));
@@ -53,7 +53,7 @@ class ArrayBinaryTree {
return res;
}
/* 前順走査 */
/* 先行順走査 */
vector<int> preOrder() {
vector<int> res;
dfs(0, "pre", res);
@@ -77,12 +77,12 @@ class ArrayBinaryTree {
private:
vector<int> tree;
/* 深さ優先走査 */
/* 深さ優先探索 */
void dfs(int i, string order, vector<int> &res) {
// 空の位置の場合、戻る
// 空きスロットなら返す
if (val(i) == INT_MAX)
return;
// 前順走査
// 先行順走査
if (order == "pre")
res.push_back(val(i));
dfs(left(i), order, res);
@@ -96,42 +96,42 @@ class ArrayBinaryTree {
}
};
/* ドライバーコード */
/* Driver Code */
int main() {
// 二分木を初期化
// INT_MAX を使用して空の位置 nullptr を表す
// 二分木を初期化する
// 空き位置 nullptr は INT_MAX で表す
vector<int> arr = {1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15};
TreeNode *root = vectorToTree(arr);
cout << "\n二分木を初期化\n";
cout << "二分木の配列表現:\n";
cout << "二分木の配列表現：\n";
printVector(arr);
cout << "二分木の連結リスト表現:\n";
cout << "二分木の連結リスト表現：\n";
printTree(root);
// 配列ベースの二分木クラス
// 配列表現による二分木クラス
ArrayBinaryTree abt(arr);
// ノードにアクセス
int i = 1;
int l = abt.left(i), r = abt.right(i), p = abt.parent(i);
cout << "\n現在のノードのインデックスは " << i << "、値 = " << abt.val(i) << "\n";
cout << "その左の子のインデックスは " << l << "、値 = " << (l != INT_MAX ? to_string(abt.val(l)) : "nullptr") << "\n";
cout << "その右の子のインデックスは " << r << "、値 = " << (r != INT_MAX ? to_string(abt.val(r)) : "nullptr") << "\n";
cout << "その親のインデックスは " << p << "、値 = " << (p != INT_MAX ? to_string(abt.val(p)) : "nullptr") << "\n";
cout << "\n現在のノードのインデックスは " << i << "、値は " << abt.val(i) << "\n";
cout << "左の子ノードのインデックスは " << l << "、値は " << (abt.val(l) != INT_MAX ? to_string(abt.val(l)) : "nullptr") << "\n";
cout << "右の子ノードのインデックスは " << r << "、値は " << (abt.val(r) != INT_MAX ? to_string(abt.val(r)) : "nullptr") << "\n";
cout << "親ノードのインデックスは " << p << "、値は " << (abt.val(p) != INT_MAX ? to_string(abt.val(p)) : "nullptr") << "\n";
// 木を走査
vector<int> res = abt.levelOrder();
cout << "\nレベル順走査は:";
cout << "\nレベル順走査： ";
printVector(res);
res = abt.preOrder();
cout << "前順走査は:";
cout << "先行順走査： ";
printVector(res);
res = abt.inOrder();
cout << "中順走査は:";
cout << "中間順走査： ";
printVector(res);
res = abt.postOrder();
cout << "後順走査は:";
cout << "後行順走査： ";
printVector(res);
return 0;
}
}

112
ja/codes/cpp/chapter_tree/avl_tree.cpp
View File

@@ -6,96 +6,96 @@
#include "../utils/common.hpp"
/* AVL木 */
/* AVL 木 */
class AVLTree {
private:
/* ノードの高さを更新 */
/* ノードの高さを更新する */
void updateHeight(TreeNode *node) {
// ノードの高さ = 最も高い部分木の高さ + 1
// ノードの高さは最も高い部分木の高さ + 1 に等しい
node->height = max(height(node->left), height(node->right)) + 1;
}
/* 右回転操作 */
/* 右回転 */
TreeNode *rightRotate(TreeNode *node) {
TreeNode *child = node->left;
TreeNode *grandChild = child->right;
// childを中心にnodeを右に回転
// child を支点として node を右回転させる
child->right = node;
node->left = grandChild;
// ノードの高さを更新
// ノードの高さを更新する
updateHeight(node);
updateHeight(child);
// 回転後の部分木のルートを返す
// 回転後の部分木の根ノードを返す
return child;
}
/* 左回転操作 */
/* 左回転 */
TreeNode *leftRotate(TreeNode *node) {
TreeNode *child = node->right;
TreeNode *grandChild = child->left;
// childを中心にnodeを左に回転
// child を支点として node を左回転させる
child->left = node;
node->right = grandChild;
// ノードの高さを更新
// ノードの高さを更新する
updateHeight(node);
updateHeight(child);
// 回転後の部分木のルートを返す
// 回転後の部分木の根ノードを返す
return child;
}
/* 回転操作を実行して部分木の平衡を回復 */
/* 回転操作を行い、この部分木の平衡を回復する */
TreeNode *rotate(TreeNode *node) {
// nodeの平衡因子を取得
// ノード node の平衡係数を取得
int _balanceFactor = balanceFactor(node);
// 左に傾いた木
// 左に偏った木
if (_balanceFactor > 1) {
if (balanceFactor(node->left) >= 0) {
// 右回転
return rightRotate(node);
} else {
// 先に左回転、その後右回転
// 左回転してから右回転
node->left = leftRotate(node->left);
return rightRotate(node);
}
}
// 右に傾いた木
// 右に偏った木
if (_balanceFactor < -1) {
if (balanceFactor(node->right) <= 0) {
// 左回転
return leftRotate(node);
} else {
// 先に右回転、その後左回転
// 右回転してから左回転
node->right = rightRotate(node->right);
return leftRotate(node);
}
}
// 平衡な木、回転不要、そのまま戻る
// 平衡木なので回転不要、そのまま返す
return node;
}
/* ノードを再帰的に挿入（ヘルパーメソッド） */
/* ノードを再帰的に挿入する（補助メソッド） */
TreeNode *insertHelper(TreeNode *node, int val) {
if (node == nullptr)
return new TreeNode(val);
/* 1. 挿入位置を見つけてノードを挿入 */
/* 1. 挿入位置を探索してノードを挿入 */
if (val < node->val)
node->left = insertHelper(node->left, val);
else if (val > node->val)
node->right = insertHelper(node->right, val);
else
return node; // 重複ノードは挿入しない、そのまま戻る
updateHeight(node); // ノードの高さを更新
/* 2. 回転操作を実行して部分木の平衡を回復 */
return node; // 重複ノードは挿入せず、そのまま返す
updateHeight(node); // ノードの高さを更新する
/* 2. 回転操作を行い、部分木の平衡を回復する */
node = rotate(node);
// 部分木のルートノードを返す
// 部分木の根ノードを返す
return node;
}
/* ノードを再帰的に削除（ヘルパーメソッド） */
/* ノードを再帰的に削除する（補助メソッド） */
TreeNode *removeHelper(TreeNode *node, int val) {
if (node == nullptr)
return nullptr;
/* 1. ノードを見つけて削除 */
/* 1. ノードを探索して削除 */
if (val < node->val)
node->left = removeHelper(node->left, val);
else if (val > node->val)
@@ -103,18 +103,18 @@ class AVLTree {
else {
if (node->left == nullptr || node->right == nullptr) {
TreeNode *child = node->left != nullptr ? node->left : node->right;
// 子ノード数 = 0、ノードを削除して戻る
// 子ノード数 = 0 の場合、node をそのまま削除して返す
if (child == nullptr) {
delete node;
return nullptr;
}
// 子ノード数 = 1、ノードを削除
// 子ノード数 = 1 の場合、node をそのまま削除する
else {
delete node;
node = child;
}
} else {
// 子ノード数 = 2、中順走査の次のノードを削除し、現在のノードと置き換える
// 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える
TreeNode *temp = node->right;
while (temp->left != nullptr) {
temp = temp->left;
@@ -124,28 +124,28 @@ class AVLTree {
node->val = tempVal;
}
}
updateHeight(node); // ノードの高さを更新
/* 2. 回転操作を実行して部分木の平衡を回復 */
updateHeight(node); // ノードの高さを更新する
/* 2. 回転操作を行い、部分木の平衡を回復する */
node = rotate(node);
// 部分木のルートノードを返す
// 部分木の根ノードを返す
return node;
}
public:
TreeNode *root; // ルートノード
TreeNode *root; // 根ノード
/* ノードの高さを取得 */
int height(TreeNode *node) {
// 空ノードの高さは-1、葉ノードの高さは0
// 空ノードの高さは -1、葉ノードの高さは 0
return node == nullptr ? -1 : node->height;
}
/* 平衡因子を取得 */
/* 平衡係数を取得 */
int balanceFactor(TreeNode *node) {
// 空ノードの平衡因子は0
// 空ノードの平衡係数は 0
if (node == nullptr)
return 0;
// ノードの平衡因子 = 左部分木の高さ - 右部分木の高さ
// ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ
return height(node->left) - height(node->right);
}
@@ -159,18 +159,18 @@ class AVLTree {
root = removeHelper(root, val);
}
/* ノードを検索 */
/* ノードを探索 */
TreeNode *search(int val) {
TreeNode *cur = root;
// ループで検索、葉ノードを通り過ぎたら終了
// ループで探索し、葉ノードを越えたら抜ける
while (cur != nullptr) {
// 目標ノードはcurの右部分木にある
// 目標ノードは cur の右部分木にある
if (cur->val < val)
cur = cur->right;
// 目標ノードはcurの左部分木にある
// 目標ノードは cur の左部分木にある
else if (cur->val > val)
cur = cur->left;
// 目標ノードを見つけた、ループを抜ける
// 目標ノードが見つかったらループを抜ける
else
break;
}
@@ -178,11 +178,11 @@ class AVLTree {
return cur;
}
/*コンストラクタ*/
/* コンストラクタ */
AVLTree() : root(nullptr) {
}
/*デストラクタ*/
/* デストラクタメソッド */
~AVLTree() {
freeMemoryTree(root);
}
@@ -190,23 +190,23 @@ class AVLTree {
void testInsert(AVLTree &tree, int val) {
tree.insert(val);
cout << "\nノード " << val << " を挿入後、AVL木は" << endl;
cout << "\nノード " << val << " を挿入した後、AVL 木は" << endl;
printTree(tree.root);
}
void testRemove(AVLTree &tree, int val) {
tree.remove(val);
cout << "\nノード " << val << " を削除後、AVL木は" << endl;
cout << "\nノード " << val << " を削除した後、AVL 木は" << endl;
printTree(tree.root);
}
/* ドライバーコード */
/* Driver Code */
int main() {
/* 空のAVL木を初期化 */
/* 空の AVL 木を初期化する */
AVLTree avlTree;
/* ノードを挿入 */
// AVL木がノード挿入後に平衡を維持する様子に注目
// ノード挿入後に AVL 木がどのように平衡を保つかに注目してほしい
testInsert(avlTree, 1);
testInsert(avlTree, 2);
testInsert(avlTree, 3);
@@ -218,16 +218,16 @@ int main() {
testInsert(avlTree, 10);
testInsert(avlTree, 6);
/* 重複ノードを挿入 */
/* 重複ノードを挿入する */
testInsert(avlTree, 7);
/* ノードを削除 */
// AVL木がノード削除後に平衡を維持する様子に注目
testRemove(avlTree, 8); // 次数0のノードを削除
testRemove(avlTree, 5); // 次数1のノードを削除
testRemove(avlTree, 4); // 次数2のノードを削除
// ノード削除後に AVL 木がどのように平衡を保つかに注目してほしい
testRemove(avlTree, 8); // 次数 0 のノードを削除する
testRemove(avlTree, 5); // 次数 1 のノードを削除する
testRemove(avlTree, 4); // 次数 2 のノードを削除する
/* ノードを検索 */
TreeNode *node = avlTree.search(7);
cout << "\n見つかったノードオブジェクトは " << node << "、ノード値 =" << node->val << endl;
}
cout << "\n見つかったノードオブジェクトは " << node << "、ノード値 = " << node->val << endl;
}

76
ja/codes/cpp/chapter_tree/binary_search_tree.cpp
View File

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

18
ja/codes/cpp/chapter_tree/binary_tree.cpp
View File

@@ -6,7 +6,7 @@
#include "../utils/common.hpp"
/* ドライバーコード */
/* Driver Code */
int main() {
/* 二分木を初期化 */
// ノードを初期化
@@ -15,7 +15,7 @@ int main() {
TreeNode *n3 = new TreeNode(3);
TreeNode *n4 = new TreeNode(4);
TreeNode *n5 = new TreeNode(5);
// ノードの参照（ポインタ）を構築
// ノード間の参照（ポインタ）を構築する
n1->left = n2;
n1->right = n3;
n2->left = n4;
@@ -25,19 +25,19 @@ int main() {
/* ノードの挿入と削除 */
TreeNode *P = new TreeNode(0);
// n1 -> n2の間にノードPを挿入
// n1 -> n2 の間にノード P を挿入
n1->left = P;
P->left = n2;
cout << endl << "ノード P を挿入後\n" << endl;
cout << endl << "ノード P を挿入した後\n" << endl;
printTree(n1);
// ノードPを削除
// ノード P を削除
n1->left = n2;
delete P; // メモリを解放
cout << endl << "ノード P を削除後\n" << endl;
delete P; // メモリを解放する
cout << endl << "ノード P を削除した後\n" << endl;
printTree(n1);
// メモリを解放
// メモリを解放する
freeMemoryTree(n1);
return 0;
}
}

20
ja/codes/cpp/chapter_tree/binary_tree_bfs.cpp
View File

@@ -8,35 +8,35 @@
/* レベル順走査 */
vector<int> levelOrder(TreeNode *root) {
// キューを初期化、ルートノードを追加
// キューを初期化し、ルートノードを追加する
queue<TreeNode *> queue;
queue.push(root);
// 走査順序を保存するリストを初期化
// 走査順序を保存するためのリストを初期化する
vector<int> vec;
while (!queue.empty()) {
TreeNode *node = queue.front();
queue.pop(); // キューからデキュー
vec.push_back(node->val); // ノード値を保存
queue.pop(); // デキュー
vec.push_back(node->val); // ノードの値を保存する
if (node->left != nullptr)
queue.push(node->left); // 左の子ノードをエンキュー
queue.push(node->left); // 左子ノードをキューに追加
if (node->right != nullptr)
queue.push(node->right); // 右の子ノードをエンキュー
queue.push(node->right); // 右子ノードをキューに追加
}
return vec;
}
/* ドライバーコード */
/* Driver Code */
int main() {
/* 二分木を初期化 */
// 特定の関数を使用して配列を二分木に変換
// ここでは、配列から直接二分木を生成する関数を利用する
TreeNode *root = vectorToTree(vector<int>{1, 2, 3, 4, 5, 6, 7});
cout << endl << "二分木を初期化\n" << endl;
printTree(root);
/* レベル順走査 */
vector<int> vec = levelOrder(root);
cout << endl << "レベル順走査のノード順序 = ";
cout << endl << "レベル順走査のノード出力列 = ";
printVector(vec);
return 0;
}
}

24
ja/codes/cpp/chapter_tree/binary_tree_dfs.cpp
View File

@@ -6,14 +6,14 @@
#include "../utils/common.hpp"
// 走査順序を保存するリストを初期化
// 走査順序を格納するリストを初期化
vector<int> vec;
/* 前順走査 */
/* 先行順走査 */
void preOrder(TreeNode *root) {
if (root == nullptr)
return;
// 訪問優先度：ルートノード -> 左部分木 -> 右部分木
// 訪問順序：根ノード -> 左部分木 -> 右部分木
vec.push_back(root->val);
preOrder(root->left);
preOrder(root->right);
@@ -23,7 +23,7 @@ void preOrder(TreeNode *root) {
void inOrder(TreeNode *root) {
if (root == nullptr)
return;
// 訪問優先度：左部分木 -> ルートノード -> 右部分木
// 訪問優先順: 左部分木 -> 根ノード -> 右部分木
inOrder(root->left);
vec.push_back(root->val);
inOrder(root->right);
@@ -33,37 +33,37 @@ void inOrder(TreeNode *root) {
void postOrder(TreeNode *root) {
if (root == nullptr)
return;
// 訪問優先度：左部分木 -> 右部分木 -> ルートノード
// 訪問優先順: 左部分木 -> 右部分木 -> 根ノード
postOrder(root->left);
postOrder(root->right);
vec.push_back(root->val);
}
/* ドライバーコード */
/* Driver Code */
int main() {
/* 二分木を初期化 */
// 特定の関数を使用して配列を二分木に変換
// ここでは、配列から直接二分木を生成する関数を利用する
TreeNode *root = vectorToTree(vector<int>{1, 2, 3, 4, 5, 6, 7});
cout << endl << "二分木を初期化\n" << endl;
printTree(root);
/* 前順走査 */
/* 先行順走査 */
vec.clear();
preOrder(root);
cout << endl << "前順走査のノード順序 = ";
cout << endl << "前順走査のノード出力列 = ";
printVector(vec);
/* 中順走査 */
vec.clear();
inOrder(root);
cout << endl << "中順走査のノード順序 = ";
cout << endl << "中順走査のノード出力列 = ";
printVector(vec);
/* 後順走査 */
vec.clear();
postOrder(root);
cout << endl << "後順走査のノード順序 = ";
cout << endl << "後順走査のノード出力列 = ";
printVector(vec);
return 0;
}
}

4
ja/codes/cpp/utils/CMakeLists.txt Normal file
View File

@@ -0,0 +1,4 @@
add_executable(utils
common.hpp print_utils.hpp
list_node.hpp tree_node.hpp
vertex.hpp)

2
ja/codes/cpp/utils/common.hpp
View File

@@ -25,4 +25,4 @@
#include "tree_node.hpp"
#include "vertex.hpp"
using namespace std;
using namespace std;

Some files were not shown because too many files have changed in this diff Show More