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

feat: Traditional Chinese version (#1163)

Browse Source 
* First commit

* Update mkdocs.yml

* Translate all the docs to traditional Chinese

* Translate the code files.

* Translate the docker file

* Fix mkdocs.yml

* Translate all the figures from SC to TC

* 二叉搜尋樹 -> 二元搜尋樹

* Update terminology.

* Update terminology

* 构造函数/构造方法 -> 建構子
异或 -> 互斥或

* 擴充套件 -> 擴展

* constant - 常量 - 常數

* 類	-> 類別

* AVL -> AVL 樹

* 數組 -> 陣列

* 係統 -> 系統
斐波那契數列 -> 費波那契數列
運算元量 -> 運算量
引數 -> 參數

* 聯絡 -> 關聯

* 麵試 -> 面試

* 面向物件 -> 物件導向
歸併排序 -> 合併排序
范式 -> 範式

* Fix 算法 -> 演算法

* 錶示 -> 表示
反碼 -> 一補數
補碼 -> 二補數
列列尾部 -> 佇列尾部
區域性性 -> 區域性
一摞 -> 一疊

* Synchronize with main branch

* 賬號 -> 帳號
推匯 -> 推導

* Sync with main branch

* First commit

* Update mkdocs.yml

* Translate all the docs to traditional Chinese

* Translate the code files.

* Translate the docker file

* Fix mkdocs.yml

* Translate all the figures from SC to TC

* 二叉搜尋樹 -> 二元搜尋樹

* Update terminology

* 构造函数/构造方法 -> 建構子
异或 -> 互斥或

* 擴充套件 -> 擴展

* constant - 常量 - 常數

* 類	-> 類別

* AVL -> AVL 樹

* 數組 -> 陣列

* 係統 -> 系統
斐波那契數列 -> 費波那契數列
運算元量 -> 運算量
引數 -> 參數

* 聯絡 -> 關聯

* 麵試 -> 面試

* 面向物件 -> 物件導向
歸併排序 -> 合併排序
范式 -> 範式

* Fix 算法 -> 演算法

* 錶示 -> 表示
反碼 -> 一補數
補碼 -> 二補數
列列尾部 -> 佇列尾部
區域性性 -> 區域性
一摞 -> 一疊

* Synchronize with main branch

* 賬號 -> 帳號
推匯 -> 推導

* Sync with main branch

* Update terminology.md

* 操作数量（num. of operations）-> 操作數量

* 字首和->前綴和

* Update figures

* 歸 -> 迴
記憶體洩漏 -> 記憶體流失

* Fix the bug of the file filter

* 支援 -> 支持
Add zh-Hant/README.md

* Add the zh-Hant chapter covers.
Bug fixes.

* 外掛 -> 擴充功能

* Add the landing page for zh-Hant version

* Unify the font of the chapter covers for the zh, en, and zh-Hant version

* Move zh-Hant/ to zh-hant/

* Translate terminology.md to traditional Chinese
This commit is contained in:
Yudong Jin
2024-04-06 02:30:11 +08:00
committed by GitHub
parent 33d7f8a2e5
commit 5f7385c8a3
1875 changed files with 102923 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files
zh-hant/codes/cpp/.gitignore
+10
View File
@@ -0,0 +1,10 @@
# Ignore all
*
# Unignore all with extensions
!*.*
# Unignore all dirs
!*/
*.dSYM/
build/
zh-hant/codes/cpp/CMakeLists.txt
+20
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)
zh-hant/codes/cpp/chapter_array_and_linkedlist/CMakeLists.txt
+4
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)
zh-hant/codes/cpp/chapter_array_and_linkedlist/array.cpp
+113
View File
@@ -0,0 +1,113 @@
/**
* File: array.cpp
* Created Time: 2022-11-25
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 隨機訪問元素 */
int randomAccess(int *nums, int size) {
// 在區間 [0, size) 中隨機抽取一個數字
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 */
void insert(int *nums, int size, int num, int index) {
// 把索引 index 以及之後的所有元素向後移動一位
for (int i = size - 1; i > index; i--) {
nums[i] = nums[i - 1];
}
// 將 num 賦給 index 處的元素
nums[index] = num;
}
/* 刪除索引 index 處的元素 */
void remove(int *nums, int size, int index) {
// 把索引 index 之後的所有元素向前移動一位
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)
return i;
}
return -1;
}
/* Driver Code */
int main() {
/* 初始化陣列 */
int size = 5;
int *arr = new int[size];
cout << "陣列 arr = ";
printArray(arr, size);
int *nums = new int[size]{1, 3, 2, 5, 4};
cout << "陣列 nums = ";
printArray(nums, size);
/* 隨機訪問 */
int randomNum = randomAccess(nums, size);
cout << "在 nums 中獲取隨機元素 " << randomNum << endl;
/* 長度擴展 */
int enlarge = 3;
nums = extend(nums, size, enlarge);
size += enlarge;
cout << "將陣列長度擴展至 8 ，得到 nums = ";
printArray(nums, size);
/* 插入元素 */
insert(nums, size, 6, 3);
cout << "在索引 3 處插入數字 6 ，得到 nums = ";
printArray(nums, size);
/* 刪除元素 */
remove(nums, size, 2);
cout << "刪除索引 2 處的元素，得到 nums = ";
printArray(nums, size);
/* 走訪陣列 */
traverse(nums, size);
/* 查詢元素 */
int index = find(nums, size, 3);
cout << "在 nums 中查詢元素 3 ，得到索引 = " << index << endl;
// 釋放記憶體
delete[] arr;
delete[] nums;
return 0;
}
zh-hant/codes/cpp/chapter_array_and_linkedlist/linked_list.cpp
+89
View File
@@ -0,0 +1,89 @@
/**
* File: linked_list.cpp
* Created Time: 2022-11-25
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 在鏈結串列的節點 n0 之後插入節點 P */
void insert(ListNode *n0, ListNode *P) {
ListNode *n1 = n0->next;
P->next = n1;
n0->next = P;
}
/* 刪除鏈結串列的節點 n0 之後的首個節點 */
void remove(ListNode *n0) {
if (n0->next == nullptr)
return;
// n0 -> P -> n1
ListNode *P = n0->next;
ListNode *n1 = P->next;
n0->next = n1;
// 釋放記憶體
delete P;
}
/* 訪問鏈結串列中索引為 index 的節點 */
ListNode *access(ListNode *head, int index) {
for (int i = 0; i < index; i++) {
if (head == nullptr)
return nullptr;
head = head->next;
}
return head;
}
/* 在鏈結串列中查詢值為 target 的首個節點 */
int find(ListNode *head, int target) {
int index = 0;
while (head != nullptr) {
if (head->val == target)
return index;
head = head->next;
index++;
}
return -1;
}
/* Driver Code */
int main() {
/* 初始化鏈結串列 */
// 初始化各個節點
ListNode *n0 = new ListNode(1);
ListNode *n1 = new ListNode(3);
ListNode *n2 = new ListNode(2);
ListNode *n3 = new ListNode(5);
ListNode *n4 = new ListNode(4);
// 構建節點之間的引用
n0->next = n1;
n1->next = n2;
n2->next = n3;
n3->next = n4;
cout << "初始化的鏈結串列為" << endl;
printLinkedList(n0);
/* 插入節點 */
insert(n0, new ListNode(0));
cout << "插入節點後的鏈結串列為" << endl;
printLinkedList(n0);
/* 刪除節點 */
remove(n0);
cout << "刪除節點後的鏈結串列為" << endl;
printLinkedList(n0);
/* 訪問節點 */
ListNode *node = access(n0, 3);
cout << "鏈結串列中索引 3 處的節點的值 = " << node->val << endl;
/* 查詢節點 */
int index = find(n0, 2);
cout << "鏈結串列中值為 2 的節點的索引 = " << index << endl;
// 釋放記憶體
freeMemoryLinkedList(n0);
return 0;
}
zh-hant/codes/cpp/chapter_array_and_linkedlist/list.cpp
+72
View File
@@ -0,0 +1,72 @@
/**
* File: list.cpp
* Created Time: 2022-11-25
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* Driver Code */
int main() {
/* 初始化串列 */
vector<int> nums = {1, 3, 2, 5, 4};
cout << "串列 nums = ";
printVector(nums);
/* 訪問元素 */
int num = nums[1];
cout << "訪問索引 1 處的元素，得到 num = " << num << endl;
/* 更新元素 */
nums[1] = 0;
cout << "將索引 1 處的元素更新為 0 ，得到 nums = ";
printVector(nums);
/* 清空串列 */
nums.clear();
cout << "清空串列後 nums = ";
printVector(nums);
/* 在尾部新增元素 */
nums.push_back(1);
nums.push_back(3);
nums.push_back(2);
nums.push_back(5);
nums.push_back(4);
cout << "新增元素後 nums = ";
printVector(nums);
/* 在中間插入元素 */
nums.insert(nums.begin() + 3, 6);
cout << "在索引 3 處插入數字 6 ，得到 nums = ";
printVector(nums);
/* 刪除元素 */
nums.erase(nums.begin() + 3);
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;
}
/* 拼接兩個串列 */
vector<int> nums1 = {6, 8, 7, 10, 9};
nums.insert(nums.end(), nums1.begin(), nums1.end());
cout << "將串列 nums1 拼接到 nums 之後，得到 nums = ";
printVector(nums);
/* 排序串列 */
sort(nums.begin(), nums.end());
cout << "排序串列後 nums = ";
printVector(nums);
return 0;
}
zh-hant/codes/cpp/chapter_array_and_linkedlist/my_list.cpp
+171
View File
@@ -0,0 +1,171 @@
/**
* File: my_list.cpp
* Created Time: 2022-11-25
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 串列類別 */
class MyList {
private:
int *arr; // 陣列（儲存串列元素）
int arrCapacity = 10; // 串列容量
int arrSize = 0; // 串列長度（當前元素數量）
int extendRatio = 2; // 每次串列擴容的倍數
public:
/* 建構子 */
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("索引越界");
return arr[index];
}
/* 更新元素 */
void set(int index, int num) {
if (index < 0 || index >= size())
throw out_of_range("索引越界");
arr[index] = num;
}
/* 在尾部新增元素 */
void add(int num) {
// 元素數量超出容量時，觸發擴容機制
if (size() == capacity())
extendCapacity();
arr[size()] = num;
// 更新元素數量
arrSize++;
}
/* 在中間插入元素 */
void insert(int index, int num) {
if (index < 0 || index >= size())
throw out_of_range("索引越界");
// 元素數量超出容量時，觸發擴容機制
if (size() == capacity())
extendCapacity();
// 將索引 index 以及之後的元素都向後移動一位
for (int j = size() - 1; j >= index; j--) {
arr[j + 1] = arr[j];
}
arr[index] = num;
// 更新元素數量
arrSize++;
}
/* 刪除元素 */
int remove(int index) {
if (index < 0 || index >= size())
throw out_of_range("索引越界");
int num = arr[index];
// 將索引 index 之後的元素都向前移動一位
for (int j = index; j < size() - 1; j++) {
arr[j] = arr[j + 1];
}
// 更新元素數量
arrSize--;
// 返回被刪除的元素
return num;
}
/* 串列擴容 */
void extendCapacity() {
// 新建一個長度為原陣列 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<int> toVector() {
// 僅轉換有效長度範圍內的串列元素
vector<int> vec(size());
for (int i = 0; i < size(); i++) {
vec[i] = arr[i];
}
return vec;
}
};
/* Driver Code */
int main() {
/* 初始化串列 */
MyList *nums = new MyList();
/* 在尾部新增元素 */
nums->add(1);
nums->add(3);
nums->add(2);
nums->add(5);
nums->add(4);
cout << "串列 nums = ";
vector<int> vec = nums->toVector();
printVector(vec);
cout << "容量 = " << nums->capacity() << " ，長度 = " << nums->size() << endl;
/* 在中間插入元素 */
nums->insert(3, 6);
cout << "在索引 3 處插入數字 6 ，得到 nums = ";
vec = nums->toVector();
printVector(vec);
/* 刪除元素 */
nums->remove(3);
cout << "刪除索引 3 處的元素，得到 nums = ";
vec = nums->toVector();
printVector(vec);
/* 訪問元素 */
int num = nums->get(1);
cout << "訪問索引 1 處的元素，得到 num = " << num << endl;
/* 更新元素 */
nums->set(1, 0);
cout << "將索引 1 處的元素更新為 0 ，得到 nums = ";
vec = nums->toVector();
printVector(vec);
/* 測試擴容機制 */
for (int i = 0; i < 10; i++) {
// 在 i = 5 時，串列長度將超出串列容量，此時觸發擴容機制
nums->add(i);
}
cout << "擴容後的串列 nums = ";
vec = nums->toVector();
printVector(vec);
cout << "容量 = " << nums->capacity() << " ，長度 = " << nums->size() << endl;
// 釋放記憶體
delete nums;
return 0;
}
zh-hant/codes/cpp/chapter_backtracking/CMakeLists.txt
+10
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)
zh-hant/codes/cpp/chapter_backtracking/n_queens.cpp
+65
View File
@@ -0,0 +1,65 @@
/**
* File: n_queens.cpp
* Created Time: 2023-05-04
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 回溯演算法：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 皇后 */
vector<vector<vector<string>>> nQueens(int n) {
// 初始化 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<vector<vector<string>>> res;
backtrack(0, n, state, res, cols, diags1, diags2);
return res;
}
/* Driver Code */
int main() {
int n = 4;
vector<vector<vector<string>>> res = nQueens(n);
cout << "輸入棋盤長寬為 " << n << endl;
cout << "皇后放置方案共有 " << res.size() << " 種" << endl;
for (const vector<vector<string>> &state : res) {
cout << "--------------------" << endl;
for (const vector<string> &row : state) {
printVector(row);
}
}
return 0;
}
zh-hant/codes/cpp/chapter_backtracking/permutations_i.cpp
+54
View File
@@ -0,0 +1,54 @@
/**
* File: permutations_i.cpp
* Created Time: 2023-04-24
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 回溯演算法：全排列 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;
}
// 走訪所有選擇
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 */
vector<vector<int>> permutationsI(vector<int> nums) {
vector<int> state;
vector<bool> selected(nums.size(), false);
vector<vector<int>> res;
backtrack(state, nums, selected, res);
return res;
}
/* Driver Code */
int main() {
vector<int> nums = {1, 2, 3};
vector<vector<int>> res = permutationsI(nums);
cout << "輸入陣列 nums = ";
printVector(nums);
cout << "所有排列 res = ";
printVectorMatrix(res);
return 0;
}
zh-hant/codes/cpp/chapter_backtracking/permutations_ii.cpp
+56
View File
@@ -0,0 +1,56 @@
/**
* File: permutations_ii.cpp
* Created Time: 2023-04-24
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 回溯演算法：全排列 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;
}
// 走訪所有選擇
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); // 記錄選擇過的元素值
selected[i] = true;
state.push_back(choice);
// 進行下一輪選擇
backtrack(state, choices, selected, res);
// 回退：撤銷選擇，恢復到之前的狀態
selected[i] = false;
state.pop_back();
}
}
}
/* 全排列 II */
vector<vector<int>> permutationsII(vector<int> nums) {
vector<int> state;
vector<bool> selected(nums.size(), false);
vector<vector<int>> res;
backtrack(state, nums, selected, res);
return res;
}
/* Driver Code */
int main() {
vector<int> nums = {1, 1, 2};
vector<vector<int>> res = permutationsII(nums);
cout << "輸入陣列 nums = ";
printVector(nums);
cout << "所有排列 res = ";
printVectorMatrix(res);
return 0;
}
zh-hant/codes/cpp/chapter_backtracking/preorder_traversal_i_compact.cpp
+39
View File
@@ -0,0 +1,39 @@
/**
* File: preorder_traversal_i_compact.cpp
* Created Time: 2023-04-16
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
vector<TreeNode *> res;
/* 前序走訪：例題一 */
void preOrder(TreeNode *root) {
if (root == nullptr) {
return;
}
if (root->val == 7) {
// 記錄解
res.push_back(root);
}
preOrder(root->left);
preOrder(root->right);
}
/* Driver Code */
int main() {
TreeNode *root = vectorToTree(vector<int>{1, 7, 3, 4, 5, 6, 7});
cout << "\n初始化二元樹" << endl;
printTree(root);
// 前序走訪
preOrder(root);
cout << "\n輸出所有值為 7 的節點" << endl;
vector<int> vals;
for (TreeNode *node : res) {
vals.push_back(node->val);
}
printVector(vals);
}
zh-hant/codes/cpp/chapter_backtracking/preorder_traversal_ii_compact.cpp
+46
View File
@@ -0,0 +1,46 @@
/**
* File: preorder_traversal_ii_compact.cpp
* Created Time: 2023-04-16
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
vector<TreeNode *> path;
vector<vector<TreeNode *>> res;
/* 前序走訪：例題二 */
void preOrder(TreeNode *root) {
if (root == nullptr) {
return;
}
// 嘗試
path.push_back(root);
if (root->val == 7) {
// 記錄解
res.push_back(path);
}
preOrder(root->left);
preOrder(root->right);
// 回退
path.pop_back();
}
/* Driver Code */
int main() {
TreeNode *root = vectorToTree(vector<int>{1, 7, 3, 4, 5, 6, 7});
cout << "\n初始化二元樹" << endl;
printTree(root);
// 前序走訪
preOrder(root);
cout << "\n輸出所有根節點到節點 7 的路徑" << endl;
for (vector<TreeNode *> &path : res) {
vector<int> vals;
for (TreeNode *node : path) {
vals.push_back(node->val);
}
printVector(vals);
}
}
zh-hant/codes/cpp/chapter_backtracking/preorder_traversal_iii_compact.cpp
+47
View File
@@ -0,0 +1,47 @@
/**
* File: preorder_traversal_iii_compact.cpp
* Created Time: 2023-04-16
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
vector<TreeNode *> path;
vector<vector<TreeNode *>> res;
/* 前序走訪：例題三 */
void preOrder(TreeNode *root) {
// 剪枝
if (root == nullptr || root->val == 3) {
return;
}
// 嘗試
path.push_back(root);
if (root->val == 7) {
// 記錄解
res.push_back(path);
}
preOrder(root->left);
preOrder(root->right);
// 回退
path.pop_back();
}
/* Driver Code */
int main() {
TreeNode *root = vectorToTree(vector<int>{1, 7, 3, 4, 5, 6, 7});
cout << "\n初始化二元樹" << endl;
printTree(root);
// 前序走訪
preOrder(root);
cout << "\n輸出所有根節點到節點 7 的路徑，要求路徑中不包含值為 3 的節點" << endl;
for (vector<TreeNode *> &path : res) {
vector<int> vals;
for (TreeNode *node : path) {
vals.push_back(node->val);
}
printVector(vals);
}
}
zh-hant/codes/cpp/chapter_backtracking/preorder_traversal_iii_template.cpp
+76
View File
@@ -0,0 +1,76 @@
/**
* File: preorder_traversal_iii_template.cpp
* Created Time: 2023-04-16
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 判斷當前狀態是否為解 */
bool isSolution(vector<TreeNode *> &state) {
return !state.empty() && state.back()->val == 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;
}
/* 更新狀態 */
void makeChoice(vector<TreeNode *> &state, TreeNode *choice) {
state.push_back(choice);
}
/* 恢復狀態 */
void undoChoice(vector<TreeNode *> &state, TreeNode *choice) {
state.pop_back();
}
/* 回溯演算法：例題三 */
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() {
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;
for (vector<TreeNode *> &path : res) {
vector<int> vals;
for (TreeNode *node : path) {
vals.push_back(node->val);
}
printVector(vals);
}
}
zh-hant/codes/cpp/chapter_backtracking/subset_sum_i.cpp
+57
View File
@@ -0,0 +1,57 @@
/**
* File: subset_sum_i.cpp
* Created Time: 2023-06-21
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 回溯演算法：子集和 I */
void backtrack(vector<int> &state, int target, vector<int> &choices, int start, vector<vector<int>> &res) {
// 子集和等於 target 時，記錄解
if (target == 0) {
res.push_back(state);
return;
}
// 走訪所有選擇
// 剪枝二：從 start 開始走訪，避免生成重複子集
for (int i = start; i < choices.size(); i++) {
// 剪枝一：若子集和超過 target ，則直接結束迴圈
// 這是因為陣列已排序，後邊元素更大，子集和一定超過 target
if (target - choices[i] < 0) {
break;
}
// 嘗試：做出選擇，更新 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) {
vector<int> state; // 狀態（子集）
sort(nums.begin(), nums.end()); // 對 nums 進行排序
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;
vector<vector<int>> res = subsetSumI(nums, target);
cout << "輸入陣列 nums = ";
printVector(nums);
cout << "target = " << target << endl;
cout << "所有和等於 " << target << " 的子集 res = " << endl;
printVectorMatrix(res);
return 0;
}
zh-hant/codes/cpp/chapter_backtracking/subset_sum_i_naive.cpp
+54
View File
@@ -0,0 +1,54 @@
/**
* File: subset_sum_i_naive.cpp
* Created Time: 2023-06-21
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 回溯演算法：子集和 I */
void backtrack(vector<int> &state, int target, int total, vector<int> &choices, vector<vector<int>> &res) {
// 子集和等於 target 時，記錄解
if (total == target) {
res.push_back(state);
return;
}
// 走訪所有選擇
for (size_t i = 0; i < choices.size(); i++) {
// 剪枝：若子集和超過 target ，則跳過該選擇
if (total + choices[i] > target) {
continue;
}
// 嘗試：做出選擇，更新元素和 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) {
vector<int> state; // 狀態（子集）
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;
vector<vector<int>> res = subsetSumINaive(nums, target);
cout << "輸入陣列 nums = ";
printVector(nums);
cout << "target = " << target << endl;
cout << "所有和等於 " << target << " 的子集 res = " << endl;
printVectorMatrix(res);
return 0;
}
zh-hant/codes/cpp/chapter_backtracking/subset_sum_ii.cpp
+62
View File
@@ -0,0 +1,62 @@
/**
* File: subset_sum_ii.cpp
* Created Time: 2023-06-21
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 回溯演算法：子集和 II */
void backtrack(vector<int> &state, int target, vector<int> &choices, int start, vector<vector<int>> &res) {
// 子集和等於 target 時，記錄解
if (target == 0) {
res.push_back(state);
return;
}
// 走訪所有選擇
// 剪枝二：從 start 開始走訪，避免生成重複子集
// 剪枝三：從 start 開始走訪，避免重複選擇同一元素
for (int i = start; i < choices.size(); i++) {
// 剪枝一：若子集和超過 target ，則直接結束迴圈
// 這是因為陣列已排序，後邊元素更大，子集和一定超過 target
if (target - choices[i] < 0) {
break;
}
// 剪枝四：如果該元素與左邊元素相等，說明該搜尋分支重複，直接跳過
if (i > start && choices[i] == choices[i - 1]) {
continue;
}
// 嘗試：做出選擇，更新 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) {
vector<int> state; // 狀態（子集）
sort(nums.begin(), nums.end()); // 對 nums 進行排序
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;
vector<vector<int>> res = subsetSumII(nums, target);
cout << "輸入陣列 nums = ";
printVector(nums);
cout << "target = " << target << endl;
cout << "所有和等於 " << target << " 的子集 res = " << endl;
printVectorMatrix(res);
return 0;
}
zh-hant/codes/cpp/chapter_computational_complexity/CMakeLists.txt
+5
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)
zh-hant/codes/cpp/chapter_computational_complexity/iteration.cpp
+76
View File
@@ -0,0 +1,76 @@
/**
* File: iteration.cpp
* Created Time: 2023-08-24
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* for 迴圈 */
int forLoop(int n) {
int res = 0;
// 迴圈求和 1, 2, ..., n-1, n
for (int i = 1; i <= n; ++i) {
res += i;
}
return res;
}
/* while 迴圈 */
int whileLoop(int n) {
int res = 0;
int i = 1; // 初始化條件變數
// 迴圈求和 1, 2, ..., n-1, n
while (i <= n) {
res += i;
i++; // 更新條件變數
}
return res;
}
/* while 迴圈（兩次更新） */
int whileLoopII(int n) {
int res = 0;
int i = 1; // 初始化條件變數
// 迴圈求和 1, 4, 10, ...
while (i <= n) {
res += i;
// 更新條件變數
i++;
i *= 2;
}
return res;
}
/* 雙層 for 迴圈 */
string nestedForLoop(int n) {
ostringstream res;
// 迴圈 i = 1, 2, ..., n-1, n
for (int i = 1; i <= n; ++i) {
// 迴圈 j = 1, 2, ..., n-1, n
for (int j = 1; j <= n; ++j) {
res << "(" << i << ", " << j << "), ";
}
}
return res.str();
}
/* Driver Code */
int main() {
int n = 5;
int res;
res = forLoop(n);
cout << "\nfor 迴圈的求和結果 res = " << res << endl;
res = whileLoop(n);
cout << "\nwhile 迴圈的求和結果 res = " << res << endl;
res = whileLoopII(n);
cout << "\nwhile 迴圈（兩次更新）求和結果 res = " << res << endl;
string resStr = nestedForLoop(n);
cout << "\n雙層 for 迴圈的走訪結果 " << resStr << endl;
return 0;
}
zh-hant/codes/cpp/chapter_computational_complexity/recursion.cpp
+78
View File
@@ -0,0 +1,78 @@
/**
* File: recursion.cpp
* Created Time: 2023-08-24
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 遞迴 */
int recur(int n) {
// 終止條件
if (n == 1)
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();
}
// res = 1+2+3+...+n
return res;
}
/* 尾遞迴 */
int tailRecur(int n, int res) {
// 終止條件
if (n == 0)
return res;
// 尾遞迴呼叫
return tailRecur(n - 1, res + n);
}
/* 費波那契數列：遞迴 */
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)
int res = fib(n - 1) + fib(n - 2);
// 返回結果 f(n)
return res;
}
/* Driver Code */
int main() {
int n = 5;
int res;
res = recur(n);
cout << "\n遞迴函式的求和結果 res = " << res << endl;
res = forLoopRecur(n);
cout << "\n使用迭代模擬遞迴求和結果 res = " << res << endl;
res = tailRecur(n, 0);
cout << "\n尾遞迴函式的求和結果 res = " << res << endl;
res = fib(n);
cout << "\n費波那契數列的第 " << n << " 項為 " << res << endl;
return 0;
}
zh-hant/codes/cpp/chapter_computational_complexity/space_complexity.cpp
+107
View File
@@ -0,0 +1,107 @@
/**
* File: space_complexity.cpp
* Created Time: 2022-11-25
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 函式 */
int func() {
// 執行某些操作
return 0;
}
/* 常數階 */
void constant(int n) {
// 常數、變數、物件佔用 O(1) 空間
const int a = 0;
int b = 0;
vector<int> nums(10000);
ListNode node(0);
// 迴圈中的變數佔用 O(1) 空間
for (int i = 0; i < n; i++) {
int c = 0;
}
// 迴圈中的函式佔用 O(1) 空間
for (int i = 0; i < n; i++) {
func();
}
}
/* 線性階 */
void linear(int n) {
// 長度為 n 的陣列佔用 O(n) 空間
vector<int> nums(n);
// 長度為 n 的串列佔用 O(n) 空間
vector<ListNode> nodes;
for (int i = 0; i < n; i++) {
nodes.push_back(ListNode(i));
}
// 長度為 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)
return;
linearRecur(n - 1);
}
/* 平方階 */
void quadratic(int n) {
// 二維串列佔用 O(n^2) 空間
vector<vector<int>> numMatrix;
for (int i = 0; i < n; i++) {
vector<int> tmp;
for (int j = 0; j < n; j++) {
tmp.push_back(0);
}
numMatrix.push_back(tmp);
}
}
/* 平方階（遞迴實現） */
int quadraticRecur(int n) {
if (n <= 0)
return 0;
vector<int> nums(n);
cout << "遞迴 n = " << n << " 中的 nums 長度 = " << nums.size() << endl;
return quadraticRecur(n - 1);
}
/* 指數階（建立滿二元樹） */
TreeNode *buildTree(int n) {
if (n == 0)
return nullptr;
TreeNode *root = new TreeNode(0);
root->left = buildTree(n - 1);
root->right = buildTree(n - 1);
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;
}
zh-hant/codes/cpp/chapter_computational_complexity/time_complexity.cpp
+168
View File
@@ -0,0 +1,168 @@
/**
* File: time_complexity.cpp
* Created Time: 2022-11-25
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 常數階 */
int constant(int n) {
int count = 0;
int size = 100000;
for (int i = 0; i < size; i++)
count++;
return count;
}
/* 線性階 */
int linear(int n) {
int count = 0;
for (int i = 0; i < n; i++)
count++;
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 成平方關係
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
count++;
}
}
return count;
}
/* 平方階（泡沫排序） */
int bubbleSort(vector<int> &nums) {
int count = 0; // 計數器
// 外迴圈：未排序區間為 [0, i]
for (int i = nums.size() - 1; i > 0; i--) {
// 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端
for (int j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交換 nums[j] 與 nums[j + 1]
int tmp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = tmp;
count += 3; // 元素交換包含 3 個單元操作
}
}
}
return count;
}
/* 指數階（迴圈實現） */
int exponential(int n) {
int count = 0, base = 1;
// 細胞每輪一分為二，形成數列 1, 2, 4, 8, ..., 2^(n-1)
for (int i = 0; i < n; i++) {
for (int j = 0; j < base; j++) {
count++;
}
base *= 2;
}
// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
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) {
n = n / 2;
count++;
}
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;
int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);
for (int i = 0; i < n; i++) {
count++;
}
return count;
}
/* 階乘階（遞迴實現） */
int factorialRecur(int n) {
if (n == 0)
return 1;
int count = 0;
// 從 1 個分裂出 n 個
for (int i = 0; i < n; i++) {
count += factorialRecur(n - 1);
}
return count;
}
/* Driver Code */
int main() {
// 可以修改 n 執行，體會一下各種複雜度的操作數量變化趨勢
int n = 8;
cout << "輸入資料大小 n = " << n << endl;
int count = constant(n);
cout << "常數階的操作數量 = " << count << endl;
count = linear(n);
cout << "線性階的操作數量 = " << count << endl;
vector<int> arr(n);
count = arrayTraversal(arr);
cout << "線性階（走訪陣列）的操作數量 = " << count << endl;
count = quadratic(n);
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;
count = exponential(n);
cout << "指數階（迴圈實現）的操作數量 = " << count << endl;
count = expRecur(n);
cout << "指數階（遞迴實現）的操作數量 = " << count << endl;
count = logarithmic(n);
cout << "對數階（迴圈實現）的操作數量 = " << count << endl;
count = logRecur(n);
cout << "對數階（遞迴實現）的操作數量 = " << count << endl;
count = linearLogRecur(n);
cout << "線性對數階（遞迴實現）的操作數量 = " << count << endl;
count = factorialRecur(n);
cout << "階乘階（遞迴實現）的操作數量 = " << count << endl;
return 0;
}
zh-hant/codes/cpp/chapter_computational_complexity/worst_best_time_complexity.cpp
+45
View File
@@ -0,0 +1,45 @@
/**
* File: worst_best_time_complexity.cpp
* Created Time: 2022-11-25
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 生成一個陣列，元素為 { 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 所在索引 */
int findOne(vector<int> &nums) {
for (int i = 0; i < nums.size(); i++) {
// 當元素 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 ] 被打亂後 = ";
printVector(nums);
cout << "數字 1 的索引為 " << index << endl;
}
return 0;
}
zh-hant/codes/cpp/chapter_divide_and_conquer/CMakeLists.txt
+3
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)
zh-hant/codes/cpp/chapter_divide_and_conquer/binary_search_recur.cpp
+46
View File
@@ -0,0 +1,46 @@
/**
* File: binary_search_recur.cpp
* Created Time: 2023-07-17
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 二分搜尋：問題 f(i, j) */
int dfs(vector<int> &nums, int target, int i, int j) {
// 若區間為空，代表無目標元素，則返回 -1
if (i > j) {
return -1;
}
// 計算中點索引 m
int m = (i + j) / 2;
if (nums[m] < target) {
// 遞迴子問題 f(m+1, j)
return dfs(nums, target, m + 1, j);
} else if (nums[m] > target) {
// 遞迴子問題 f(i, m-1)
return dfs(nums, target, i, m - 1);
} else {
// 找到目標元素，返回其索引
return m;
}
}
/* 二分搜尋 */
int binarySearch(vector<int> &nums, int target) {
int n = nums.size();
// 求解問題 f(0, n-1)
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;
return 0;
}
zh-hant/codes/cpp/chapter_divide_and_conquer/build_tree.cpp
+51
View File
@@ -0,0 +1,51 @@
/**
* File: build_tree.cpp
* Created Time: 2023-07-17
* Author: krahets (krahets@163.com)
*/
#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 ，從而劃分左右子樹
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;
}
TreeNode *root = dfs(preorder, inorderMap, 0, 0, inorder.size() - 1);
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 << "中序走訪 = ";
printVector(inorder);
TreeNode *root = buildTree(preorder, inorder);
cout << "構建的二元樹為：\n";
printTree(root);
return 0;
}
zh-hant/codes/cpp/chapter_divide_and_conquer/hanota.cpp
+66
View File
@@ -0,0 +1,66 @@
/**
* File: hanota.cpp
* Created Time: 2023-07-17
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 移動一個圓盤 */
void move(vector<int> &src, vector<int> &tar) {
// 從 src 頂部拿出一個圓盤
int pan = src.back();
src.pop_back();
// 將圓盤放入 tar 頂部
tar.push_back(pan);
}
/* 求解河內塔問題 f(i) */
void dfs(int i, vector<int> &src, vector<int> &buf, vector<int> &tar) {
// 若 src 只剩下一個圓盤，則直接將其移到 tar
if (i == 1) {
move(src, tar);
return;
}
// 子問題 f(i-1) ：將 src 頂部 i-1 個圓盤藉助 tar 移到 buf
dfs(i - 1, src, tar, buf);
// 子問題 f(1) ：將 src 剩餘一個圓盤移到 tar
move(src, 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();
// 將 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 << "A =";
printVector(A);
cout << "B =";
printVector(B);
cout << "C =";
printVector(C);
solveHanota(A, B, C);
cout << "圓盤移動完成後：\n";
cout << "A =";
printVector(A);
cout << "B =";
printVector(B);
cout << "C =";
printVector(C);
return 0;
}
zh-hant/codes/cpp/chapter_dynamic_programming/CMakeLists.txt
+10
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)
zh-hant/codes/cpp/chapter_dynamic_programming/climbing_stairs_backtrack.cpp
+43
View File
@@ -0,0 +1,43 @@
/**
* File: climbing_stairs_backtrack.cpp
* Created Time: 2023-06-30
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 回溯 */
void backtrack(vector<int> &choices, int state, int n, vector<int> &res) {
// 當爬到第 n 階時，方案數量加 1
if (state == n)
res[0]++;
// 走訪所有選擇
for (auto &choice : choices) {
// 剪枝：不允許越過第 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] 記錄方案數量
backtrack(choices, state, n, res);
return res[0];
}
/* Driver Code */
int main() {
int n = 9;
int res = climbingStairsBacktrack(n);
cout << "爬 " << n << " 階樓梯共有 " << res << " 種方案" << endl;
return 0;
}
zh-hant/codes/cpp/chapter_dynamic_programming/climbing_stairs_constraint_dp.cpp
+37
View File
@@ -0,0 +1,37 @@
/**
* File: climbing_stairs_constraint_dp.cpp
* Created Time: 2023-07-01
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 帶約束爬樓梯：動態規劃 */
int climbingStairsConstraintDP(int n) {
if (n == 1 || n == 2) {
return 1;
}
// 初始化 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];
}
return dp[n][1] + dp[n][2];
}
/* Driver Code */
int main() {
int n = 9;
int res = climbingStairsConstraintDP(n);
cout << "爬 " << n << " 階樓梯共有 " << res << " 種方案" << endl;
return 0;
}
zh-hant/codes/cpp/chapter_dynamic_programming/climbing_stairs_dfs.cpp
+32
View File
@@ -0,0 +1,32 @@
/**
* File: climbing_stairs_dfs.cpp
* Created Time: 2023-06-30
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 搜尋 */
int dfs(int i) {
// 已知 dp[1] 和 dp[2] ，返回之
if (i == 1 || i == 2)
return i;
// dp[i] = dp[i-1] + dp[i-2]
int count = dfs(i - 1) + dfs(i - 2);
return count;
}
/* 爬樓梯：搜尋 */
int climbingStairsDFS(int n) {
return dfs(n);
}
/* Driver Code */
int main() {
int n = 9;
int res = climbingStairsDFS(n);
cout << "爬 " << n << " 階樓梯共有 " << res << " 種方案" << endl;
return 0;
}
zh-hant/codes/cpp/chapter_dynamic_programming/climbing_stairs_dfs_mem.cpp
+39
View File
@@ -0,0 +1,39 @@
/**
* File: climbing_stairs_dfs_mem.cpp
* Created Time: 2023-06-30
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 記憶化搜尋 */
int dfs(int i, vector<int> &mem) {
// 已知 dp[1] 和 dp[2] ，返回之
if (i == 1 || i == 2)
return 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]
mem[i] = count;
return count;
}
/* 爬樓梯：記憶化搜尋 */
int climbingStairsDFSMem(int n) {
// 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;
return 0;
}
zh-hant/codes/cpp/chapter_dynamic_programming/climbing_stairs_dp.cpp
+49
View File
@@ -0,0 +1,49 @@
/**
* File: climbing_stairs_dp.cpp
* Created Time: 2023-06-30
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 爬樓梯：動態規劃 */
int climbingStairsDP(int n) {
if (n == 1 || n == 2)
return n;
// 初始化 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;
int a = 1, b = 2;
for (int i = 3; i <= n; i++) {
int tmp = b;
b = a + b;
a = tmp;
}
return b;
}
/* Driver Code */
int main() {
int n = 9;
int res = climbingStairsDP(n);
cout << "爬 " << n << " 階樓梯共有 " << res << " 種方案" << endl;
res = climbingStairsDPComp(n);
cout << "爬 " << n << " 階樓梯共有 " << res << " 種方案" << endl;
return 0;
}
zh-hant/codes/cpp/chapter_dynamic_programming/coin_change.cpp
+70
View File
@@ -0,0 +1,70 @@
/**
* File: coin_change.cpp
* Created Time: 2023-07-11
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 零錢兌換：動態規劃 */
int coinChangeDP(vector<int> &coins, int amt) {
int n = coins.size();
int MAX = amt + 1;
// 初始化 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
dp[i][a] = dp[i - 1][a];
} else {
// 不選和選硬幣 i 這兩種方案的較小值
dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);
}
}
}
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 表
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
dp[a] = dp[a];
} else {
// 不選和選硬幣 i 這兩種方案的較小值
dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1);
}
}
}
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;
// 空間最佳化後的動態規劃
res = coinChangeDPComp(coins, amt);
cout << "湊到目標金額所需的最少硬幣數量為 " << res << endl;
return 0;
}
zh-hant/codes/cpp/chapter_dynamic_programming/coin_change_ii.cpp
+68
View File
@@ -0,0 +1,68 @@
/**
* File: coin_change_ii.cpp
* Created Time: 2023-07-11
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 零錢兌換 II：動態規劃 */
int coinChangeIIDP(vector<int> &coins, int amt) {
int n = coins.size();
// 初始化 dp 表
vector<vector<int>> dp(n + 1, vector<int>(amt + 1, 0));
// 初始化首列
for (int i = 0; i <= n; i++) {
dp[i][0] = 1;
}
// 狀態轉移
for (int i = 1; i <= n; i++) {
for (int a = 1; a <= amt; a++) {
if (coins[i - 1] > a) {
// 若超過目標金額，則不選硬幣 i
dp[i][a] = dp[i - 1][a];
} else {
// 不選和選硬幣 i 這兩種方案之和
dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];
}
}
}
return dp[n][amt];
}
/* 零錢兌換 II：空間最佳化後的動態規劃 */
int coinChangeIIDPComp(vector<int> &coins, int amt) {
int n = coins.size();
// 初始化 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
dp[a] = dp[a];
} else {
// 不選和選硬幣 i 這兩種方案之和
dp[a] = dp[a] + dp[a - coins[i - 1]];
}
}
}
return dp[amt];
}
/* Driver code */
int main() {
vector<int> coins = {1, 2, 5};
int amt = 5;
// 動態規劃
int res = coinChangeIIDP(coins, amt);
cout << "湊出目標金額的硬幣組合數量為 " << res << endl;
// 空間最佳化後的動態規劃
res = coinChangeIIDPComp(coins, amt);
cout << "湊出目標金額的硬幣組合數量為 " << res << endl;
return 0;
}
zh-hant/codes/cpp/chapter_dynamic_programming/edit_distance.cpp
+136
View File
@@ -0,0 +1,136 @@
/**
* File: edit_distance.cpp
* Created Time: 2023-07-13
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 編輯距離：暴力搜尋 */
int editDistanceDFS(string s, string t, 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 (s[i - 1] == t[j - 1])
return editDistanceDFS(s, t, i - 1, j - 1);
// 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 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];
// 若兩字元相等，則直接跳過此兩字元
if (s[i - 1] == t[j - 1])
return editDistanceDFSMem(s, t, mem, i - 1, j - 1);
// 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 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]) {
// 若兩字元相等，則直接跳過此兩字元
dp[i][j] = dp[i - 1][j - 1];
} else {
// 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1
dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;
}
}
}
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]) {
// 若兩字元相等，則直接跳過此兩字元
dp[j] = leftup;
} else {
// 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 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 << " 步\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 << " 步\n";
// 空間最佳化後的動態規劃
res = editDistanceDPComp(s, t);
cout << "將 " << s << " 更改為 " << t << " 最少需要編輯 " << res << " 步\n";
return 0;
}
zh-hant/codes/cpp/chapter_dynamic_programming/knapsack.cpp
+109
View File
@@ -0,0 +1,109 @@
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
/* 0-1 背包：暴力搜尋 */
int knapsackDFS(vector<int> &wgt, vector<int> &val, int i, int c) {
// 若已選完所有物品或背包無剩餘容量，則返回價值 0
if (i == 0 || c == 0) {
return 0;
}
// 若超過背包容量，則只能選擇不放入背包
if (wgt[i - 1] > c) {
return knapsackDFS(wgt, val, i - 1, c);
}
// 計算不放入和放入物品 i 的最大價值
int no = knapsackDFS(wgt, val, i - 1, c);
int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];
// 返回兩種方案中價值更大的那一個
return max(no, yes);
}
/* 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];
// 記錄並返回兩種方案中價值更大的那一個
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 表
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
dp[i][c] = dp[i - 1][c];
} else {
// 不選和選物品 i 這兩種方案的較大值
dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);
}
}
}
return dp[n][cap];
}
/* 0-1 背包：空間最佳化後的動態規劃 */
int knapsackDPComp(vector<int> &wgt, vector<int> &val, int cap) {
int n = wgt.size();
// 初始化 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 這兩種方案的較大值
dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
}
}
}
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;
// 記憶化搜尋
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;
// 空間最佳化後的動態規劃
res = knapsackDPComp(wgt, val, cap);
cout << "不超過背包容量的最大物品價值為 " << res << endl;
return 0;
}
zh-hant/codes/cpp/chapter_dynamic_programming/min_cost_climbing_stairs_dp.cpp
+53
View File
@@ -0,0 +1,53 @@
/**
* File: min_cost_climbing_stairs_dp.cpp
* Created Time: 2023-06-30
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 爬樓梯最小代價：動態規劃 */
int minCostClimbingStairsDP(vector<int> &cost) {
int n = cost.size() - 1;
if (n == 1 || n == 2)
return cost[n];
// 初始化 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)
return cost[n];
int a = cost[1], b = cost[2];
for (int i = 3; i <= n; i++) {
int tmp = b;
b = min(a, tmp) + cost[i];
a = tmp;
}
return b;
}
/* Driver Code */
int main() {
vector<int> cost = {0, 1, 10, 1, 1, 1, 10, 1, 1, 10, 1};
cout << "輸入樓梯的代價串列為 ";
printVector(cost);
int res = minCostClimbingStairsDP(cost);
cout << "爬完樓梯的最低代價為 " << res << endl;
res = minCostClimbingStairsDPComp(cost);
cout << "爬完樓梯的最低代價為 " << res << endl;
return 0;
}
zh-hant/codes/cpp/chapter_dynamic_programming/min_path_sum.cpp
+116
View File
@@ -0,0 +1,116 @@
/**
* File: min_path_sum.cpp
* Created Time: 2023-07-10
* Author: krahets (krahets@163.com)
*/
#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) 的最小路徑代價
int up = minPathSumDFS(grid, i - 1, j);
int left = minPathSumDFS(grid, i, j - 1);
// 返回從左上角到 (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 表
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];
}
}
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}};
int n = grid.size(), m = grid[0].size();
// 暴力搜尋
int res = minPathSumDFS(grid, n - 1, m - 1);
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;
// 空間最佳化後的動態規劃
res = minPathSumDPComp(grid);
cout << "從左上角到右下角的最小路徑和為 " << res << endl;
return 0;
}
zh-hant/codes/cpp/chapter_dynamic_programming/unbounded_knapsack.cpp
+64
View File
@@ -0,0 +1,64 @@
/**
* File: unbounded_knapsack.cpp
* Created Time: 2023-07-11
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 完全背包：動態規劃 */
int unboundedKnapsackDP(vector<int> &wgt, vector<int> &val, int cap) {
int n = wgt.size();
// 初始化 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
dp[i][c] = dp[i - 1][c];
} else {
// 不選和選物品 i 這兩種方案的較大值
dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);
}
}
}
return dp[n][cap];
}
/* 完全背包：空間最佳化後的動態規劃 */
int unboundedKnapsackDPComp(vector<int> &wgt, vector<int> &val, int cap) {
int n = wgt.size();
// 初始化 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
dp[c] = dp[c];
} else {
// 不選和選物品 i 這兩種方案的較大值
dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
}
}
}
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;
// 空間最佳化後的動態規劃
res = unboundedKnapsackDPComp(wgt, val, cap);
cout << "不超過背包容量的最大物品價值為 " << res << endl;
return 0;
}
zh-hant/codes/cpp/chapter_graph/CMakeLists.txt
+5
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)
zh-hant/codes/cpp/chapter_graph/graph_adjacency_list.cpp
+90
View File
@@ -0,0 +1,90 @@
/**
* File: graph_adjacency_list.cpp
* Created Time: 2023-02-09
* Author: what-is-me (whatisme@outlook.jp), krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 基於鄰接表實現的無向圖類別 */
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) {
vec.erase(vec.begin() + i);
break;
}
}
}
/* 建構子 */
GraphAdjList(const vector<vector<Vertex *>> &edges) {
// 新增所有頂點和邊
for (const vector<Vertex *> &edge : edges) {
addVertex(edge[0]);
addVertex(edge[1]);
addEdge(edge[0], edge[1]);
}
}
/* 獲取頂點數量 */
int size() {
return adjList.size();
}
/* 新增邊 */
void addEdge(Vertex *vet1, Vertex *vet2) {
if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)
throw invalid_argument("不存在頂點");
// 新增邊 vet1 - vet2
adjList[vet1].push_back(vet2);
adjList[vet2].push_back(vet1);
}
/* 刪除邊 */
void removeEdge(Vertex *vet1, Vertex *vet2) {
if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)
throw invalid_argument("不存在頂點");
// 刪除邊 vet1 - vet2
remove(adjList[vet1], vet2);
remove(adjList[vet2], vet1);
}
/* 新增頂點 */
void addVertex(Vertex *vet) {
if (adjList.count(vet))
return;
// 在鄰接表中新增一個新鏈結串列
adjList[vet] = vector<Vertex *>();
}
/* 刪除頂點 */
void removeVertex(Vertex *vet) {
if (!adjList.count(vet))
throw invalid_argument("不存在頂點");
// 在鄰接表中刪除頂點 vet 對應的鏈結串列
adjList.erase(vet);
// 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊
for (auto &adj : adjList) {
remove(adj.second, vet);
}
}
/* 列印鄰接表 */
void print() {
cout << "鄰接表 =" << endl;
for (auto &adj : adjList) {
const auto &key = adj.first;
const auto &vec = adj.second;
cout << key->val << ": ";
printVector(vetsToVals(vec));
}
}
};
// 測試樣例請見 graph_adjacency_list_test.cpp
zh-hant/codes/cpp/chapter_graph/graph_adjacency_list_test.cpp
+49
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;
}
zh-hant/codes/cpp/chapter_graph/graph_adjacency_matrix.cpp
+127
View File
@@ -0,0 +1,127 @@
/**
* File: graph_adjacency_matrix.cpp
* Created Time: 2023-02-09
* Author: what-is-me (whatisme@outlook.jp)
*/
#include "../utils/common.hpp"
/* 基於鄰接矩陣實現的無向圖類別 */
class GraphAdjMat {
vector<int> vertices; // 頂點串列，元素代表“頂點值”，索引代表“頂點索引”
vector<vector<int>> adjMat; // 鄰接矩陣，行列索引對應“頂點索引”
public:
/* 建構子 */
GraphAdjMat(const vector<int> &vertices, const vector<vector<int>> &edges) {
// 新增頂點
for (int val : vertices) {
addVertex(val);
}
// 新增邊
// 請注意，edges 元素代表頂點索引，即對應 vertices 元素索引
for (const vector<int> &edge : edges) {
addEdge(edge[0], edge[1]);
}
}
/* 獲取頂點數量 */
int size() const {
return vertices.size();
}
/* 新增頂點 */
void addVertex(int val) {
int n = size();
// 向頂點串列中新增新頂點的值
vertices.push_back(val);
// 在鄰接矩陣中新增一行
adjMat.emplace_back(vector<int>(n, 0));
// 在鄰接矩陣中新增一列
for (vector<int> &row : adjMat) {
row.push_back(0);
}
}
/* 刪除頂點 */
void removeVertex(int index) {
if (index >= size()) {
throw out_of_range("頂點不存在");
}
// 在頂點串列中移除索引 index 的頂點
vertices.erase(vertices.begin() + index);
// 在鄰接矩陣中刪除索引 index 的行
adjMat.erase(adjMat.begin() + index);
// 在鄰接矩陣中刪除索引 index 的列
for (vector<int> &row : adjMat) {
row.erase(row.begin() + index);
}
}
/* 新增邊 */
// 參數 i, j 對應 vertices 元素索引
void addEdge(int i, int j) {
// 索引越界與相等處理
if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {
throw out_of_range("頂點不存在");
}
// 在無向圖中，鄰接矩陣關於主對角線對稱，即滿足 (i, j) == (j, i)
adjMat[i][j] = 1;
adjMat[j][i] = 1;
}
/* 刪除邊 */
// 參數 i, j 對應 vertices 元素索引
void removeEdge(int i, int j) {
// 索引越界與相等處理
if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {
throw out_of_range("頂點不存在");
}
adjMat[i][j] = 0;
adjMat[j][i] = 0;
}
/* 列印鄰接矩陣 */
void print() {
cout << "頂點串列 = ";
printVector(vertices);
cout << "鄰接矩陣 =" << endl;
printVectorMatrix(adjMat);
}
};
/* 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);
cout << "\n初始化後，圖為" << endl;
graph.print();
/* 新增邊 */
// 頂點 1, 2 的索引分別為 0, 2
graph.addEdge(0, 2);
cout << "\n新增邊 1-2 後，圖為" << endl;
graph.print();
/* 刪除邊 */
// 頂點 1, 3 的索引分別為 0, 1
graph.removeEdge(0, 1);
cout << "\n刪除邊 1-3 後，圖為" << endl;
graph.print();
/* 新增頂點 */
graph.addVertex(6);
cout << "\n新增頂點 6 後，圖為" << endl;
graph.print();
/* 刪除頂點 */
// 頂點 3 的索引為 1
graph.removeVertex(1);
cout << "\n刪除頂點 3 後，圖為" << endl;
graph.print();
return 0;
}
zh-hant/codes/cpp/chapter_graph/graph_bfs.cpp
+59
View File
@@ -0,0 +1,59 @@
/**
* File: graph_bfs.cpp
* Created Time: 2023-03-02
* Author: krahets (krahets@163.com)
*/
#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
queue<Vertex *> que;
que.push(startVet);
// 以頂點 vet 為起點，迴圈直至訪問完所有頂點
while (!que.empty()) {
Vertex *vet = que.front();
que.pop(); // 佇列首頂點出隊
res.push_back(vet); // 記錄訪問頂點
// 走訪該頂點的所有鄰接頂點
for (auto adjVet : graph.adjList[vet]) {
if (visited.count(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});
vector<vector<Vertex *>> edges = {{v[0], v[1]}, {v[0], v[3]}, {v[1], v[2]}, {v[1], v[4]},
{v[2], v[5]}, {v[3], v[4]}, {v[3], v[6]}, {v[4], v[5]},
{v[4], v[7]}, {v[5], v[8]}, {v[6], v[7]}, {v[7], v[8]}};
GraphAdjList graph(edges);
cout << "\n初始化後，圖為\\n";
graph.print();
/* 廣度優先走訪 */
vector<Vertex *> res = graphBFS(graph, v[0]);
cout << "\n廣度優先走訪（BFS）頂點序列為" << endl;
printVector(vetsToVals(res));
// 釋放記憶體
for (Vertex *vet : v) {
delete vet;
}
return 0;
}
zh-hant/codes/cpp/chapter_graph/graph_dfs.cpp
+55
View File
@@ -0,0 +1,55 @@
/**
* File: graph_dfs.cpp
* Created Time: 2023-03-02
* Author: krahets (krahets@163.com)
*/
#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); // 標記該頂點已被訪問
// 走訪該頂點的所有鄰接頂點
for (Vertex *adjVet : graph.adjList[vet]) {
if (visited.count(adjVet))
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});
vector<vector<Vertex *>> edges = {{v[0], v[1]}, {v[0], v[3]}, {v[1], v[2]},
{v[2], v[5]}, {v[4], v[5]}, {v[5], v[6]}};
GraphAdjList graph(edges);
cout << "\n初始化後，圖為" << endl;
graph.print();
/* 深度優先走訪 */
vector<Vertex *> res = graphDFS(graph, v[0]);
cout << "\n深度優先走訪（DFS）頂點序列為" << endl;
printVector(vetsToVals(res));
// 釋放記憶體
for (Vertex *vet : v) {
delete vet;
}
return 0;
}
zh-hant/codes/cpp/chapter_greedy/CMakeLists.txt
+3
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)
zh-hant/codes/cpp/chapter_greedy/coin_change_greedy.cpp
+60
View File
@@ -0,0 +1,60 @@
/**
* File: coin_change_greedy.cpp
* Created Time: 2023-07-20
* Author: krahets (krahets@163.com)
*/
#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]
amt -= coins[i];
count++;
}
// 若未找到可行方案，則返回 -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;
// 貪婪：無法保證找到全域性最優解
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;
// 貪婪：無法保證找到全域性最優解
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;
return 0;
}
zh-hant/codes/cpp/chapter_greedy/fractional_knapsack.cpp
+56
View File
@@ -0,0 +1,56 @@
/**
* File: fractional_knapsack.cpp
* Created Time: 2023-07-20
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 物品 */
class Item {
public:
int w; // 物品重量
int v; // 物品價值
Item(int w, int v) : w(w), v(v) {
}
};
/* 分數背包：貪婪 */
double fractionalKnapsack(vector<int> &wgt, vector<int> &val, int cap) {
// 建立物品串列，包含兩個屬性：重量、價值
vector<Item> items;
for (int i = 0; i < wgt.size(); i++) {
items.push_back(Item(wgt[i], val[i]));
}
// 按照單位價值 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;
return 0;
}
zh-hant/codes/cpp/chapter_greedy/max_capacity.cpp
+39
View File
@@ -0,0 +1,39 @@
/**
* File: max_capacity.cpp
* Created Time: 2023-07-21
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 最大容量：貪婪 */
int maxCapacity(vector<int> &ht) {
// 初始化 i, j，使其分列陣列兩端
int i = 0, j = ht.size() - 1;
// 初始最大容量為 0
int res = 0;
// 迴圈貪婪選擇，直至兩板相遇
while (i < j) {
// 更新最大容量
int cap = min(ht[i], ht[j]) * (j - i);
res = max(res, cap);
// 向內移動短板
if (ht[i] < ht[j]) {
i++;
} else {
j--;
}
}
return res;
}
/* Driver Code */
int main() {
vector<int> ht = {3, 8, 5, 2, 7, 7, 3, 4};
// 貪婪演算法
int res = maxCapacity(ht);
cout << "最大容量為 " << res << endl;
return 0;
}
zh-hant/codes/cpp/chapter_greedy/max_product_cutting.cpp
+39
View File
@@ -0,0 +1,39 @@
/**
* File: max_product_cutting.cpp
* Created Time: 2023-07-21
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 最大切分乘積：貪婪 */
int maxProductCutting(int n) {
// 當 n <= 3 時，必須切分出一個 1
if (n <= 3) {
return 1 * (n - 1);
}
// 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數
int a = n / 3;
int b = n % 3;
if (b == 1) {
// 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2
return (int)pow(3, a - 1) * 2 * 2;
}
if (b == 2) {
// 當餘數為 2 時，不做處理
return (int)pow(3, a) * 2;
}
// 當餘數為 0 時，不做處理
return (int)pow(3, a);
}
/* Driver Code */
int main() {
int n = 58;
// 貪婪演算法
int res = maxProductCutting(n);
cout << "最大切分乘積為" << res << endl;
return 0;
}
zh-hant/codes/cpp/chapter_hashing/CMakeLists.txt
+6
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)
zh-hant/codes/cpp/chapter_hashing/array_hash_map.cpp
+110
View File
@@ -0,0 +1,110 @@
/**
* File: array_hash_map.cpp
* Created Time: 2022-12-14
* Author: msk397 (machangxinq@gmail.com)
*/
#include "../utils/common.hpp"
/* 鍵值對 */
struct Pair {
public:
int key;
string val;
Pair(int key, string val) {
this->key = key;
this->val = val;
}
};
/* 基於陣列實現的雜湊表 */
class ArrayHashMap {
private:
vector<Pair *> buckets;
public:
ArrayHashMap() {
// 初始化陣列，包含 100 個桶
buckets = vector<Pair *>(100);
}
~ArrayHashMap() {
// 釋放記憶體
for (const auto &bucket : buckets) {
delete bucket;
}
buckets.clear();
}
/* 雜湊函式 */
int hashFunc(int key) {
int index = key % 100;
return index;
}
/* 查詢操作 */
string get(int key) {
int index = hashFunc(key);
Pair *pair = buckets[index];
if (pair == nullptr)
return "";
return pair->val;
}
/* 新增操作 */
void put(int key, string val) {
Pair *pair = new Pair(key, val);
int index = hashFunc(key);
buckets[index] = pair;
}
/* 刪除操作 */
void remove(int key) {
int index = hashFunc(key);
// 釋放記憶體並置為 nullptr
delete buckets[index];
buckets[index] = nullptr;
}
/* 獲取所有鍵值對 */
vector<Pair *> pairSet() {
vector<Pair *> pairSet;
for (Pair *pair : buckets) {
if (pair != nullptr) {
pairSet.push_back(pair);
}
}
return pairSet;
}
/* 獲取所有鍵 */
vector<int> keySet() {
vector<int> keySet;
for (Pair *pair : buckets) {
if (pair != nullptr) {
keySet.push_back(pair->key);
}
}
return keySet;
}
/* 獲取所有值 */
vector<string> valueSet() {
vector<string> valueSet;
for (Pair *pair : buckets) {
if (pair != nullptr) {
valueSet.push_back(pair->val);
}
}
return valueSet;
}
/* 列印雜湊表 */
void print() {
for (Pair *kv : pairSet()) {
cout << kv->key << " -> " << kv->val << endl;
}
}
};
// 測試樣例請見 array_hash_map_test.cpp
zh-hant/codes/cpp/chapter_hashing/array_hash_map_test.cpp
+52
View File
@@ -0,0 +1,52 @@
/**
* File: array_hash_map_test.cpp
* Created Time: 2022-12-14
* Author: msk397 (machangxinq@gmail.com)
*/
#include "./array_hash_map.cpp"
/* Driver Code */
int main() {
/* 初始化雜湊表 */
ArrayHashMap map = ArrayHashMap();
/* 新增操作 */
// 在雜湊表中新增鍵值對 (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 << "\n輸入學號 15937 ，查詢到姓名 " << name << endl;
/* 刪除操作 */
// 在雜湊表中刪除鍵值對 (key, value)
map.remove(10583);
cout << "\n刪除 10583 後，雜湊表為\nKey -> Value" << endl;
map.print();
/* 走訪雜湊表 */
cout << "\n走訪鍵值對 Key->Value" << endl;
for (auto kv : map.pairSet()) {
cout << kv->key << " -> " << kv->val << endl;
}
cout << "\n單獨走訪鍵 Key" << endl;
for (auto key : map.keySet()) {
cout << key << endl;
}
cout << "\n單獨走訪值 Value" << endl;
for (auto val : map.valueSet()) {
cout << val << endl;
}
return 0;
}
zh-hant/codes/cpp/chapter_hashing/built_in_hash.cpp
+29
View File
@@ -0,0 +1,29 @@
/**
* File: built_in_hash.cpp
* Created Time: 2023-06-21
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* Driver Code */
int main() {
int num = 3;
size_t hashNum = hash<int>()(num);
cout << "整數 " << num << " 的雜湊值為 " << hashNum << "\n";
bool bol = true;
size_t hashBol = hash<bool>()(bol);
cout << "布林量 " << bol << " 的雜湊值為 " << hashBol << "\n";
double dec = 3.14159;
size_t hashDec = hash<double>()(dec);
cout << "小數 " << dec << " 的雜湊值為 " << hashDec << "\n";
string str = "Hello 演算法";
size_t hashStr = hash<string>()(str);
cout << "字串 " << str << " 的雜湊值為 " << hashStr << "\n";
// 在 C++ 中，內建 std:hash() 僅提供基本資料型別的雜湊值計算
// 陣列、物件的雜湊值計算需要自行實現
}
zh-hant/codes/cpp/chapter_hashing/hash_map.cpp
+46
View File
@@ -0,0 +1,46 @@
/**
* File: hash_map.cpp
* Created Time: 2022-12-14
* Author: msk397 (machangxinq@gmail.com)
*/
#include "../utils/common.hpp"
/* Driver Code */
int main() {
/* 初始化雜湊表 */
unordered_map<int, string> map;
/* 新增操作 */
// 在雜湊表中新增鍵值對 (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 << "\n輸入學號 15937 ，查詢到姓名 " << name << endl;
/* 刪除操作 */
// 在雜湊表中刪除鍵值對 (key, value)
map.erase(10583);
cout << "\n刪除 10583 後，雜湊表為\nKey -> Value" << endl;
printHashMap(map);
/* 走訪雜湊表 */
cout << "\n走訪鍵值對 Key->Value" << endl;
for (auto kv : map) {
cout << kv.first << " -> " << kv.second << endl;
}
cout << "\n使用迭代器走訪 Key->Value" << endl;
for (auto iter = map.begin(); iter != map.end(); iter++) {
cout << iter->first << "->" << iter->second << endl;
}
return 0;
}
zh-hant/codes/cpp/chapter_hashing/hash_map_chaining.cpp
+150
View File
@@ -0,0 +1,150 @@
/**
* File: hash_map_chaining.cpp
* Created Time: 2023-06-13
* Author: krahets (krahets@163.com)
*/
#include "./array_hash_map.cpp"
/* 鏈式位址雜湊表 */
class HashMapChaining {
private:
int size; // 鍵值對數量
int capacity; // 雜湊表容量
double loadThres; // 觸發擴容的負載因子閾值
int extendRatio; // 擴容倍數
vector<vector<Pair *>> buckets; // 桶陣列
public:
/* 建構子 */
HashMapChaining() : size(0), capacity(4), loadThres(2.0 / 3.0), extendRatio(2) {
buckets.resize(capacity);
}
/* 析構方法 */
~HashMapChaining() {
for (auto &bucket : buckets) {
for (Pair *pair : bucket) {
// 釋放記憶體
delete pair;
}
}
}
/* 雜湊函式 */
int hashFunc(int key) {
return key % capacity;
}
/* 負載因子 */
double loadFactor() {
return (double)size / (double)capacity;
}
/* 查詢操作 */
string get(int key) {
int index = hashFunc(key);
// 走訪桶，若找到 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);
// 走訪桶，若遇到指定 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++;
}
/* 刪除操作 */
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; // 釋放記憶體
size--;
return;
}
}
}
/* 擴容雜湊表 */
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 << "[";
for (Pair *pair : bucket) {
cout << pair->key << " -> " << pair->val << ", ";
}
cout << "]\n";
}
}
};
/* Driver Code */
int main() {
/* 初始化雜湊表 */
HashMapChaining map = HashMapChaining();
/* 新增操作 */
// 在雜湊表中新增鍵值對 (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 << "\n輸入學號 13276 ，查詢到姓名 " << name << endl;
/* 刪除操作 */
// 在雜湊表中刪除鍵值對 (key, value)
map.remove(12836);
cout << "\n刪除 12836 後，雜湊表為\nKey -> Value" << endl;
map.print();
return 0;
}
zh-hant/codes/cpp/chapter_hashing/hash_map_open_addressing.cpp
+171
View File
@@ -0,0 +1,171 @@
/**
* File: hash_map_open_addressing.cpp
* Created Time: 2023-06-13
* Author: krahets (krahets@163.com)
*/
#include "./array_hash_map.cpp"
/* 開放定址雜湊表 */
class HashMapOpenAddressing {
private:
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"); // 刪除標記
public:
/* 建構子 */
HashMapOpenAddressing() : size(0), buckets(capacity, nullptr) {
}
/* 析構方法 */
~HashMapOpenAddressing() {
for (Pair *pair : buckets) {
if (pair != nullptr && pair != TOMBSTONE) {
delete pair;
}
}
delete TOMBSTONE;
}
/* 雜湊函式 */
int hashFunc(int key) {
return key % capacity;
}
/* 負載因子 */
double loadFactor() {
return (double)size / capacity;
}
/* 搜尋 key 對應的桶索引 */
int findBucket(int key) {
int index = hashFunc(key);
int firstTombstone = -1;
// 線性探查，當遇到空桶時跳出
while (buckets[index] != nullptr) {
// 若遇到 key ，返回對應的桶索引
if (buckets[index]->key == key) {
// 若之前遇到了刪除標記，則將鍵值對移動至該索引處
if (firstTombstone != -1) {
buckets[firstTombstone] = buckets[index];
buckets[index] = TOMBSTONE;
return firstTombstone; // 返回移動後的桶索引
}
return index; // 返回桶索引
}
// 記錄遇到的首個刪除標記
if (firstTombstone == -1 && buckets[index] == TOMBSTONE) {
firstTombstone = index;
}
// 計算桶索引，越過尾部則返回頭部
index = (index + 1) % capacity;
}
// 若 key 不存在，則返回新增點的索引
return firstTombstone == -1 ? index : firstTombstone;
}
/* 查詢操作 */
string get(int key) {
// 搜尋 key 對應的桶索引
int index = findBucket(key);
// 若找到鍵值對，則返回對應 val
if (buckets[index] != nullptr && buckets[index] != TOMBSTONE) {
return buckets[index]->val;
}
// 若鍵值對不存在，則返回空字串
return "";
}
/* 新增操作 */
void put(int key, string val) {
// 當負載因子超過閾值時，執行擴容
if (loadFactor() > loadThres) {
extend();
}
// 搜尋 key 對應的桶索引
int index = findBucket(key);
// 若找到鍵值對，則覆蓋 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 對應的桶索引
int index = findBucket(key);
// 若找到鍵值對，則用刪除標記覆蓋它
if (buckets[index] != nullptr && buckets[index] != TOMBSTONE) {
delete buckets[index];
buckets[index] = TOMBSTONE;
size--;
}
}
/* 擴容雜湊表 */
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);
delete pair;
}
}
}
/* 列印雜湊表 */
void print() {
for (Pair *pair : buckets) {
if (pair == nullptr) {
cout << "nullptr" << endl;
} else if (pair == TOMBSTONE) {
cout << "TOMBSTONE" << endl;
} else {
cout << pair->key << " -> " << pair->val << endl;
}
}
}
};
/* Driver Code */
int main() {
// 初始化雜湊表
HashMapOpenAddressing hashmap;
// 新增操作
// 在雜湊表中新增鍵值對 (key, val)
hashmap.put(12836, "小哈");
hashmap.put(15937, "小囉");
hashmap.put(16750, "小算");
hashmap.put(13276, "小法");
hashmap.put(10583, "小鴨");
cout << "\n新增完成後，雜湊表為\nKey -> Value" << endl;
hashmap.print();
// 查詢操作
// 向雜湊表中輸入鍵 key ，得到值 val
string name = hashmap.get(13276);
cout << "\n輸入學號 13276 ，查詢到姓名 " << name << endl;
// 刪除操作
// 在雜湊表中刪除鍵值對 (key, val)
hashmap.remove(16750);
cout << "\n刪除 16750 後，雜湊表為\nKey -> Value" << endl;
hashmap.print();
return 0;
}
zh-hant/codes/cpp/chapter_hashing/simple_hash.cpp
+66
View File
@@ -0,0 +1,66 @@
/**
* File: simple_hash.cpp
* Created Time: 2023-06-21
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 加法雜湊 */
int addHash(string key) {
long long hash = 0;
const int MODULUS = 1000000007;
for (unsigned char c : key) {
hash = (hash + (int)c) % MODULUS;
}
return (int)hash;
}
/* 乘法雜湊 */
int mulHash(string key) {
long long hash = 0;
const int MODULUS = 1000000007;
for (unsigned char c : key) {
hash = (31 * hash + (int)c) % MODULUS;
}
return (int)hash;
}
/* 互斥或雜湊 */
int xorHash(string key) {
int hash = 0;
const int MODULUS = 1000000007;
for (unsigned char c : key) {
hash ^= (int)c;
}
return hash & MODULUS;
}
/* 旋轉雜湊 */
int rotHash(string key) {
long long hash = 0;
const int MODULUS = 1000000007;
for (unsigned char c : key) {
hash = ((hash << 4) ^ (hash >> 28) ^ (int)c) % MODULUS;
}
return (int)hash;
}
/* Driver Code */
int main() {
string key = "Hello dsad3241241dsa算123法";
int hash = addHash(key);
cout << "加法雜湊值為 " << hash << endl;
hash = mulHash(key);
cout << "乘法雜湊值為 " << hash << endl;
hash = xorHash(key);
cout << "互斥或雜湊值為 " << hash << endl;
hash = rotHash(key);
cout << "旋轉雜湊值為 " << hash << endl;
return 0;
}
zh-hant/codes/cpp/chapter_heap/CMakeLists.txt
+3
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)
zh-hant/codes/cpp/chapter_heap/heap.cpp
+66
View File
@@ -0,0 +1,66 @@
/**
* File: heap.cpp
* Created Time: 2023-01-19
* Author: LoneRanger(836253168@qq.com)
*/
#include "../utils/common.hpp"
void testPush(priority_queue<int> &heap, int val) {
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;
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;
/* 元素入堆積 */
testPush(maxHeap, 1);
testPush(maxHeap, 3);
testPush(maxHeap, 2);
testPush(maxHeap, 5);
testPush(maxHeap, 4);
/* 獲取堆積頂元素 */
int peek = maxHeap.top();
cout << "\n堆積頂元素為 " << peek << endl;
/* 堆積頂元素出堆積 */
testPop(maxHeap);
testPop(maxHeap);
testPop(maxHeap);
testPop(maxHeap);
testPop(maxHeap);
/* 獲取堆積大小 */
int size = maxHeap.size();
cout << "\n堆積元素數量為 " << size << endl;
/* 判斷堆積是否為空 */
bool isEmpty = maxHeap.empty();
cout << "\n堆積是否為空 " << isEmpty << endl;
/* 輸入串列並建堆積 */
// 時間複雜度為 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;
printHeap(minHeap);
return 0;
}
zh-hant/codes/cpp/chapter_heap/my_heap.cpp
+155
View File
@@ -0,0 +1,155 @@
/**
* File: my_heap.cpp
* Created Time: 2023-02-04
* Author: LoneRanger (836253168@qq.com), what-is-me (whatisme@outlook.jp)
*/
#include "../utils/common.hpp"
/* 大頂堆積 */
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; // 向下整除
}
/* 從節點 i 開始，從底至頂堆積化 */
void siftUp(int i) {
while (true) {
// 獲取節點 i 的父節點
int p = parent(i);
// 當“越過根節點”或“節點無須修復”時，結束堆積化
if (p < 0 || maxHeap[i] <= maxHeap[p])
break;
// 交換兩節點
swap(maxHeap[i], maxHeap[p]);
// 迴圈向上堆積化
i = p;
}
}
/* 從節點 i 開始，從頂至底堆積化 */
void siftDown(int i) {
while (true) {
// 判斷節點 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 越界，則無須繼續堆積化，跳出
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);
}
}
/* 獲取堆積大小 */
int size() {
return maxHeap.size();
}
/* 判斷堆積是否為空 */
bool isEmpty() {
return size() == 0;
}
/* 訪問堆積頂元素 */
int peek() {
return maxHeap[0];
}
/* 元素入堆積 */
void push(int val) {
// 新增節點
maxHeap.push_back(val);
// 從底至頂堆積化
siftUp(size() - 1);
}
/* 元素出堆積 */
void pop() {
// 判空處理
if (isEmpty()) {
throw out_of_range("堆積為空");
}
// 交換根節點與最右葉節點（交換首元素與尾元素）
swap(maxHeap[0], maxHeap[size() - 1]);
// 刪除節點
maxHeap.pop_back();
// 從頂至底堆積化
siftDown(0);
}
/* 列印堆積（二元樹）*/
void print() {
cout << "堆積的陣列表示：";
printVector(maxHeap);
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;
maxHeap.print();
/* 獲取堆積頂元素 */
int peek = maxHeap.peek();
cout << "\n堆積頂元素為 " << peek << endl;
/* 元素入堆積 */
int val = 7;
maxHeap.push(val);
cout << "\n元素 " << val << " 入堆積後" << endl;
maxHeap.print();
/* 堆積頂元素出堆積 */
peek = maxHeap.peek();
maxHeap.pop();
cout << "\n堆積頂元素 " << peek << " 出堆積後" << endl;
maxHeap.print();
/* 獲取堆積大小 */
int size = maxHeap.size();
cout << "\n堆積元素數量為 " << size << endl;
/* 判斷堆積是否為空 */
bool isEmpty = maxHeap.isEmpty();
cout << "\n堆積是否為空 " << isEmpty << endl;
return 0;
}
zh-hant/codes/cpp/chapter_heap/top_k.cpp
+38
View File
@@ -0,0 +1,38 @@
/**
* File: top_k.cpp
* Created Time: 2023-06-12
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 基於堆積查詢陣列中最大的 k 個元素 */
priority_queue<int, vector<int>, greater<int>> topKHeap(vector<int> &nums, int k) {
// 初始化小頂堆積
priority_queue<int, vector<int>, greater<int>> heap;
// 將陣列的前 k 個元素入堆積
for (int i = 0; i < k; i++) {
heap.push(nums[i]);
}
// 從第 k+1 個元素開始，保持堆積的長度為 k
for (int i = k; i < nums.size(); i++) {
// 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積
if (nums[i] > heap.top()) {
heap.pop();
heap.push(nums[i]);
}
}
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 << " 個元素為: ";
printHeap(res);
return 0;
}
zh-hant/codes/cpp/chapter_searching/CMakeLists.txt
+4
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)
zh-hant/codes/cpp/chapter_searching/binary_search.cpp
+59
View File
@@ -0,0 +1,59 @@
/**
* File: binary_search.cpp
* Created Time: 2022-11-25
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 二分搜尋（雙閉區間） */
int binarySearch(vector<int> &nums, int target) {
// 初始化雙閉區間 [0, n-1] ，即 i, j 分別指向陣列首元素、尾元素
int i = 0, j = nums.size() - 1;
// 迴圈，當搜尋區間為空時跳出（當 i > j 時為空）
while (i <= 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] 中
j = m - 1;
else // 找到目標元素，返回其索引
return m;
}
// 未找到目標元素，返回 -1
return -1;
}
/* 二分搜尋（左閉右開區間） */
int binarySearchLCRO(vector<int> &nums, int target) {
// 初始化左閉右開區間 [0, n) ，即 i, j 分別指向陣列首元素、尾元素+1
int i = 0, j = nums.size();
// 迴圈，當搜尋區間為空時跳出（當 i = j 時為空）
while (i < 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) 中
j = m;
else // 找到目標元素，返回其索引
return m;
}
// 未找到目標元素，返回 -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;
/* 二分搜尋（左閉右開區間） */
index = binarySearchLCRO(nums, target);
cout << "目標元素 6 的索引 = " << index << endl;
return 0;
}
zh-hant/codes/cpp/chapter_searching/binary_search_edge.cpp
+66
View File
@@ -0,0 +1,66 @@
/**
* File: binary_search_edge.cpp
* Created Time: 2023-08-04
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 二分搜尋插入點（存在重複元素） */
int binarySearchInsertion(const vector<int> &nums, int target) {
int i = 0, j = nums.size() - 1; // 初始化雙閉區間 [0, n-1]
while (i <= j) {
int m = i + (j - i) / 2; // 計算中點索引 m
if (nums[m] < target) {
i = m + 1; // target 在區間 [m+1, j] 中
} else {
j = m - 1; // 首個小於 target 的元素在區間 [i, m-1] 中
}
}
// 返回插入點 i
return i;
}
/* 二分搜尋最左一個 target */
int binarySearchLeftEdge(vector<int> &nums, int target) {
// 等價於查詢 target 的插入點
int i = binarySearchInsertion(nums, target);
// 未找到 target ，返回 -1
if (i == nums.size() || nums[i] != target) {
return -1;
}
// 找到 target ，返回索引 i
return i;
}
/* 二分搜尋最右一個 target */
int binarySearchRightEdge(vector<int> &nums, int target) {
// 轉化為查詢最左一個 target + 1
int i = binarySearchInsertion(nums, target + 1);
// j 指向最右一個 target ，i 指向首個大於 target 的元素
int j = i - 1;
// 未找到 target ，返回 -1
if (j == -1 || nums[j] != target) {
return -1;
}
// 找到 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;
index = binarySearchRightEdge(nums, target);
cout << "最右一個元素 " << target << " 的索引為 " << index << endl;
}
return 0;
}
zh-hant/codes/cpp/chapter_searching/binary_search_insertion.cpp
+66
View File
@@ -0,0 +1,66 @@
/**
* File: binary_search_insertion.cpp
* Created Time: 2023-08-04
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 二分搜尋插入點（無重複元素） */
int binarySearchInsertionSimple(vector<int> &nums, int target) {
int i = 0, j = nums.size() - 1; // 初始化雙閉區間 [0, n-1]
while (i <= j) {
int m = i + (j - i) / 2; // 計算中點索引 m
if (nums[m] < target) {
i = m + 1; // target 在區間 [m+1, j] 中
} else if (nums[m] > target) {
j = m - 1; // target 在區間 [i, m-1] 中
} else {
return m; // 找到 target ，返回插入點 m
}
}
// 未找到 target ，返回插入點 i
return i;
}
/* 二分搜尋插入點（存在重複元素） */
int binarySearchInsertion(vector<int> &nums, int target) {
int i = 0, j = nums.size() - 1; // 初始化雙閉區間 [0, n-1]
while (i <= j) {
int m = i + (j - i) / 2; // 計算中點索引 m
if (nums[m] < target) {
i = m + 1; // target 在區間 [m+1, j] 中
} else if (nums[m] > target) {
j = m - 1; // target 在區間 [i, m-1] 中
} else {
j = m - 1; // 首個小於 target 的元素在區間 [i, m-1] 中
}
}
// 返回插入點 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;
}
// 包含重複元素的陣列
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;
}
return 0;
}
zh-hant/codes/cpp/chapter_searching/hashing_search.cpp
+53
View File
@@ -0,0 +1,53 @@
/**
* File: hashing_search.cpp
* Created Time: 2022-11-25
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 雜湊查詢（陣列） */
int hashingSearchArray(unordered_map<int, int> map, int target) {
// 雜湊表的 key: 目標元素，value: 索引
// 若雜湊表中無此 key ，返回 -1
if (map.find(target) == map.end())
return -1;
return map[target];
}
/* 雜湊查詢（鏈結串列） */
ListNode *hashingSearchLinkedList(unordered_map<int, ListNode *> map, int target) {
// 雜湊表的 key: 目標節點值，value: 節點物件
// 若雜湊表中無此 key ，返回 nullptr
if (map.find(target) == map.end())
return nullptr;
return map[target];
}
/* Driver Code */
int main() {
int target = 3;
/* 雜湊查詢（陣列） */
vector<int> nums = {1, 5, 3, 2, 4, 7, 5, 9, 10, 8};
// 初始化雜湊表
unordered_map<int, int> map;
for (int i = 0; i < nums.size(); i++) {
map[nums[i]] = i; // key: 元素，value: 索引
}
int index = hashingSearchArray(map, target);
cout << "目標元素 3 的索引 = " << index << endl;
/* 雜湊查詢（鏈結串列） */
ListNode *head = vecToLinkedList(nums);
// 初始化雜湊表
unordered_map<int, ListNode *> map1;
while (head != nullptr) {
map1[head->val] = head; // key: 節點值，value: 節點
head = head->next;
}
ListNode *node = hashingSearchLinkedList(map1, target);
cout << "目標節點值 3 的對應節點物件為 " << node << endl;
return 0;
}
zh-hant/codes/cpp/chapter_searching/linear_search.cpp
+49
View File
@@ -0,0 +1,49 @@
/**
* File: linear_search.cpp
* Created Time: 2022-11-25
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 線性查詢（陣列） */
int linearSearchArray(vector<int> &nums, int target) {
// 走訪陣列
for (int i = 0; i < nums.size(); i++) {
// 找到目標元素，返回其索引
if (nums[i] == target)
return i;
}
// 未找到目標元素，返回 -1
return -1;
}
/* 線性查詢（鏈結串列） */
ListNode *linearSearchLinkedList(ListNode *head, int target) {
// 走訪鏈結串列
while (head != nullptr) {
// 找到目標節點，返回之
if (head->val == target)
return head;
head = head->next;
}
// 未找到目標節點，返回 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;
/* 在鏈結串列中執行線性查詢 */
ListNode *head = vecToLinkedList(nums);
ListNode *node = linearSearchLinkedList(head, target);
cout << "目標節點值 3 的對應節點物件為 " << node << endl;
return 0;
}
zh-hant/codes/cpp/chapter_searching/two_sum.cpp
+54
View File
@@ -0,0 +1,54 @@
/**
* File: two_sum.cpp
* Created Time: 2022-11-25
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 方法一：暴力列舉 */
vector<int> twoSumBruteForce(vector<int> &nums, int target) {
int size = nums.size();
// 兩層迴圈，時間複雜度為 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)
return {i, j};
}
}
return {};
}
/* 方法二：輔助雜湊表 */
vector<int> twoSumHashTable(vector<int> &nums, int target) {
int size = nums.size();
// 輔助雜湊表，空間複雜度為 O(n)
unordered_map<int, int> dic;
// 單層迴圈，時間複雜度為 O(n)
for (int i = 0; i < size; i++) {
if (dic.find(target - nums[i]) != dic.end()) {
return {dic[target - nums[i]], i};
}
dic.emplace(nums[i], i);
}
return {};
}
/* Driver Code */
int main() {
// ======= Test Case =======
vector<int> nums = {2, 7, 11, 15};
int target = 13;
// ====== Driver Code ======
// 方法一
vector<int> res = twoSumBruteForce(nums, target);
cout << "方法一 res = ";
printVector(res);
// 方法二
res = twoSumHashTable(nums, target);
cout << "方法二 res = ";
printVector(res);
return 0;
}
zh-hant/codes/cpp/chapter_sorting/CMakeLists.txt
+6
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)
zh-hant/codes/cpp/chapter_sorting/bubble_sort.cpp
+56
View File
@@ -0,0 +1,56 @@
/**
* File: bubble_sort.cpp
* Created Time: 2022-11-25
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 泡沫排序 */
void bubbleSort(vector<int> &nums) {
// 外迴圈：未排序區間為 [0, i]
for (int i = nums.size() - 1; 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() 函式
swap(nums[j], nums[j + 1]);
}
}
}
}
/* 泡沫排序（標誌最佳化）*/
void bubbleSortWithFlag(vector<int> &nums) {
// 外迴圈：未排序區間為 [0, i]
for (int i = nums.size() - 1; i > 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() 函式
swap(nums[j], nums[j + 1]);
flag = true; // 記錄交換元素
}
}
if (!flag)
break; // 此輪“冒泡”未交換任何元素，直接跳出
}
}
/* Driver Code */
int main() {
vector<int> nums = {4, 1, 3, 1, 5, 2};
bubbleSort(nums);
cout << "泡沫排序完成後 nums = ";
printVector(nums);
vector<int> nums1 = {4, 1, 3, 1, 5, 2};
bubbleSortWithFlag(nums1);
cout << "泡沫排序完成後 nums1 = ";
printVector(nums1);
return 0;
}
zh-hant/codes/cpp/chapter_sorting/bucket_sort.cpp
+44
View File
@@ -0,0 +1,44 @@
/**
* File: bucket_sort.cpp
* Created Time: 2023-03-30
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 桶排序 */
void bucketSort(vector<float> &nums) {
// 初始化 k = n/2 個桶，預期向每個桶分配 2 個元素
int k = nums.size() / 2;
vector<vector<float>> buckets(k);
// 1. 將陣列元素分配到各個桶中
for (float num : nums) {
// 輸入資料範圍為 [0, 1)，使用 num * k 對映到索引範圍 [0, k-1]
int i = num * k;
// 將 num 新增進桶 bucket_idx
buckets[i].push_back(num);
}
// 2. 對各個桶執行排序
for (vector<float> &bucket : buckets) {
// 使用內建排序函式，也可以替換成其他排序演算法
sort(bucket.begin(), bucket.end());
}
// 3. 走訪桶合併結果
int i = 0;
for (vector<float> &bucket : buckets) {
for (float num : bucket) {
nums[i++] = num;
}
}
}
/* Driver Code */
int main() {
// 設輸入資料為浮點數，範圍為 [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 = ";
printVector(nums);
return 0;
}
zh-hant/codes/cpp/chapter_sorting/counting_sort.cpp
+77
View File
@@ -0,0 +1,77 @@
/**
* File: counting_sort.cpp
* Created Time: 2023-03-17
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 計數排序 */
// 簡單實現，無法用於排序物件
void countingSortNaive(vector<int> &nums) {
// 1. 統計陣列最大元素 m
int m = 0;
for (int num : nums) {
m = max(m, num);
}
// 2. 統計各數字的出現次數
// counter[num] 代表 num 的出現次數
vector<int> counter(m + 1, 0);
for (int num : nums) {
counter[num]++;
}
// 3. 走訪 counter ，將各元素填入原陣列 nums
int i = 0;
for (int num = 0; num < m + 1; num++) {
for (int j = 0; j < counter[num]; j++, i++) {
nums[i] = num;
}
}
}
/* 計數排序 */
// 完整實現，可排序物件，並且是穩定排序
void countingSort(vector<int> &nums) {
// 1. 統計陣列最大元素 m
int m = 0;
for (int num : nums) {
m = max(m, num);
}
// 2. 統計各數字的出現次數
// counter[num] 代表 num 的出現次數
vector<int> counter(m + 1, 0);
for (int num : nums) {
counter[num]++;
}
// 3. 求 counter 的前綴和，將“出現次數”轉換為“尾索引”
// 即 counter[num]-1 是 num 在 res 中最後一次出現的索引
for (int i = 0; i < m; i++) {
counter[i + 1] += counter[i];
}
// 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 覆蓋原陣列 nums
nums = res;
}
/* Driver Code */
int main() {
vector<int> nums = {1, 0, 1, 2, 0, 4, 0, 2, 2, 4};
countingSortNaive(nums);
cout << "計數排序（無法排序物件）完成後 nums = ";
printVector(nums);
vector<int> nums1 = {1, 0, 1, 2, 0, 4, 0, 2, 2, 4};
countingSort(nums1);
cout << "計數排序完成後 nums1 = ";
printVector(nums1);
return 0;
}
zh-hant/codes/cpp/chapter_sorting/heap_sort.cpp
+54
View File
@@ -0,0 +1,54 @@
/**
* File: heap_sort.cpp
* Created Time: 2023-05-26
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 堆積的長度為 n ，從節點 i 開始，從頂至底堆積化 */
void siftDown(vector<int> &nums, int n, int i) {
while (true) {
// 判斷節點 i, l, r 中值最大的節點，記為 ma
int l = 2 * i + 1;
int r = 2 * i + 2;
int ma = i;
if (l < n && nums[l] > nums[ma])
ma = l;
if (r < n && nums[r] > nums[ma])
ma = r;
// 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出
if (ma == i) {
break;
}
// 交換兩節點
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 輪
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 = ";
printVector(nums);
return 0;
}
zh-hant/codes/cpp/chapter_sorting/insertion_sort.cpp
+31
View File
@@ -0,0 +1,31 @@
/**
* File: insertion_sort.cpp
* Created Time: 2022-11-25
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 插入排序 */
void insertionSort(vector<int> &nums) {
// 外迴圈：已排序區間為 [0, i-1]
for (int i = 1; i < nums.size(); i++) {
int base = nums[i], j = i - 1;
// 內迴圈：將 base 插入到已排序區間 [0, i-1] 中的正確位置
while (j >= 0 && nums[j] > base) {
nums[j + 1] = nums[j]; // 將 nums[j] 向右移動一位
j--;
}
nums[j + 1] = base; // 將 base 賦值到正確位置
}
}
/* Driver Code */
int main() {
vector<int> nums = {4, 1, 3, 1, 5, 2};
insertionSort(nums);
cout << "插入排序完成後 nums = ";
printVector(nums);
return 0;
}
zh-hant/codes/cpp/chapter_sorting/merge_sort.cpp
+58
View File
@@ -0,0 +1,58 @@
/**
* File: merge_sort.cpp
* Created Time: 2022-11-25
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 合併左子陣列和右子陣列 */
void merge(vector<int> &nums, int left, int mid, int right) {
// 左子陣列區間為 [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 的對應區間
for (k = 0; k < tmp.size(); k++) {
nums[left + k] = tmp[k];
}
}
/* 合併排序 */
void mergeSort(vector<int> &nums, int left, int right) {
// 終止條件
if (left >= right)
return; // 當子陣列長度為 1 時終止遞迴
// 劃分階段
int mid = (left + right) / 2; // 計算中點
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 = ";
printVector(nums);
return 0;
}
zh-hant/codes/cpp/chapter_sorting/quick_sort.cpp
+166
View File
@@ -0,0 +1,166 @@
/**
* File: quick_sort.cpp
* Created Time: 2022-11-25
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 快速排序類別 */
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] 為基準數
int i = left, j = right;
while (i < j) {
while (i < j && nums[j] >= nums[left])
j--; // 從右向左找首個小於基準數的元素
while (i < j && nums[i] <= nums[left])
i++; // 從左向右找首個大於基準數的元素
swap(nums, i, j); // 交換這兩個元素
}
swap(nums, i, left); // 將基準數交換至兩子陣列的分界線
return i; // 返回基準數的索引
}
public:
/* 快速排序 */
static void quickSort(vector<int> &nums, int left, int right) {
// 子陣列長度為 1 時終止遞迴
if (left >= right)
return;
// 哨兵劃分
int pivot = partition(nums, left, right);
// 遞迴左子陣列、右子陣列
quickSort(nums, left, pivot - 1);
quickSort(nums, pivot + 1, right);
}
};
/* 快速排序類別（中位基準數最佳化） */
class QuickSortMedian {
private:
/* 元素交換 */
static void swap(vector<int> &nums, int i, int j) {
int tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
/* 選取三個候選元素的中位數 */
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 之間
if ((m <= l && l <= r) || (r <= l && l <= m))
return left; // l 在 m 和 r 之間
return right;
}
/* 哨兵劃分（三數取中值） */
static int partition(vector<int> &nums, int left, int right) {
// 選取三個候選元素的中位數
int med = medianThree(nums, left, (left + right) / 2, right);
// 將中位數交換至陣列最左端
swap(nums, left, med);
// 以 nums[left] 為基準數
int i = left, j = right;
while (i < j) {
while (i < j && nums[j] >= nums[left])
j--; // 從右向左找首個小於基準數的元素
while (i < j && nums[i] <= nums[left])
i++; // 從左向右找首個大於基準數的元素
swap(nums, i, j); // 交換這兩個元素
}
swap(nums, i, left); // 將基準數交換至兩子陣列的分界線
return i; // 返回基準數的索引
}
public:
/* 快速排序 */
static void quickSort(vector<int> &nums, int left, int right) {
// 子陣列長度為 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] 為基準數
int i = left, j = right;
while (i < j) {
while (i < j && nums[j] >= nums[left])
j--; // 從右向左找首個小於基準數的元素
while (i < j && nums[i] <= nums[left])
i++; // 從左向右找首個大於基準數的元素
swap(nums, i, j); // 交換這兩個元素
}
swap(nums, i, left); // 將基準數交換至兩子陣列的分界線
return i; // 返回基準數的索引
}
public:
/* 快速排序（尾遞迴最佳化） */
static void quickSort(vector<int> &nums, int left, int right) {
// 子陣列長度為 1 時終止
while (left < right) {
// 哨兵劃分操作
int pivot = partition(nums, left, right);
// 對兩個子陣列中較短的那個執行快速排序
if (pivot - left < right - pivot) {
quickSort(nums, left, pivot - 1); // 遞迴排序左子陣列
left = pivot + 1; // 剩餘未排序區間為 [pivot + 1, right]
} else {
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 = ";
printVector(nums);
/* 快速排序（中位基準數最佳化） */
vector<int> nums1 = {2, 4, 1, 0, 3, 5};
QuickSortMedian::quickSort(nums1, 0, nums1.size() - 1);
cout << "快速排序（中位基準數最佳化）完成後 nums = ";
printVector(nums1);
/* 快速排序（尾遞迴最佳化） */
vector<int> nums2 = {2, 4, 1, 0, 3, 5};
QuickSortTailCall::quickSort(nums2, 0, nums2.size() - 1);
cout << "快速排序（尾遞迴最佳化）完成後 nums = ";
printVector(nums2);
return 0;
}
zh-hant/codes/cpp/chapter_sorting/radix_sort.cpp
+65
View File
@@ -0,0 +1,65 @@
/**
* File: radix_sort.cpp
* Created Time: 2023-03-26
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 獲取元素 num 的第 k 位，其中 exp = 10^(k-1) */
int digit(int num, int exp) {
// 傳入 exp 而非 k 可以避免在此重複執行昂貴的次方計算
return (num / exp) % 10;
}
/* 計數排序（根據 nums 第 k 位排序） */
void countingSortDigit(vector<int> &nums, int exp) {
// 十進位制的位範圍為 0~9 ，因此需要長度為 10 的桶陣列
vector<int> counter(10, 0);
int n = nums.size();
// 統計 0~9 各數字的出現次數
for (int i = 0; i < n; i++) {
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
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
}
// 使用結果覆蓋原陣列 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 = 1 -> exp = 1
// k = 2 -> exp = 10
// 即 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 = ";
printVector(nums);
return 0;
}
zh-hant/codes/cpp/chapter_sorting/selection_sort.cpp
+34
View File
@@ -0,0 +1,34 @@
/**
* File: selection_sort.cpp
* Created Time: 2023-05-23
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 選擇排序 */
void selectionSort(vector<int> &nums) {
int n = nums.size();
// 外迴圈：未排序區間為 [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 = ";
printVector(nums);
return 0;
}
zh-hant/codes/cpp/chapter_stack_and_queue/CMakeLists.txt
+9
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)
zh-hant/codes/cpp/chapter_stack_and_queue/array_deque.cpp
+156
View File
@@ -0,0 +1,156 @@
/**
* File: array_deque.cpp
* Created Time: 2023-03-02
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 基於環形陣列實現的雙向佇列 */
class ArrayDeque {
private:
vector<int> nums; // 用於儲存雙向佇列元素的陣列
int front; // 佇列首指標，指向佇列首元素
int queSize; // 雙向佇列長度
public:
/* 建構子 */
ArrayDeque(int capacity) {
nums.resize(capacity);
front = queSize = 0;
}
/* 獲取雙向佇列的容量 */
int capacity() {
return nums.size();
}
/* 獲取雙向佇列的長度 */
int size() {
return queSize;
}
/* 判斷雙向佇列是否為空 */
bool isEmpty() {
return queSize == 0;
}
/* 計算環形陣列索引 */
int index(int i) {
// 透過取餘操作實現陣列首尾相連
// 當 i 越過陣列尾部後，回到頭部
// 當 i 越過陣列頭部後，回到尾部
return (i + capacity()) % capacity();
}
/* 佇列首入列 */
void pushFirst(int num) {
if (queSize == capacity()) {
cout << "雙向佇列已滿" << endl;
return;
}
// 佇列首指標向左移動一位
// 透過取餘操作實現 front 越過陣列頭部後回到尾部
front = index(front - 1);
// 將 num 新增至佇列首
nums[front] = num;
queSize++;
}
/* 佇列尾入列 */
void pushLast(int num) {
if (queSize == capacity()) {
cout << "雙向佇列已滿" << endl;
return;
}
// 計算佇列尾指標，指向佇列尾索引 + 1
int rear = index(front + queSize);
// 將 num 新增至佇列尾
nums[rear] = num;
queSize++;
}
/* 佇列首出列 */
int popFirst() {
int num = peekFirst();
// 佇列首指標向後移動一位
front = index(front + 1);
queSize--;
return num;
}
/* 佇列尾出列 */
int popLast() {
int num = peekLast();
queSize--;
return num;
}
/* 訪問佇列首元素 */
int peekFirst() {
if (isEmpty())
throw out_of_range("雙向佇列為空");
return nums[front];
}
/* 訪問佇列尾元素 */
int peekLast() {
if (isEmpty())
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)];
}
return res;
}
};
/* Driver Code */
int main() {
/* 初始化雙向佇列 */
ArrayDeque *deque = new ArrayDeque(10);
deque->pushLast(3);
deque->pushLast(2);
deque->pushLast(5);
cout << "雙向佇列 deque = ";
printVector(deque->toVector());
/* 訪問元素 */
int peekFirst = deque->peekFirst();
cout << "佇列首元素 peekFirst = " << peekFirst << endl;
int peekLast = deque->peekLast();
cout << "佇列尾元素 peekLast = " << peekLast << endl;
/* 元素入列 */
deque->pushLast(4);
cout << "元素 4 佇列尾入列後 deque = ";
printVector(deque->toVector());
deque->pushFirst(1);
cout << "元素 1 佇列首入列後 deque = ";
printVector(deque->toVector());
/* 元素出列 */
int popLast = deque->popLast();
cout << "佇列尾出列元素 = " << popLast << "，佇列尾出列後 deque = ";
printVector(deque->toVector());
int popFirst = deque->popFirst();
cout << "佇列首出列元素 = " << popFirst << "，佇列首出列後 deque = ";
printVector(deque->toVector());
/* 獲取雙向佇列的長度 */
int size = deque->size();
cout << "雙向佇列長度 size = " << size << endl;
/* 判斷雙向佇列是否為空 */
bool isEmpty = deque->isEmpty();
cout << "雙向佇列是否為空 = " << boolalpha << isEmpty << endl;
return 0;
}
zh-hant/codes/cpp/chapter_stack_and_queue/array_queue.cpp
+129
View File
@@ -0,0 +1,129 @@
/**
* File: array_queue.cpp
* Created Time: 2022-11-25
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 基於環形陣列實現的佇列 */
class ArrayQueue {
private:
int *nums; // 用於儲存佇列元素的陣列
int front; // 佇列首指標，指向佇列首元素
int queSize; // 佇列長度
int queCapacity; // 佇列容量
public:
ArrayQueue(int capacity) {
// 初始化陣列
nums = new int[capacity];
queCapacity = capacity;
front = queSize = 0;
}
~ArrayQueue() {
delete[] nums;
}
/* 獲取佇列的容量 */
int capacity() {
return queCapacity;
}
/* 獲取佇列的長度 */
int size() {
return queSize;
}
/* 判斷佇列是否為空 */
bool isEmpty() {
return size() == 0;
}
/* 入列 */
void push(int num) {
if (queSize == queCapacity) {
cout << "佇列已滿" << endl;
return;
}
// 計算佇列尾指標，指向佇列尾索引 + 1
// 透過取餘操作實現 rear 越過陣列尾部後回到頭部
int rear = (front + queSize) % queCapacity;
// 將 num 新增至佇列尾
nums[rear] = num;
queSize++;
}
/* 出列 */
int pop() {
int num = peek();
// 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部
front = (front + 1) % queCapacity;
queSize--;
return num;
}
/* 訪問佇列首元素 */
int peek() {
if (isEmpty())
throw out_of_range("佇列為空");
return nums[front];
}
/* 將陣列轉化為 Vector 並返回 */
vector<int> toVector() {
// 僅轉換有效長度範圍內的串列元素
vector<int> arr(queSize);
for (int i = 0, j = front; i < queSize; i++, j++) {
arr[i] = nums[j % queCapacity];
}
return arr;
}
};
/* 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 = ";
printVector(queue->toVector());
/* 訪問佇列首元素 */
int peek = queue->peek();
cout << "佇列首元素 peek = " << peek << endl;
/* 元素出列 */
peek = queue->pop();
cout << "出列元素 pop = " << peek << "，出列後 queue = ";
printVector(queue->toVector());
/* 獲取佇列的長度 */
int size = queue->size();
cout << "佇列長度 size = " << size << endl;
/* 判斷佇列是否為空 */
bool empty = queue->isEmpty();
cout << "佇列是否為空 = " << empty << endl;
/* 測試環形陣列 */
for (int i = 0; i < 10; i++) {
queue->push(i);
queue->pop();
cout << "第 " << i << " 輪入列 + 出列後 queue = ";
printVector(queue->toVector());
}
// 釋放記憶體
delete queue;
return 0;
}
zh-hant/codes/cpp/chapter_stack_and_queue/array_stack.cpp
+85
View File
@@ -0,0 +1,85 @@
/**
* File: array_stack.cpp
* Created Time: 2022-11-28
* Author: qualifier1024 (2539244001@qq.com)
*/
#include "../utils/common.hpp"
/* 基於陣列實現的堆疊 */
class ArrayStack {
private:
vector<int> stack;
public:
/* 獲取堆疊的長度 */
int size() {
return stack.size();
}
/* 判斷堆疊是否為空 */
bool isEmpty() {
return stack.size() == 0;
}
/* 入堆疊 */
void push(int num) {
stack.push_back(num);
}
/* 出堆疊 */
int pop() {
int num = top();
stack.pop_back();
return num;
}
/* 訪問堆疊頂元素 */
int top() {
if (isEmpty())
throw out_of_range("堆疊為空");
return stack.back();
}
/* 返回 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 = ";
printVector(stack->toVector());
/* 訪問堆疊頂元素 */
int top = stack->top();
cout << "堆疊頂元素 top = " << top << endl;
/* 元素出堆疊 */
top = stack->pop();
cout << "出堆疊元素 pop = " << top << "，出堆疊後 stack = ";
printVector(stack->toVector());
/* 獲取堆疊的長度 */
int size = stack->size();
cout << "堆疊的長度 size = " << size << endl;
/* 判斷是否為空 */
bool empty = stack->isEmpty();
cout << "堆疊是否為空 = " << empty << endl;
// 釋放記憶體
delete stack;
return 0;
}
zh-hant/codes/cpp/chapter_stack_and_queue/deque.cpp
+46
View File
@@ -0,0 +1,46 @@
/**
* File: deque.cpp
* Created Time: 2022-11-25
* Author: krahets (krahets@163.com)
*/
#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 << "雙向佇列 deque = ";
printDeque(deque);
/* 訪問元素 */
int front = deque.front();
cout << "佇列首元素 front = " << front << endl;
int back = deque.back();
cout << "佇列尾元素 back = " << back << endl;
/* 元素出列 */
deque.pop_front();
cout << "佇列首出列元素 popFront = " << front << "，佇列首出列後 deque = ";
printDeque(deque);
deque.pop_back();
cout << "佇列尾出列元素 popLast = " << back << "，佇列尾出列後 deque = ";
printDeque(deque);
/* 獲取雙向佇列的長度 */
int size = deque.size();
cout << "雙向佇列長度 size = " << size << endl;
/* 判斷雙向佇列是否為空 */
bool empty = deque.empty();
cout << "雙向佇列是否為空 = " << empty << endl;
return 0;
}
zh-hant/codes/cpp/chapter_stack_and_queue/linkedlist_deque.cpp
+194
View File
@@ -0,0 +1,194 @@
/**
* File: linkedlist_deque.cpp
* Created Time: 2023-03-02
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 雙向鏈結串列節點 */
struct DoublyListNode {
int val; // 節點值
DoublyListNode *next; // 後繼節點指標
DoublyListNode *prev; // 前驅節點指標
DoublyListNode(int val) : val(val), prev(nullptr), next(nullptr) {
}
};
/* 基於雙向鏈結串列實現的雙向佇列 */
class LinkedListDeque {
private:
DoublyListNode *front, *rear; // 頭節點 front ，尾節點 rear
int queSize = 0; // 雙向佇列的長度
public:
/* 建構子 */
LinkedListDeque() : front(nullptr), rear(nullptr) {
}
/* 析構方法 */
~LinkedListDeque() {
// 走訪鏈結串列刪除節點，釋放記憶體
DoublyListNode *pre, *cur = front;
while (cur != nullptr) {
pre = cur;
cur = cur->next;
delete pre;
}
}
/* 獲取雙向佇列的長度 */
int size() {
return queSize;
}
/* 判斷雙向佇列是否為空 */
bool isEmpty() {
return size() == 0;
}
/* 入列操作 */
void push(int num, bool isFront) {
DoublyListNode *node = new DoublyListNode(num);
// 若鏈結串列為空，則令 front 和 rear 都指向 node
if (isEmpty())
front = rear = node;
// 佇列首入列操作
else if (isFront) {
// 將 node 新增至鏈結串列頭部
front->prev = node;
node->next = front;
front = node; // 更新頭節點
// 佇列尾入列操作
} else {
// 將 node 新增至鏈結串列尾部
rear->next = node;
node->prev = rear;
rear = node; // 更新尾節點
}
queSize++; // 更新佇列長度
}
/* 佇列首入列 */
void pushFirst(int num) {
push(num, true);
}
/* 佇列尾入列 */
void pushLast(int num) {
push(num, false);
}
/* 出列操作 */
int pop(bool isFront) {
if (isEmpty())
throw out_of_range("佇列為空");
int val;
// 佇列首出列操作
if (isFront) {
val = front->val; // 暫存頭節點值
// 刪除頭節點
DoublyListNode *fNext = front->next;
if (fNext != nullptr) {
fNext->prev = nullptr;
front->next = nullptr;
}
delete front;
front = fNext; // 更新頭節點
// 佇列尾出列操作
} else {
val = rear->val; // 暫存尾節點值
// 刪除尾節點
DoublyListNode *rPrev = rear->prev;
if (rPrev != nullptr) {
rPrev->next = nullptr;
rear->prev = nullptr;
}
delete rear;
rear = rPrev; // 更新尾節點
}
queSize--; // 更新佇列長度
return val;
}
/* 佇列首出列 */
int popFirst() {
return pop(true);
}
/* 佇列尾出列 */
int popLast() {
return pop(false);
}
/* 訪問佇列首元素 */
int peekFirst() {
if (isEmpty())
throw out_of_range("雙向佇列為空");
return front->val;
}
/* 訪問佇列尾元素 */
int peekLast() {
if (isEmpty())
throw out_of_range("雙向佇列為空");
return rear->val;
}
/* 返回陣列用於列印 */
vector<int> toVector() {
DoublyListNode *node = front;
vector<int> res(size());
for (int i = 0; i < res.size(); i++) {
res[i] = node->val;
node = node->next;
}
return res;
}
};
/* Driver Code */
int main() {
/* 初始化雙向佇列 */
LinkedListDeque *deque = new LinkedListDeque();
deque->pushLast(3);
deque->pushLast(2);
deque->pushLast(5);
cout << "雙向佇列 deque = ";
printVector(deque->toVector());
/* 訪問元素 */
int peekFirst = deque->peekFirst();
cout << "佇列首元素 peekFirst = " << peekFirst << endl;
int peekLast = deque->peekLast();
cout << "佇列尾元素 peekLast = " << peekLast << endl;
/* 元素入列 */
deque->pushLast(4);
cout << "元素 4 佇列尾入列後 deque =";
printVector(deque->toVector());
deque->pushFirst(1);
cout << "元素 1 佇列首入列後 deque = ";
printVector(deque->toVector());
/* 元素出列 */
int popLast = deque->popLast();
cout << "佇列尾出列元素 = " << popLast << "，佇列尾出列後 deque = ";
printVector(deque->toVector());
int popFirst = deque->popFirst();
cout << "佇列首出列元素 = " << popFirst << "，佇列首出列後 deque = ";
printVector(deque->toVector());
/* 獲取雙向佇列的長度 */
int size = deque->size();
cout << "雙向佇列長度 size = " << size << endl;
/* 判斷雙向佇列是否為空 */
bool isEmpty = deque->isEmpty();
cout << "雙向佇列是否為空 = " << boolalpha << isEmpty << endl;
// 釋放記憶體
delete deque;
return 0;
}
zh-hant/codes/cpp/chapter_stack_and_queue/linkedlist_queue.cpp
+120
View File
@@ -0,0 +1,120 @@
/**
* File: linkedlist_queue.cpp
* Created Time: 2022-11-25
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 基於鏈結串列實現的佇列 */
class LinkedListQueue {
private:
ListNode *front, *rear; // 頭節點 front ，尾節點 rear
int queSize;
public:
LinkedListQueue() {
front = nullptr;
rear = nullptr;
queSize = 0;
}
~LinkedListQueue() {
// 走訪鏈結串列刪除節點，釋放記憶體
freeMemoryLinkedList(front);
}
/* 獲取佇列的長度 */
int size() {
return queSize;
}
/* 判斷佇列是否為空 */
bool isEmpty() {
return queSize == 0;
}
/* 入列 */
void push(int num) {
// 在尾節點後新增 num
ListNode *node = new ListNode(num);
// 如果佇列為空，則令頭、尾節點都指向該節點
if (front == nullptr) {
front = node;
rear = node;
}
// 如果佇列不為空，則將該節點新增到尾節點後
else {
rear->next = node;
rear = node;
}
queSize++;
}
/* 出列 */
int pop() {
int num = peek();
// 刪除頭節點
ListNode *tmp = front;
front = front->next;
// 釋放記憶體
delete tmp;
queSize--;
return num;
}
/* 訪問佇列首元素 */
int peek() {
if (size() == 0)
throw out_of_range("佇列為空");
return front->val;
}
/* 將鏈結串列轉化為 Vector 並返回 */
vector<int> toVector() {
ListNode *node = front;
vector<int> res(size());
for (int i = 0; i < res.size(); i++) {
res[i] = node->val;
node = node->next;
}
return res;
}
};
/* 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 = ";
printVector(queue->toVector());
/* 訪問佇列首元素 */
int peek = queue->peek();
cout << "佇列首元素 peek = " << peek << endl;
/* 元素出列 */
peek = queue->pop();
cout << "出列元素 pop = " << peek << "，出列後 queue = ";
printVector(queue->toVector());
/* 獲取佇列的長度 */
int size = queue->size();
cout << "佇列長度 size = " << size << endl;
/* 判斷佇列是否為空 */
bool empty = queue->isEmpty();
cout << "佇列是否為空 = " << empty << endl;
// 釋放記憶體
delete queue;
return 0;
}
zh-hant/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp
+109
View File
@@ -0,0 +1,109 @@
/**
* File: linkedlist_stack.cpp
* Created Time: 2022-11-28
* Author: qualifier1024 (2539244001@qq.com)
*/
#include "../utils/common.hpp"
/* 基於鏈結串列實現的堆疊 */
class LinkedListStack {
private:
ListNode *stackTop; // 將頭節點作為堆疊頂
int stkSize; // 堆疊的長度
public:
LinkedListStack() {
stackTop = nullptr;
stkSize = 0;
}
~LinkedListStack() {
// 走訪鏈結串列刪除節點，釋放記憶體
freeMemoryLinkedList(stackTop);
}
/* 獲取堆疊的長度 */
int size() {
return stkSize;
}
/* 判斷堆疊是否為空 */
bool isEmpty() {
return size() == 0;
}
/* 入堆疊 */
void push(int num) {
ListNode *node = new ListNode(num);
node->next = stackTop;
stackTop = node;
stkSize++;
}
/* 出堆疊 */
int pop() {
int num = top();
ListNode *tmp = stackTop;
stackTop = stackTop->next;
// 釋放記憶體
delete tmp;
stkSize--;
return num;
}
/* 訪問堆疊頂元素 */
int top() {
if (isEmpty())
throw out_of_range("堆疊為空");
return stackTop->val;
}
/* 將 List 轉化為 Array 並返回 */
vector<int> toVector() {
ListNode *node = stackTop;
vector<int> res(size());
for (int i = res.size() - 1; i >= 0; i--) {
res[i] = node->val;
node = node->next;
}
return res;
}
};
/* 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 = ";
printVector(stack->toVector());
/* 訪問堆疊頂元素 */
int top = stack->top();
cout << "堆疊頂元素 top = " << top << endl;
/* 元素出堆疊 */
top = stack->pop();
cout << "出堆疊元素 pop = " << top << "，出堆疊後 stack = ";
printVector(stack->toVector());
/* 獲取堆疊的長度 */
int size = stack->size();
cout << "堆疊的長度 size = " << size << endl;
/* 判斷是否為空 */
bool empty = stack->isEmpty();
cout << "堆疊是否為空 = " << empty << endl;
// 釋放記憶體
delete stack;
return 0;
}
zh-hant/codes/cpp/chapter_stack_and_queue/queue.cpp
+41
View File
@@ -0,0 +1,41 @@
/**
* File: queue.cpp
* Created Time: 2022-11-28
* Author: qualifier1024 (2539244001@qq.com)
*/
#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 = ";
printQueue(queue);
/* 訪問佇列首元素 */
int front = queue.front();
cout << "佇列首元素 front = " << front << endl;
/* 元素出列 */
queue.pop();
cout << "出列元素 front = " << front << "，出列後 queue = ";
printQueue(queue);
/* 獲取佇列的長度 */
int size = queue.size();
cout << "佇列長度 size = " << size << endl;
/* 判斷佇列是否為空 */
bool empty = queue.empty();
cout << "佇列是否為空 = " << empty << endl;
return 0;
}
zh-hant/codes/cpp/chapter_stack_and_queue/stack.cpp
+41
View File
@@ -0,0 +1,41 @@
/**
* File: stack.cpp
* Created Time: 2022-11-28
* Author: qualifier1024 (2539244001@qq.com)
*/
#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 = ";
printStack(stack);
/* 訪問堆疊頂元素 */
int top = stack.top();
cout << "堆疊頂元素 top = " << top << endl;
/* 元素出堆疊 */
stack.pop(); // 無返回值
cout << "出堆疊元素 pop = " << top << "，出堆疊後 stack = ";
printStack(stack);
/* 獲取堆疊的長度 */
int size = stack.size();
cout << "堆疊的長度 size = " << size << endl;
/* 判斷是否為空 */
bool empty = stack.empty();
cout << "堆疊是否為空 = " << empty << endl;
return 0;
}
zh-hant/codes/cpp/chapter_tree/CMakeLists.txt
+6
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)
zh-hant/codes/cpp/chapter_tree/array_binary_tree.cpp
+137
View File
@@ -0,0 +1,137 @@
/**
* File: array_binary_tree.cpp
* Created Time: 2023-07-19
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 陣列表示下的二元樹類別 */
class ArrayBinaryTree {
public:
/* 建構子 */
ArrayBinaryTree(vector<int> arr) {
tree = arr;
}
/* 串列容量 */
int size() {
return tree.size();
}
/* 獲取索引為 i 節點的值 */
int val(int i) {
// 若索引越界，則返回 INT_MAX ，代表空位
if (i < 0 || i >= size())
return INT_MAX;
return tree[i];
}
/* 獲取索引為 i 節點的左子節點的索引 */
int left(int i) {
return 2 * i + 1;
}
/* 獲取索引為 i 節點的右子節點的索引 */
int right(int i) {
return 2 * i + 2;
}
/* 獲取索引為 i 節點的父節點的索引 */
int parent(int i) {
return (i - 1) / 2;
}
/* 層序走訪 */
vector<int> levelOrder() {
vector<int> res;
// 直接走訪陣列
for (int i = 0; i < size(); i++) {
if (val(i) != INT_MAX)
res.push_back(val(i));
}
return res;
}
/* 前序走訪 */
vector<int> preOrder() {
vector<int> res;
dfs(0, "pre", res);
return res;
}
/* 中序走訪 */
vector<int> inOrder() {
vector<int> res;
dfs(0, "in", res);
return res;
}
/* 後序走訪 */
vector<int> postOrder() {
vector<int> res;
dfs(0, "post", res);
return res;
}
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);
// 中序走訪
if (order == "in")
res.push_back(val(i));
dfs(right(i), order, res);
// 後序走訪
if (order == "post")
res.push_back(val(i));
}
};
/* Driver Code */
int main() {
// 初始化二元樹
// 使用 INT_MAX 代表空位 nullptr
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";
printVector(arr);
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";
// 走訪樹
vector<int> res = abt.levelOrder();
cout << "\n層序走訪為： ";
printVector(res);
res = abt.preOrder();
cout << "前序走訪為： ";
printVector(res);
res = abt.inOrder();
cout << "中序走訪為： ";
printVector(res);
res = abt.postOrder();
cout << "後序走訪為： ";
printVector(res);
return 0;
}
zh-hant/codes/cpp/chapter_tree/avl_tree.cpp
+233
View File
@@ -0,0 +1,233 @@
/**
* File: avl_tree.cpp
* Created Time: 2023-02-03
* Author: what-is-me (whatisme@outlook.jp)
*/
#include "../utils/common.hpp"
/* AVL 樹 */
class AVLTree {
public:
TreeNode *root; // 根節點
private:
/* 更新節點高度 */
void updateHeight(TreeNode *node) {
// 節點高度等於最高子樹高度 + 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->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->left = node;
node->right = grandChild;
// 更新節點高度
updateHeight(node);
updateHeight(child);
// 返回旋轉後子樹的根節點
return child;
}
/* 執行旋轉操作，使該子樹重新恢復平衡 */
TreeNode *rotate(TreeNode *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. 查詢插入位置並插入節點 */
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. 執行旋轉操作，使該子樹重新恢復平衡 */
node = rotate(node);
// 返回子樹的根節點
return node;
}
/* 遞迴刪除節點（輔助方法） */
TreeNode *removeHelper(TreeNode *node, int val) {
if (node == nullptr)
return nullptr;
/* 1. 查詢節點並刪除 */
if (val < node->val)
node->left = removeHelper(node->left, val);
else if (val > node->val)
node->right = removeHelper(node->right, val);
else {
if (node->left == nullptr || node->right == nullptr) {
TreeNode *child = node->left != nullptr ? node->left : node->right;
// 子節點數量 = 0 ，直接刪除 node 並返回
if (child == nullptr) {
delete node;
return nullptr;
}
// 子節點數量 = 1 ，直接刪除 node
else {
delete node;
node = child;
}
} else {
// 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點
TreeNode *temp = node->right;
while (temp->left != nullptr) {
temp = temp->left;
}
int tempVal = temp->val;
node->right = removeHelper(node->right, temp->val);
node->val = tempVal;
}
}
updateHeight(node); // 更新節點高度
/* 2. 執行旋轉操作，使該子樹重新恢復平衡 */
node = rotate(node);
// 返回子樹的根節點
return node;
}
public:
/* 獲取節點高度 */
int height(TreeNode *node) {
// 空節點高度為 -1 ，葉節點高度為 0
return node == nullptr ? -1 : node->height;
}
/* 獲取平衡因子 */
int balanceFactor(TreeNode *node) {
// 空節點平衡因子為 0
if (node == nullptr)
return 0;
// 節點平衡因子 = 左子樹高度 - 右子樹高度
return height(node->left) - height(node->right);
}
/* 插入節點 */
void insert(int val) {
root = insertHelper(root, val);
}
/* 刪除節點 */
void remove(int val) {
root = removeHelper(root, val);
}
/* 查詢節點 */
TreeNode *search(int val) {
TreeNode *cur = root;
// 迴圈查詢，越過葉節點後跳出
while (cur != nullptr) {
// 目標節點在 cur 的右子樹中
if (cur->val < val)
cur = cur->right;
// 目標節點在 cur 的左子樹中
else if (cur->val > val)
cur = cur->left;
// 找到目標節點，跳出迴圈
else
break;
}
// 返回目標節點
return cur;
}
/*建構子*/
AVLTree() : root(nullptr) {
}
/*析構方法*/
~AVLTree() {
freeMemoryTree(root);
}
};
void testInsert(AVLTree &tree, int val) {
tree.insert(val);
cout << "\n插入節點 " << val << " 後，AVL 樹為" << endl;
printTree(tree.root);
}
void testRemove(AVLTree &tree, int val) {
tree.remove(val);
cout << "\n刪除節點 " << val << " 後，AVL 樹為" << endl;
printTree(tree.root);
}
/* Driver Code */
int main() {
/* 初始化空 AVL 樹 */
AVLTree avlTree;
/* 插入節點 */
// 請關注插入節點後，AVL 樹是如何保持平衡的
testInsert(avlTree, 1);
testInsert(avlTree, 2);
testInsert(avlTree, 3);
testInsert(avlTree, 4);
testInsert(avlTree, 5);
testInsert(avlTree, 8);
testInsert(avlTree, 7);
testInsert(avlTree, 9);
testInsert(avlTree, 10);
testInsert(avlTree, 6);
/* 插入重複節點 */
testInsert(avlTree, 7);
/* 刪除節點 */
// 請關注刪除節點後，AVL 樹是如何保持平衡的
testRemove(avlTree, 8); // 刪除度為 0 的節點
testRemove(avlTree, 5); // 刪除度為 1 的節點
testRemove(avlTree, 4); // 刪除度為 2 的節點
/* 查詢節點 */
TreeNode *node = avlTree.search(7);
cout << "\n查詢到的節點物件為 " << node << "，節點值 = " << node->val << endl;
}
zh-hant/codes/cpp/chapter_tree/binary_search_tree.cpp
+170
View File
@@ -0,0 +1,170 @@
/**
* File: binary_search_tree.cpp
* Created Time: 2022-11-25
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 二元搜尋樹 */
class BinarySearchTree {
private:
TreeNode *root;
public:
/* 建構子 */
BinarySearchTree() {
// 初始化空樹
root = nullptr;
}
/* 析構方法 */
~BinarySearchTree() {
freeMemoryTree(root);
}
/* 獲取二元樹根節點 */
TreeNode *getRoot() {
return root;
}
/* 查詢節點 */
TreeNode *search(int num) {
TreeNode *cur = root;
// 迴圈查詢，越過葉節點後跳出
while (cur != nullptr) {
// 目標節點在 cur 的右子樹中
if (cur->val < num)
cur = cur->right;
// 目標節點在 cur 的左子樹中
else if (cur->val > num)
cur = cur->left;
// 找到目標節點，跳出迴圈
else
break;
}
// 返回目標節點
return cur;
}
/* 插入節點 */
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 的右子樹中
if (cur->val < num)
cur = cur->right;
// 插入位置在 cur 的左子樹中
else
cur = cur->left;
}
// 插入節點
TreeNode *node = new TreeNode(num);
if (pre->val < num)
pre->right = node;
else
pre->left = node;
}
/* 刪除節點 */
void remove(int num) {
// 若樹為空，直接提前返回
if (root == nullptr)
return;
TreeNode *cur = root, *pre = nullptr;
// 迴圈查詢，越過葉節點後跳出
while (cur != nullptr) {
// 找到待刪除節點，跳出迴圈
if (cur->val == num)
break;
pre = cur;
// 待刪除節點在 cur 的右子樹中
if (cur->val < num)
cur = cur->right;
// 待刪除節點在 cur 的左子樹中
else
cur = cur->left;
}
// 若無待刪除節點，則直接返回
if (cur == nullptr)
return;
// 子節點數量 = 0 or 1
if (cur->left == nullptr || cur->right == nullptr) {
// 當子節點數量 = 0 / 1 時， child = nullptr / 該子節點
TreeNode *child = cur->left != nullptr ? cur->left : cur->right;
// 刪除節點 cur
if (cur != root) {
if (pre->left == cur)
pre->left = child;
else
pre->right = child;
} else {
// 若刪除節點為根節點，則重新指定根節點
root = child;
}
// 釋放記憶體
delete cur;
}
// 子節點數量 = 2
else {
// 獲取中序走訪中 cur 的下一個節點
TreeNode *tmp = cur->right;
while (tmp->left != nullptr) {
tmp = tmp->left;
}
int tmpVal = tmp->val;
// 遞迴刪除節點 tmp
remove(tmp->val);
// 用 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;
printTree(bst->getRoot());
/* 查詢節點 */
TreeNode *node = bst->search(7);
cout << endl << "查詢到的節點物件為 " << node << "，節點值 = " << node->val << endl;
/* 插入節點 */
bst->insert(16);
cout << endl << "插入節點 16 後，二元樹為\n" << endl;
printTree(bst->getRoot());
/* 刪除節點 */
bst->remove(1);
cout << endl << "刪除節點 1 後，二元樹為\n" << endl;
printTree(bst->getRoot());
bst->remove(2);
cout << endl << "刪除節點 2 後，二元樹為\n" << endl;
printTree(bst->getRoot());
bst->remove(4);
cout << endl << "刪除節點 4 後，二元樹為\n" << endl;
printTree(bst->getRoot());
// 釋放記憶體
delete bst;
return 0;
}
zh-hant/codes/cpp/chapter_tree/binary_tree.cpp
+43
View File
@@ -0,0 +1,43 @@
/**
* File: binary_tree.cpp
* Created Time: 2022-11-25
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* Driver Code */
int main() {
/* 初始化二元樹 */
// 初始化節點
TreeNode *n1 = new TreeNode(1);
TreeNode *n2 = new TreeNode(2);
TreeNode *n3 = new TreeNode(3);
TreeNode *n4 = new TreeNode(4);
TreeNode *n5 = new TreeNode(5);
// 構建節點之間的引用（指標）
n1->left = n2;
n1->right = n3;
n2->left = n4;
n2->right = n5;
cout << endl << "初始化二元樹\n" << endl;
printTree(n1);
/* 插入與刪除節點 */
TreeNode *P = new TreeNode(0);
// 在 n1 -> n2 中間插入節點 P
n1->left = P;
P->left = n2;
cout << endl << "插入節點 P 後\n" << endl;
printTree(n1);
// 刪除節點 P
n1->left = n2;
delete P; // 釋放記憶體
cout << endl << "刪除節點 P 後\n" << endl;
printTree(n1);
// 釋放記憶體
freeMemoryTree(n1);
return 0;
}
zh-hant/codes/cpp/chapter_tree/binary_tree_bfs.cpp
+42
View File
@@ -0,0 +1,42 @@
/**
* File: binary_tree_bfs.cpp
* Created Time: 2022-11-25
* Author: krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 層序走訪 */
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); // 儲存節點值
if (node->left != nullptr)
queue.push(node->left); // 左子節點入列
if (node->right != nullptr)
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 << "層序走訪的節點列印序列 = ";
printVector(vec);
return 0;
}
zh-hant/codes/cpp/chapter_tree/binary_tree_dfs.cpp
+69
View File
@@ -0,0 +1,69 @@
/**
* File: binary_tree_dfs.cpp
* Created Time: 2022-11-25
* Author: krahets (krahets@163.com)
*/
#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);
}
/* 中序走訪 */
void inOrder(TreeNode *root) {
if (root == nullptr)
return;
// 訪問優先順序：左子樹 -> 根節點 -> 右子樹
inOrder(root->left);
vec.push_back(root->val);
inOrder(root->right);
}
/* 後序走訪 */
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 << "前序走訪的節點列印序列 = ";
printVector(vec);
/* 中序走訪 */
vec.clear();
inOrder(root);
cout << endl << "中序走訪的節點列印序列 = ";
printVector(vec);
/* 後序走訪 */
vec.clear();
postOrder(root);
cout << endl << "後序走訪的節點列印序列 = ";
printVector(vec);
return 0;
}
zh-hant/codes/cpp/utils/CMakeLists.txt
+4
View File
@@ -0,0 +1,4 @@
add_executable(utils
common.hpp print_utils.hpp
list_node.hpp tree_node.hpp
vertex.hpp)
zh-hant/codes/cpp/utils/common.hpp
+28
View File
@@ -0,0 +1,28 @@
/**
* File: common.hpp
* Created Time: 2021-12-19
* Author: krahets (krahets@163.com)
*/
#pragma once
#include <algorithm>
#include <chrono>
#include <deque>
#include <iostream>
#include <list>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include "list_node.hpp"
#include "print_utils.hpp"
#include "tree_node.hpp"
#include "vertex.hpp"
using namespace std;

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