diff --git a/.gitignore b/.gitignore
index cb287df..4e17eaf 100644
--- a/.gitignore
+++ b/.gitignore
@@ -59,3 +59,4 @@ _deps
 *.out
 *.app
 
+build
\ No newline at end of file
diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 0000000..ca284a3
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,9 @@
+{
+    "cmake.configureOnOpen": true,
+    "C_Cpp.default.configurationProvider": "ms-vscode.cmake-tools",
+    "files.associations": {
+        "climits": "cpp",
+        "sstream": "cpp",
+        "compare": "cpp"
+    }
+}
\ No newline at end of file
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
new file mode 100644
index 0000000..fc10398
--- /dev/null
+++ b/.vscode/tasks.json
@@ -0,0 +1,28 @@
+{
+    "tasks": [
+        {
+            "type": "cppbuild",
+            "label": "C/C++: g++.exe 生成活动文件",
+            "command": "C:\\mingw64\\bin\\g++.exe",
+            "args": [
+                "-fdiagnostics-color=always",
+                "-g",
+                "${file}",
+                "-o",
+                "${fileDirname}\\${fileBasenameNoExtension}.exe"
+            ],
+            "options": {
+                "cwd": "${fileDirname}"
+            },
+            "problemMatcher": [
+                "$gcc"
+            ],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "detail": "调试器生成的任务。"
+        }
+    ],
+    "version": "2.0.0"
+}
\ No newline at end of file
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..1e80bc4
--- /dev/null
+++ b/CMakeLists.txt
@@ -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)
diff --git a/chapter_array_and_linkedlist/CMakeLists.txt b/chapter_array_and_linkedlist/CMakeLists.txt
new file mode 100644
index 0000000..2e933e0
--- /dev/null
+++ b/chapter_array_and_linkedlist/CMakeLists.txt
@@ -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)
diff --git a/chapter_array_and_linkedlist/array.cpp b/chapter_array_and_linkedlist/array.cpp
new file mode 100644
index 0000000..538a2e1
--- /dev/null
+++ b/chapter_array_and_linkedlist/array.cpp
@@ -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;
+}
diff --git a/chapter_array_and_linkedlist/linked_list.cpp b/chapter_array_and_linkedlist/linked_list.cpp
new file mode 100644
index 0000000..3304ead
--- /dev/null
+++ b/chapter_array_and_linkedlist/linked_list.cpp
@@ -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;
+}
diff --git a/chapter_array_and_linkedlist/list.cpp b/chapter_array_and_linkedlist/list.cpp
new file mode 100644
index 0000000..4029173
--- /dev/null
+++ b/chapter_array_and_linkedlist/list.cpp
@@ -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;
+}
diff --git a/chapter_array_and_linkedlist/my_list.cpp b/chapter_array_and_linkedlist/my_list.cpp
new file mode 100644
index 0000000..af35a70
--- /dev/null
+++ b/chapter_array_and_linkedlist/my_list.cpp
@@ -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;
+}
diff --git a/chapter_backtracking/CMakeLists.txt b/chapter_backtracking/CMakeLists.txt
new file mode 100644
index 0000000..6c271e3
--- /dev/null
+++ b/chapter_backtracking/CMakeLists.txt
@@ -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)
diff --git a/chapter_backtracking/n_queens.cpp b/chapter_backtracking/n_queens.cpp
new file mode 100644
index 0000000..1e27986
--- /dev/null
+++ b/chapter_backtracking/n_queens.cpp
@@ -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;
+}
diff --git a/chapter_backtracking/permutations_i.cpp b/chapter_backtracking/permutations_i.cpp
new file mode 100644
index 0000000..da57810
--- /dev/null
+++ b/chapter_backtracking/permutations_i.cpp
@@ -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;
+}
diff --git a/chapter_backtracking/permutations_ii.cpp b/chapter_backtracking/permutations_ii.cpp
new file mode 100644
index 0000000..a113be4
--- /dev/null
+++ b/chapter_backtracking/permutations_ii.cpp
@@ -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;
+}
diff --git a/chapter_backtracking/preorder_traversal_i_compact.cpp b/chapter_backtracking/preorder_traversal_i_compact.cpp
new file mode 100644
index 0000000..811ae38
--- /dev/null
+++ b/chapter_backtracking/preorder_traversal_i_compact.cpp
@@ -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);
+}
diff --git a/chapter_backtracking/preorder_traversal_ii_compact.cpp b/chapter_backtracking/preorder_traversal_ii_compact.cpp
new file mode 100644
index 0000000..5a549e9
--- /dev/null
+++ b/chapter_backtracking/preorder_traversal_ii_compact.cpp
@@ -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);
+    }
+}
diff --git a/chapter_backtracking/preorder_traversal_iii_compact.cpp b/chapter_backtracking/preorder_traversal_iii_compact.cpp
new file mode 100644
index 0000000..f806e2d
--- /dev/null
+++ b/chapter_backtracking/preorder_traversal_iii_compact.cpp
@@ -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);
+    }
+}
diff --git a/chapter_backtracking/preorder_traversal_iii_template.cpp b/chapter_backtracking/preorder_traversal_iii_template.cpp
new file mode 100644
index 0000000..835d051
--- /dev/null
+++ b/chapter_backtracking/preorder_traversal_iii_template.cpp
@@ -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);
+    }
+}
diff --git a/chapter_backtracking/subset_sum_i.cpp b/chapter_backtracking/subset_sum_i.cpp
new file mode 100644
index 0000000..b9998d2
--- /dev/null
+++ b/chapter_backtracking/subset_sum_i.cpp
@@ -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;
+}
diff --git a/chapter_backtracking/subset_sum_i_naive.cpp b/chapter_backtracking/subset_sum_i_naive.cpp
new file mode 100644
index 0000000..0947a9b
--- /dev/null
+++ b/chapter_backtracking/subset_sum_i_naive.cpp
@@ -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;
+}
diff --git a/chapter_backtracking/subset_sum_ii.cpp b/chapter_backtracking/subset_sum_ii.cpp
new file mode 100644
index 0000000..9c277aa
--- /dev/null
+++ b/chapter_backtracking/subset_sum_ii.cpp
@@ -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;
+}
diff --git a/chapter_computational_complexity/CMakeLists.txt b/chapter_computational_complexity/CMakeLists.txt
new file mode 100644
index 0000000..ea2845b
--- /dev/null
+++ b/chapter_computational_complexity/CMakeLists.txt
@@ -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)
\ No newline at end of file
diff --git a/chapter_computational_complexity/iteration.cpp b/chapter_computational_complexity/iteration.cpp
new file mode 100644
index 0000000..cbefe8d
--- /dev/null
+++ b/chapter_computational_complexity/iteration.cpp
@@ -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;
+}
diff --git a/chapter_computational_complexity/recursion.cpp b/chapter_computational_complexity/recursion.cpp
new file mode 100644
index 0000000..60d2eb8
--- /dev/null
+++ b/chapter_computational_complexity/recursion.cpp
@@ -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;
+}
diff --git a/chapter_computational_complexity/space_complexity.cpp b/chapter_computational_complexity/space_complexity.cpp
new file mode 100644
index 0000000..6f9944f
--- /dev/null
+++ b/chapter_computational_complexity/space_complexity.cpp
@@ -0,0 +1,107 @@
+/**
+ * File: space_complexity.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* ���� */
+int func() {
+    // ִ��ijЩ����
+    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;
+}
diff --git a/chapter_computational_complexity/time_complexity.cpp b/chapter_computational_complexity/time_complexity.cpp
new file mode 100644
index 0000000..2ba6ccc
--- /dev/null
+++ b/chapter_computational_complexity/time_complexity.cpp
@@ -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;
+    // ѭ�����������鳤�ȳ�ƽ����ϵ
+    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(float n) {
+    int count = 0;
+    while (n > 1) {
+        n = n / 2;
+        count++;
+    }
+    return count;
+}
+
+/* �����ף��ݹ�ʵ�֣� */
+int logRecur(float n) {
+    if (n <= 1)
+        return 0;
+    return logRecur(n / 2) + 1;
+}
+
+/* ���Զ����� */
+int linearLogRecur(float 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 ���У����һ�¸��ָ��ӶȵIJ��������仯����
+    int n = 8;
+    cout << "�������ݴ�С n = " << n << endl;
+
+    int count = constant(n);
+    cout << "�����׵IJ������� = " << count << endl;
+
+    count = linear(n);
+    cout << "���Խ׵IJ������� = " << count << endl;
+    vector<int> arr(n);
+    count = arrayTraversal(arr);
+    cout << "���Խף��������飩�IJ������� = " << count << endl;
+
+    count = quadratic(n);
+    cout << "ƽ���׵IJ������� = " << 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 << "ƽ���ף�ð�����򣩵IJ������� = " << count << endl;
+
+    count = exponential(n);
+    cout << "ָ���ף�ѭ��ʵ�֣��IJ������� = " << count << endl;
+    count = expRecur(n);
+    cout << "ָ���ף��ݹ�ʵ�֣��IJ������� = " << count << endl;
+
+    count = logarithmic((float)n);
+    cout << "�����ף�ѭ��ʵ�֣��IJ������� = " << count << endl;
+    count = logRecur((float)n);
+    cout << "�����ף��ݹ�ʵ�֣��IJ������� = " << count << endl;
+
+    count = linearLogRecur((float)n);
+    cout << "���Զ����ף��ݹ�ʵ�֣��IJ������� = " << count << endl;
+
+    count = factorialRecur(n);
+    cout << "�׳˽ף��ݹ�ʵ�֣��IJ������� = " << count << endl;
+
+    return 0;
+}
diff --git a/chapter_computational_complexity/worst_best_time_complexity.cpp b/chapter_computational_complexity/worst_best_time_complexity.cpp
new file mode 100644
index 0000000..5e8843f
--- /dev/null
+++ b/chapter_computational_complexity/worst_best_time_complexity.cpp
@@ -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;
+}
diff --git a/chapter_divide_and_conquer/CMakeLists.txt b/chapter_divide_and_conquer/CMakeLists.txt
new file mode 100644
index 0000000..38dfff7
--- /dev/null
+++ b/chapter_divide_and_conquer/CMakeLists.txt
@@ -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)
\ No newline at end of file
diff --git a/chapter_divide_and_conquer/binary_search_recur.cpp b/chapter_divide_and_conquer/binary_search_recur.cpp
new file mode 100644
index 0000000..d72de52
--- /dev/null
+++ b/chapter_divide_and_conquer/binary_search_recur.cpp
@@ -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;
+}
\ No newline at end of file
diff --git a/chapter_divide_and_conquer/build_tree.cpp b/chapter_divide_and_conquer/build_tree.cpp
new file mode 100644
index 0000000..a677e72
--- /dev/null
+++ b/chapter_divide_and_conquer/build_tree.cpp
@@ -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;
+}
diff --git a/chapter_divide_and_conquer/hanota.cpp b/chapter_divide_and_conquer/hanota.cpp
new file mode 100644
index 0000000..79313b3
--- /dev/null
+++ b/chapter_divide_and_conquer/hanota.cpp
@@ -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;
+}
diff --git a/chapter_dynamic_programming/CMakeLists.txt b/chapter_dynamic_programming/CMakeLists.txt
new file mode 100644
index 0000000..ed18545
--- /dev/null
+++ b/chapter_dynamic_programming/CMakeLists.txt
@@ -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)
\ No newline at end of file
diff --git a/chapter_dynamic_programming/climbing_stairs_backtrack.cpp b/chapter_dynamic_programming/climbing_stairs_backtrack.cpp
new file mode 100644
index 0000000..dbe405f
--- /dev/null
+++ b/chapter_dynamic_programming/climbing_stairs_backtrack.cpp
@@ -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;
+}
diff --git a/chapter_dynamic_programming/climbing_stairs_constraint_dp.cpp b/chapter_dynamic_programming/climbing_stairs_constraint_dp.cpp
new file mode 100644
index 0000000..c5b5db1
--- /dev/null
+++ b/chapter_dynamic_programming/climbing_stairs_constraint_dp.cpp
@@ -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;
+}
diff --git a/chapter_dynamic_programming/climbing_stairs_dfs.cpp b/chapter_dynamic_programming/climbing_stairs_dfs.cpp
new file mode 100644
index 0000000..73b5e80
--- /dev/null
+++ b/chapter_dynamic_programming/climbing_stairs_dfs.cpp
@@ -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;
+}
diff --git a/chapter_dynamic_programming/climbing_stairs_dfs_mem.cpp b/chapter_dynamic_programming/climbing_stairs_dfs_mem.cpp
new file mode 100644
index 0000000..a8cc1ea
--- /dev/null
+++ b/chapter_dynamic_programming/climbing_stairs_dfs_mem.cpp
@@ -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;
+}
diff --git a/chapter_dynamic_programming/climbing_stairs_dp.cpp b/chapter_dynamic_programming/climbing_stairs_dp.cpp
new file mode 100644
index 0000000..5eb5ddf
--- /dev/null
+++ b/chapter_dynamic_programming/climbing_stairs_dp.cpp
@@ -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;
+}
diff --git a/chapter_dynamic_programming/coin_change.cpp b/chapter_dynamic_programming/coin_change.cpp
new file mode 100644
index 0000000..2daa2ac
--- /dev/null
+++ b/chapter_dynamic_programming/coin_change.cpp
@@ -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;
+}
diff --git a/chapter_dynamic_programming/coin_change_ii.cpp b/chapter_dynamic_programming/coin_change_ii.cpp
new file mode 100644
index 0000000..302eb7e
--- /dev/null
+++ b/chapter_dynamic_programming/coin_change_ii.cpp
@@ -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;
+}
diff --git a/chapter_dynamic_programming/edit_distance.cpp b/chapter_dynamic_programming/edit_distance.cpp
new file mode 100644
index 0000000..6257189
--- /dev/null
+++ b/chapter_dynamic_programming/edit_distance.cpp
@@ -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;
+}
diff --git a/chapter_dynamic_programming/knapsack.cpp b/chapter_dynamic_programming/knapsack.cpp
new file mode 100644
index 0000000..c15f165
--- /dev/null
+++ b/chapter_dynamic_programming/knapsack.cpp
@@ -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;
+}
diff --git a/chapter_dynamic_programming/min_cost_climbing_stairs_dp.cpp b/chapter_dynamic_programming/min_cost_climbing_stairs_dp.cpp
new file mode 100644
index 0000000..578b60e
--- /dev/null
+++ b/chapter_dynamic_programming/min_cost_climbing_stairs_dp.cpp
@@ -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;
+}
diff --git a/chapter_dynamic_programming/min_path_sum.cpp b/chapter_dynamic_programming/min_path_sum.cpp
new file mode 100644
index 0000000..70f6a2b
--- /dev/null
+++ b/chapter_dynamic_programming/min_path_sum.cpp
@@ -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;
+}
diff --git a/chapter_dynamic_programming/unbounded_knapsack.cpp b/chapter_dynamic_programming/unbounded_knapsack.cpp
new file mode 100644
index 0000000..5956027
--- /dev/null
+++ b/chapter_dynamic_programming/unbounded_knapsack.cpp
@@ -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;
+}
diff --git a/chapter_graph/CMakeLists.txt b/chapter_graph/CMakeLists.txt
new file mode 100644
index 0000000..4a56ce3
--- /dev/null
+++ b/chapter_graph/CMakeLists.txt
@@ -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)
diff --git a/chapter_graph/graph_adjacency_list.cpp b/chapter_graph/graph_adjacency_list.cpp
new file mode 100644
index 0000000..3538732
--- /dev/null
+++ b/chapter_graph/graph_adjacency_list.cpp
@@ -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
diff --git a/chapter_graph/graph_adjacency_list_test.cpp b/chapter_graph/graph_adjacency_list_test.cpp
new file mode 100644
index 0000000..fdb200e
--- /dev/null
+++ b/chapter_graph/graph_adjacency_list_test.cpp
@@ -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;
+}
diff --git a/chapter_graph/graph_adjacency_matrix.cpp b/chapter_graph/graph_adjacency_matrix.cpp
new file mode 100644
index 0000000..42f696b
--- /dev/null
+++ b/chapter_graph/graph_adjacency_matrix.cpp
@@ -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;
+}
diff --git a/chapter_graph/graph_bfs.cpp b/chapter_graph/graph_bfs.cpp
new file mode 100644
index 0000000..c2a195b
--- /dev/null
+++ b/chapter_graph/graph_bfs.cpp
@@ -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;
+}
diff --git a/chapter_graph/graph_dfs.cpp b/chapter_graph/graph_dfs.cpp
new file mode 100644
index 0000000..d29f962
--- /dev/null
+++ b/chapter_graph/graph_dfs.cpp
@@ -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;
+}
diff --git a/chapter_greedy/CMakeLists.txt b/chapter_greedy/CMakeLists.txt
new file mode 100644
index 0000000..9178866
--- /dev/null
+++ b/chapter_greedy/CMakeLists.txt
@@ -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)
\ No newline at end of file
diff --git a/chapter_greedy/coin_change_greedy.cpp b/chapter_greedy/coin_change_greedy.cpp
new file mode 100644
index 0000000..bef764f
--- /dev/null
+++ b/chapter_greedy/coin_change_greedy.cpp
@@ -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;
+}
diff --git a/chapter_greedy/fractional_knapsack.cpp b/chapter_greedy/fractional_knapsack.cpp
new file mode 100644
index 0000000..2eaebbd
--- /dev/null
+++ b/chapter_greedy/fractional_knapsack.cpp
@@ -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;
+}
diff --git a/chapter_greedy/max_capacity.cpp b/chapter_greedy/max_capacity.cpp
new file mode 100644
index 0000000..555cd06
--- /dev/null
+++ b/chapter_greedy/max_capacity.cpp
@@ -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;
+}
diff --git a/chapter_greedy/max_product_cutting.cpp b/chapter_greedy/max_product_cutting.cpp
new file mode 100644
index 0000000..65fe893
--- /dev/null
+++ b/chapter_greedy/max_product_cutting.cpp
@@ -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;
+}
diff --git a/chapter_hashing/CMakeLists.txt b/chapter_hashing/CMakeLists.txt
new file mode 100644
index 0000000..6b583ef
--- /dev/null
+++ b/chapter_hashing/CMakeLists.txt
@@ -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)
\ No newline at end of file
diff --git a/chapter_hashing/array_hash_map.cpp b/chapter_hashing/array_hash_map.cpp
new file mode 100644
index 0000000..d8838c4
--- /dev/null
+++ b/chapter_hashing/array_hash_map.cpp
@@ -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
diff --git a/chapter_hashing/array_hash_map_test.cpp b/chapter_hashing/array_hash_map_test.cpp
new file mode 100644
index 0000000..4b3ccc8
--- /dev/null
+++ b/chapter_hashing/array_hash_map_test.cpp
@@ -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;
+}
diff --git a/chapter_hashing/built_in_hash.cpp b/chapter_hashing/built_in_hash.cpp
new file mode 100644
index 0000000..d7d48ab
--- /dev/null
+++ b/chapter_hashing/built_in_hash.cpp
@@ -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() ���ṩ�����������͵Ĺ�ϣֵ����
+    // ���顢����Ĺ�ϣֵ������Ҫ����ʵ��
+}
diff --git a/chapter_hashing/hash_map.cpp b/chapter_hashing/hash_map.cpp
new file mode 100644
index 0000000..8875032
--- /dev/null
+++ b/chapter_hashing/hash_map.cpp
@@ -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;
+}
diff --git a/chapter_hashing/hash_map_chaining.cpp b/chapter_hashing/hash_map_chaining.cpp
new file mode 100644
index 0000000..4fc373e
--- /dev/null
+++ b/chapter_hashing/hash_map_chaining.cpp
@@ -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;
+}
diff --git a/chapter_hashing/hash_map_open_addressing.cpp b/chapter_hashing/hash_map_open_addressing.cpp
new file mode 100644
index 0000000..7f9bf5a
--- /dev/null
+++ b/chapter_hashing/hash_map_open_addressing.cpp
@@ -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;
+}
diff --git a/chapter_hashing/simple_hash.cpp b/chapter_hashing/simple_hash.cpp
new file mode 100644
index 0000000..bdb6c04
--- /dev/null
+++ b/chapter_hashing/simple_hash.cpp
@@ -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;
+}
diff --git a/chapter_heap/CMakeLists.txt b/chapter_heap/CMakeLists.txt
new file mode 100644
index 0000000..1ac33a4
--- /dev/null
+++ b/chapter_heap/CMakeLists.txt
@@ -0,0 +1,3 @@
+add_executable(heap heap.cpp)
+add_executable(my_heap my_heap.cpp)
+add_executable(top_k top_k.cpp)
diff --git a/chapter_heap/heap.cpp b/chapter_heap/heap.cpp
new file mode 100644
index 0000000..e50a451
--- /dev/null
+++ b/chapter_heap/heap.cpp
@@ -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;
+}
diff --git a/chapter_heap/my_heap.cpp b/chapter_heap/my_heap.cpp
new file mode 100644
index 0000000..9a3af17
--- /dev/null
+++ b/chapter_heap/my_heap.cpp
@@ -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;
+}
diff --git a/chapter_heap/top_k.cpp b/chapter_heap/top_k.cpp
new file mode 100644
index 0000000..5c37ca7
--- /dev/null
+++ b/chapter_heap/top_k.cpp
@@ -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 ��Ԫ�ؿ�ʼ�����ֶѵij���Ϊ 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;
+}
diff --git a/chapter_searching/CMakeLists.txt b/chapter_searching/CMakeLists.txt
new file mode 100644
index 0000000..60a223d
--- /dev/null
+++ b/chapter_searching/CMakeLists.txt
@@ -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)
diff --git a/chapter_searching/binary_search.cpp b/chapter_searching/binary_search.cpp
new file mode 100644
index 0000000..e7056d3
--- /dev/null
+++ b/chapter_searching/binary_search.cpp
@@ -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;
+}
diff --git a/chapter_searching/binary_search_edge.cpp b/chapter_searching/binary_search_edge.cpp
new file mode 100644
index 0000000..7b9a30f
--- /dev/null
+++ b/chapter_searching/binary_search_edge.cpp
@@ -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 �IJ����
+    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;
+}
diff --git a/chapter_searching/binary_search_insertion.cpp b/chapter_searching/binary_search_insertion.cpp
new file mode 100644
index 0000000..384fd92
--- /dev/null
+++ b/chapter_searching/binary_search_insertion.cpp
@@ -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 << " �IJ���������Ϊ " << 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 << " �IJ���������Ϊ " << index << endl;
+    }
+
+    return 0;
+}
diff --git a/chapter_searching/hashing_search.cpp b/chapter_searching/hashing_search.cpp
new file mode 100644
index 0000000..31a895d
--- /dev/null
+++ b/chapter_searching/hashing_search.cpp
@@ -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;
+}
diff --git a/chapter_searching/linear_search.cpp b/chapter_searching/linear_search.cpp
new file mode 100644
index 0000000..c88af6f
--- /dev/null
+++ b/chapter_searching/linear_search.cpp
@@ -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;
+}
diff --git a/chapter_searching/two_sum.cpp b/chapter_searching/two_sum.cpp
new file mode 100644
index 0000000..5ff81d0
--- /dev/null
+++ b/chapter_searching/two_sum.cpp
@@ -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;
+}
diff --git a/chapter_sorting/CMakeLists.txt b/chapter_sorting/CMakeLists.txt
new file mode 100644
index 0000000..e6347cf
--- /dev/null
+++ b/chapter_sorting/CMakeLists.txt
@@ -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)
\ No newline at end of file
diff --git a/chapter_sorting/bubble_sort.cpp b/chapter_sorting/bubble_sort.cpp
new file mode 100644
index 0000000..2ddf2a7
--- /dev/null
+++ b/chapter_sorting/bubble_sort.cpp
@@ -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;
+}
diff --git a/chapter_sorting/bucket_sort.cpp b/chapter_sorting/bucket_sort.cpp
new file mode 100644
index 0000000..c5ffd5e
--- /dev/null
+++ b/chapter_sorting/bucket_sort.cpp
@@ -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;
+}
diff --git a/chapter_sorting/counting_sort.cpp b/chapter_sorting/counting_sort.cpp
new file mode 100644
index 0000000..bbc5948
--- /dev/null
+++ b/chapter_sorting/counting_sort.cpp
@@ -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. ͳ�Ƹ����ֵij��ִ���
+    // counter[num] ���� num �ij��ִ���
+    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. ͳ�Ƹ����ֵij��ִ���
+    // counter[num] ���� num �ij��ִ���
+    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;
+}
diff --git a/chapter_sorting/heap_sort.cpp b/chapter_sorting/heap_sort.cpp
new file mode 100644
index 0000000..a724f47
--- /dev/null
+++ b/chapter_sorting/heap_sort.cpp
@@ -0,0 +1,54 @@
+/**
+ * File: heap_sort.cpp
+ * Created Time: 2023-05-26
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* �ѵij���Ϊ 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;
+}
diff --git a/chapter_sorting/insertion_sort.cpp b/chapter_sorting/insertion_sort.cpp
new file mode 100644
index 0000000..d602ee4
--- /dev/null
+++ b/chapter_sorting/insertion_sort.cpp
@@ -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) {
+    // ��ѭ����������Ԫ������Ϊ 1, 2, ..., n
+    for (int i = 1; i < nums.size(); i++) {
+        int base = nums[i], j = i - 1;
+        // ��ѭ������ base ���뵽�����򲿷ֵ���ȷλ��
+        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;
+}
diff --git a/chapter_sorting/merge_sort.cpp b/chapter_sorting/merge_sort.cpp
new file mode 100644
index 0000000..56e71c2
--- /dev/null
+++ b/chapter_sorting/merge_sort.cpp
@@ -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;
+}
diff --git a/chapter_sorting/quick_sort.cpp b/chapter_sorting/quick_sort.cpp
new file mode 100644
index 0000000..4e3d390
--- /dev/null
+++ b/chapter_sorting/quick_sort.cpp
@@ -0,0 +1,168 @@
+/**
+ * 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) {
+        // �˴�ʹ������������򻯴���
+        // ������Ϊ 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1
+        if ((nums[left] < nums[mid]) ^ (nums[left] < nums[right]))
+            return left;
+        else if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right]))
+            return mid;
+        else
+            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(nums);
+
+    /* ��������β�ݹ��Ż��� */
+    vector<int> nums2 = {2, 4, 1, 0, 3, 5};
+    QuickSortTailCall::quickSort(nums2, 0, nums2.size() - 1);
+    cout << "��������β�ݹ��Ż�����ɺ� nums = ";
+    printVector(nums);
+
+    return 0;
+}
diff --git a/chapter_sorting/radix_sort.cpp b/chapter_sorting/radix_sort.cpp
new file mode 100644
index 0000000..c4d8cf4
--- /dev/null
+++ b/chapter_sorting/radix_sort.cpp
@@ -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 �����ֵij��ִ���
+    for (int i = 0; i < n; i++) {
+        int d = digit(nums[i], exp); // ��ȡ nums[i] �� k λ����Ϊ d
+        counter[d]++;                // ͳ������ d �ij��ִ���
+    }
+    // ��ǰ׺�ͣ��������ָ�����ת��Ϊ������������
+    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;
+}
diff --git a/chapter_sorting/selection_sort.cpp b/chapter_sorting/selection_sort.cpp
new file mode 100644
index 0000000..25899e7
--- /dev/null
+++ b/chapter_sorting/selection_sort.cpp
@@ -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;
+}
diff --git a/chapter_stack_and_queue/CMakeLists.txt b/chapter_stack_and_queue/CMakeLists.txt
new file mode 100644
index 0000000..b55878a
--- /dev/null
+++ b/chapter_stack_and_queue/CMakeLists.txt
@@ -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)
diff --git a/chapter_stack_and_queue/array_deque.cpp b/chapter_stack_and_queue/array_deque.cpp
new file mode 100644
index 0000000..8c83296
--- /dev/null
+++ b/chapter_stack_and_queue/array_deque.cpp
@@ -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();
+    }
+
+    /* ��ȡ˫����еij��� */
+    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());
+
+    /* ��ȡ˫����еij��� */
+    int size = deque->size();
+    cout << "˫����г��� size = " << size << endl;
+
+    /* �ж�˫������Ƿ�Ϊ�� */
+    bool isEmpty = deque->isEmpty();
+    cout << "˫������Ƿ�Ϊ�� = " << boolalpha << isEmpty << endl;
+    return 0;
+}
diff --git a/chapter_stack_and_queue/array_queue.cpp b/chapter_stack_and_queue/array_queue.cpp
new file mode 100644
index 0000000..282d42a
--- /dev/null
+++ b/chapter_stack_and_queue/array_queue.cpp
@@ -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;
+    }
+
+    /* ��ȡ���еij��� */
+    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());
+
+    /* ��ȡ���еij��� */
+    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;
+}
diff --git a/chapter_stack_and_queue/array_stack.cpp b/chapter_stack_and_queue/array_stack.cpp
new file mode 100644
index 0000000..b68b2f5
--- /dev/null
+++ b/chapter_stack_and_queue/array_stack.cpp
@@ -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:
+    /* ��ȡջ�ij��� */
+    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());
+
+    /* ��ȡջ�ij��� */
+    int size = stack->size();
+    cout << "ջ�ij��� size = " << size << endl;
+
+    /* �ж��Ƿ�Ϊ�� */
+    bool empty = stack->isEmpty();
+    cout << "ջ�Ƿ�Ϊ�� = " << empty << endl;
+
+    // �ͷ��ڴ�
+    delete stack;
+
+    return 0;
+}
diff --git a/chapter_stack_and_queue/deque.cpp b/chapter_stack_and_queue/deque.cpp
new file mode 100644
index 0000000..73da7b3
--- /dev/null
+++ b/chapter_stack_and_queue/deque.cpp
@@ -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);
+
+    /* ��ȡ˫����еij��� */
+    int size = deque.size();
+    cout << "˫����г��� size = " << size << endl;
+
+    /* �ж�˫������Ƿ�Ϊ�� */
+    bool empty = deque.empty();
+    cout << "˫������Ƿ�Ϊ�� = " << empty << endl;
+
+    return 0;
+}
diff --git a/chapter_stack_and_queue/linkedlist_deque.cpp b/chapter_stack_and_queue/linkedlist_deque.cpp
new file mode 100644
index 0000000..1fb67ee
--- /dev/null
+++ b/chapter_stack_and_queue/linkedlist_deque.cpp
@@ -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;              // ˫����еij���
+
+  public:
+    /* ���췽�� */
+    LinkedListDeque() : front(nullptr), rear(nullptr) {
+    }
+
+    /* �������� */
+    ~LinkedListDeque() {
+        // ��������ɾ���ڵ㣬�ͷ��ڴ�
+        DoublyListNode *pre, *cur = front;
+        while (cur != nullptr) {
+            pre = cur;
+            cur = cur->next;
+            delete pre;
+        }
+    }
+
+    /* ��ȡ˫����еij��� */
+    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());
+
+    /* ��ȡ˫����еij��� */
+    int size = deque->size();
+    cout << "˫����г��� size = " << size << endl;
+
+    /* �ж�˫������Ƿ�Ϊ�� */
+    bool isEmpty = deque->isEmpty();
+    cout << "˫������Ƿ�Ϊ�� = " << boolalpha << isEmpty << endl;
+
+    // �ͷ��ڴ�
+    delete deque;
+
+    return 0;
+}
diff --git a/chapter_stack_and_queue/linkedlist_queue.cpp b/chapter_stack_and_queue/linkedlist_queue.cpp
new file mode 100644
index 0000000..9a7985e
--- /dev/null
+++ b/chapter_stack_and_queue/linkedlist_queue.cpp
@@ -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);
+    }
+
+    /* ��ȡ���еij��� */
+    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());
+
+    /* ��ȡ���еij��� */
+    int size = queue->size();
+    cout << "����� size = " << size << endl;
+
+    /* �ж϶����Ƿ�Ϊ�� */
+    bool empty = queue->isEmpty();
+    cout << "�����Ƿ�Ϊ�� = " << empty << endl;
+
+    // �ͷ��ڴ�
+    delete queue;
+
+    return 0;
+}
diff --git a/chapter_stack_and_queue/linkedlist_stack.cpp b/chapter_stack_and_queue/linkedlist_stack.cpp
new file mode 100644
index 0000000..043f227
--- /dev/null
+++ b/chapter_stack_and_queue/linkedlist_stack.cpp
@@ -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;        // ջ�ij���
+
+  public:
+    LinkedListStack() {
+        stackTop = nullptr;
+        stkSize = 0;
+    }
+
+    ~LinkedListStack() {
+        // ��������ɾ���ڵ㣬�ͷ��ڴ�
+        freeMemoryLinkedList(stackTop);
+    }
+
+    /* ��ȡջ�ij��� */
+    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());
+
+    /* ��ȡջ�ij��� */
+    int size = stack->size();
+    cout << "ջ�ij��� size = " << size << endl;
+
+    /* �ж��Ƿ�Ϊ�� */
+    bool empty = stack->isEmpty();
+    cout << "ջ�Ƿ�Ϊ�� = " << empty << endl;
+
+    // �ͷ��ڴ�
+    delete stack;
+
+    return 0;
+}
diff --git a/chapter_stack_and_queue/queue.cpp b/chapter_stack_and_queue/queue.cpp
new file mode 100644
index 0000000..c8a5bb3
--- /dev/null
+++ b/chapter_stack_and_queue/queue.cpp
@@ -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);
+
+    /* ��ȡ���еij��� */
+    int size = queue.size();
+    cout << "����� size = " << size << endl;
+
+    /* �ж϶����Ƿ�Ϊ�� */
+    bool empty = queue.empty();
+    cout << "�����Ƿ�Ϊ�� = " << empty << endl;
+
+    return 0;
+}
diff --git a/chapter_stack_and_queue/stack.cpp b/chapter_stack_and_queue/stack.cpp
new file mode 100644
index 0000000..55ec887
--- /dev/null
+++ b/chapter_stack_and_queue/stack.cpp
@@ -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);
+
+    /* ��ȡջ�ij��� */
+    int size = stack.size();
+    cout << "ջ�ij��� size = " << size << endl;
+
+    /* �ж��Ƿ�Ϊ�� */
+    bool empty = stack.empty();
+    cout << "ջ�Ƿ�Ϊ�� = " << empty << endl;
+
+    return 0;
+}
diff --git a/chapter_tree/CMakeLists.txt b/chapter_tree/CMakeLists.txt
new file mode 100644
index 0000000..fa7009b
--- /dev/null
+++ b/chapter_tree/CMakeLists.txt
@@ -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)
\ No newline at end of file
diff --git a/chapter_tree/array_binary_tree.cpp b/chapter_tree/array_binary_tree.cpp
new file mode 100644
index 0000000..bf26c9d
--- /dev/null
+++ b/chapter_tree/array_binary_tree.cpp
@@ -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;
+}
diff --git a/chapter_tree/avl_tree.cpp b/chapter_tree/avl_tree.cpp
new file mode 100644
index 0000000..85e62d5
--- /dev/null
+++ b/chapter_tree/avl_tree.cpp
@@ -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;
+}
diff --git a/chapter_tree/binary_search_tree.cpp b/chapter_tree/binary_search_tree.cpp
new file mode 100644
index 0000000..33347c4
--- /dev/null
+++ b/chapter_tree/binary_search_tree.cpp
@@ -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();
+    // ��ע�⣬��ͬ�IJ���˳������ɲ�ͬ�Ķ������������п�������һ������������
+    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;
+}
diff --git a/chapter_tree/binary_tree.cpp b/chapter_tree/binary_tree.cpp
new file mode 100644
index 0000000..9104e4d
--- /dev/null
+++ b/chapter_tree/binary_tree.cpp
@@ -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;
+}
diff --git a/chapter_tree/binary_tree_bfs.cpp b/chapter_tree/binary_tree_bfs.cpp
new file mode 100644
index 0000000..8cb1b45
--- /dev/null
+++ b/chapter_tree/binary_tree_bfs.cpp
@@ -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;
+}
diff --git a/chapter_tree/binary_tree_dfs.cpp b/chapter_tree/binary_tree_dfs.cpp
new file mode 100644
index 0000000..534c668
--- /dev/null
+++ b/chapter_tree/binary_tree_dfs.cpp
@@ -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;
+}
diff --git a/test/priority_queue_demo.cpp b/test/priority_queue_demo.cpp
new file mode 100644
index 0000000..cf7ebe6
--- /dev/null
+++ b/test/priority_queue_demo.cpp
@@ -0,0 +1,28 @@
+#include <queue>
+#include <iostream>
+
+struct Person {
+    std::string name;
+    int age;
+};
+
+struct CompareByAge {
+    bool operator()(const Person& p1, const Person& p2) const {
+        return p1.age < p2.age;
+    }
+};
+
+int main() {
+    std::priority_queue<Person, std::vector<Person>, CompareByAge> pq;
+
+    pq.push({"Alice", 25});
+    pq.push({"Bob", 30});
+    pq.push({"Charlie", 20});
+
+    while (!pq.empty()) {
+        std::cout << pq.top().name << " ";
+        pq.pop();
+    }
+
+    return 0;
+}
\ No newline at end of file
diff --git a/utils/CMakeLists.txt b/utils/CMakeLists.txt
new file mode 100644
index 0000000..775a558
--- /dev/null
+++ b/utils/CMakeLists.txt
@@ -0,0 +1,4 @@
+add_executable(utils
+        common.hpp print_utils.hpp
+        list_node.hpp tree_node.hpp
+        vertex.hpp)
\ No newline at end of file
diff --git a/utils/common.hpp b/utils/common.hpp
new file mode 100644
index 0000000..c72dabd
--- /dev/null
+++ b/utils/common.hpp
@@ -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;
diff --git a/utils/list_node.hpp b/utils/list_node.hpp
new file mode 100644
index 0000000..b68d49c
--- /dev/null
+++ b/utils/list_node.hpp
@@ -0,0 +1,59 @@
+/**
+ * File: list_node.hpp
+ * Created Time: 2021-12-19
+ * Author: krahets (krahets@163.com)
+ */
+
+#pragma once
+
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+/* Definition for a singly-linked list node */
+struct ListNode
+{
+    int val;        // �����ǽڵ��ֵ
+    ListNode *next; // ������ָ����һ���ڵ��ָ��
+    ListNode(int x) : val(x), next(nullptr)
+    { // ���캯��: ��ʼ���ڵ��ֵΪx, ָ����һ���ڵ��ָ��Ϊ��
+    }
+};
+
+/* Generate a linked list with a vector */ // ��һ��vector����һ������
+ListNode *vecToLinkedList(vector<int> list)
+{
+    ListNode *dum = new ListNode(0); // ����һ������ڵ� dum (ֵΪ0)
+    ListNode *head = dum;            // ����һ��ָ������ڵ��ָ�� head
+    for (int val : list)
+    {
+        head->next = new ListNode(val); // ����һ���½ڵ�, ֵΪval, ������ָ�븳��head->next
+        head = head->next;              // headָ����һ���ڵ�
+    }
+    return dum->next; // ����������ͷ�ڵ�
+}
+
+/* Get a list node with specific value from a linked list */
+ListNode *getListNode(ListNode *head, int val)
+{
+    // ��������, �ҵ�ֵΪval�Ľڵ�
+    while (head != nullptr && head->val != val)
+    {
+        head = head->next; // ָ����һ���ڵ�
+    }
+    return head; // �����ҵ��Ľڵ�, ���û���ҵ�, ����nullptr
+}
+
+/* Free the memory allocated to a linked list */
+void freeMemoryLinkedList(ListNode *cur)
+{
+    // �ͷ��ڴ�
+    ListNode *pre;
+    while (cur != nullptr) // ��ǰ�ڵ㲻Ϊ��
+    {
+        pre = cur;       // preָ��ǰ�ڵ�
+        cur = cur->next; // ��ǰ�ڵ�ָ����һ���ڵ�
+        delete pre;      // �ͷ�preָ��Ľڵ�
+    }
+}
diff --git a/utils/print_utils.hpp b/utils/print_utils.hpp
new file mode 100644
index 0000000..6686644
--- /dev/null
+++ b/utils/print_utils.hpp
@@ -0,0 +1,289 @@
+/**
+ * File: print_utils.hpp
+ * Created Time: 2021-12-19
+ * Author: krahets (krahets@163.com), msk397 (machangxinq@gmail.com), LoneRanger(836253168@qq.com)
+ */
+
+#pragma once
+
+#include "list_node.hpp"
+#include "tree_node.hpp"
+#include <climits>
+#include <iostream>
+#include <sstream>
+#include <string>
+
+/* Find an element in a vector */ // ��һ�� vector �в���Ԫ��
+template <typename T>
+int vecFind(const vector<T> &vec, T ele)
+{
+    int j = INT_MAX;
+    for (int i = 0; i < vec.size(); i++)
+    {
+        if (vec[i] == ele) // ���ҵ�Ԫ��ʱ������Ԫ�ص��±�
+        {
+            j = i;
+        }
+    }
+    return j;
+}
+
+/* Concatenate a vector with a delim */ // ��һ�� vector ��ָ���ķָ������ӳ��ַ���
+template <typename T>
+string strJoin(const string &delim, const T &vec) // delim �Ƿָ�����vec �� vector(ʹ��&vec��ʾ���ݵ�������, �����ǿ���, �����Ч��)
+{
+    ostringstream s; // ����һ�����������
+    for (const auto &i : vec)
+    {
+        if (&i != &vec[0])
+        {
+            s << delim; // ���ָ������ӵ������������
+        }
+        s << i; // ��Ԫ�����ӵ������������
+    }
+    return s.str(); // .str() ���������������ij�Ա���������ڷ��������������ַ�����ʾ
+}
+
+/* Repeat a string for n times */ // ��һ���ַ����ظ� n ��
+string strRepeat(string str, int n)
+{
+    ostringstream os; // ����һ�����������
+    for (int i = 0; i < n; i++)
+        os << str;   // ���ַ����ظ� n ��
+    return os.str(); // ���������������ַ�����ʾ
+}
+
+/* Print an Array */ // ��ӡһ������
+template <typename T>
+void printArray(T *arr, int n) // arr ��������׵�ַ��n ������ij���
+{
+    cout << "[";
+    for (int i = 0; i < n - 1; i++)
+    {
+        cout << arr[i] << ", "; // �����ӡ����Ԫ��
+    }
+    if (n >= 1)                            // �����鳤�ȴ��ڵ��� 1 ʱ
+        cout << arr[n - 1] << "]" << endl; // ��ӡ�������һ��Ԫ�� �� ����һ�� ']' ����
+    else
+        cout << "]" << endl; // �����鳤��Ϊ 0 ʱ��ֱ�Ӵ�ӡһ�� ']' ����
+}
+
+/* Get the Vector String object */ // ��ȡһ�� vector ���ַ�����ʾ
+template <typename T>
+string getVectorString(vector<T> &list) // list �� vector
+{
+    return "[" + strJoin(", ", list) + "]"; // ʹ�� strJoin ������ vector �ö������ӳ��ַ����������ַ����������� '[' �� ']'
+}
+
+/* Print a vector */ // ��ӡһ�� vector
+template <typename T>
+void printVector(vector<T> list)
+{
+    cout << getVectorString(list) << '\n'; // ʹ�� getVectorString ������ȡ vector ���ַ�����ʾ������ӡ
+}
+
+/* Print a vector matrix */ // ��ӡһ�� vector ����
+template <typename T>
+void printVectorMatrix(vector<vector<T>> &matrix) // matrix ��һ����ά vector, ����ÿ��Ԫ�ض���һ�� vector, ���ڱ�ʾ���� (���������)
+{
+    cout << "[" << '\n';
+    for (vector<T> &list : matrix)                          // ���� matrix �е�ÿһ�� vector Ԫ��
+        cout << "  " + getVectorString(list) + "," << '\n'; // ʹ�� getVectorString ������ȡ vector ���ַ�����ʾ������ӡ
+    cout << "]" << '\n';
+}
+
+/* Print a linked list */ // ��ӡһ������
+void printLinkedList(ListNode *head)
+{
+    vector<int> list;       // ����һ�� vector ���ڴ洢������Ԫ��
+    while (head != nullptr) // ��������: ��������ָ�벻Ϊ��ʱ, ��������
+    {
+        list.push_back(head->val); // ��������Ԫ�����ӵ� vector ��
+        head = head->next;         // ��ָ��ָ����������һ��Ԫ��
+    }
+
+    cout << strJoin(" -> ", list) << '\n'; // ʹ�� strJoin ������ vector �ü�ͷ���ӳ��ַ���������ӡ
+}
+
+/**
+ * This tree printer is borrowed from TECHIE DELIGHT    // ������ӡ���Ǵ� TECHIE DELIGHT ���õ�
+ * https://www.techiedelight.com/c-program-print-binary-tree/
+ */
+struct Trunk // ���ɽṹ��
+{
+    Trunk *prev;                   // ָ����һ������
+    string str;                    // ���ɵ��ַ�����ʾ
+    Trunk(Trunk *prev, string str) // ���캯�� ��cpp �е� struct Ҳ�����й��캯����
+    {
+        this->prev = prev;
+        this->str = str;
+    }
+};
+
+/* Helper function to print branches of the binary tree */ // ���ڴ�ӡ�������ĸ�������
+void showTrunks(Trunk *p)
+{
+    if (p == nullptr) // ������Ϊ��ʱ��ֱ�ӷ���
+    {
+        return;
+    }
+
+    // �ݹ���õ�˳�����ӡ��˳���෴
+    showTrunks(p->prev); // �ݹ���� showTrunks ����
+    cout << p->str;      // ��ӡ���ɵ��ַ�����ʾ
+}
+
+/* Print a binary tree */ // ��ӡһ��������
+void printTree(TreeNode *root, Trunk *prev, bool isRight)
+{
+    if (root == nullptr)
+    {
+        return;
+    }
+
+    string prev_str = "    ";    // ��ʼ�� prev_str Ϊ�ո�
+    Trunk trunk(prev, prev_str); // ����һ�����ɶ���
+
+    printTree(root->right, &trunk, true); // �ݹ���� printTree ��������ӡ������
+
+    if (!prev) // ������Ϊ��ʱ
+    {
+        trunk.str = "������"; // ���ɵ��ַ�����ʾΪ "������"
+    }
+    else if (isRight) // �����ɲ�Ϊ������������ʱ
+    {
+        trunk.str = "/������"; // ���ɵ��ַ�����ʾΪ "/������"
+        prev_str = "   |";  // prev_str Ϊ "   |"
+    }
+    else // �����ɲ�Ϊ���Ҳ���������ʱ
+    {
+        trunk.str = "\\������";  // ���ɵ��ַ�����ʾΪ "\������"
+        prev->str = prev_str; // prev_str Ϊ prev->str
+    }
+
+    showTrunks(&trunk);               // ���� showTrunks ��������ӡ����
+    cout << " " << root->val << endl; // ��ӡ�ڵ��ֵ
+
+    if (prev) // �����ɲ�Ϊ��ʱ
+    {
+        prev->str = prev_str; // prev->str Ϊ prev_str
+    }
+    trunk.str = "   |"; // ���ɵ��ַ�����ʾΪ "   |"
+
+    printTree(root->left, &trunk, false); // �ݹ���� printTree ��������ӡ������
+}
+
+/* The interface of the tree printer */ // ��������ӡ���Ľӿ� (��������: Ŀ����Ϊ�˷������)
+void printTree(TreeNode *root)
+{
+    printTree(root, nullptr, false); // ���� printTree ���� (���ذ汾)
+}
+
+/* Print a stack */ // ��ӡһ��ջ
+template <typename T>
+void printStack(stack<T> stk)
+{
+    // Reverse the input stack  // ��ת�����ջ
+    stack<T> tmp;        // ����һ����ʱջ
+    while (!stk.empty()) // �������ջ��Ϊ��ʱ (���������ջ)
+    {
+        tmp.push(stk.top()); // �������ջ��Ԫ��������ӵ���ʱջ��
+        stk.pop();           // ���������ջ��Ԫ��
+    }
+
+    // Generate the string to print // ����Ҫ��ӡ���ַ���
+    ostringstream s;  // ����һ�����������
+    bool flag = true; // ����һ����־λ (Ĭ��Ϊ true), ��������Ƿ��ǵ�һ��Ԫ��
+    while (!tmp.empty())
+    {
+        if (flag)
+        {
+            s << tmp.top(); // ����־λΪ true ʱ����ջ��Ԫ�����ӵ������������
+            flag = false;   // ����־λ����Ϊ false
+        }
+        else                        // ����־λΪ false ʱ
+            s << ", " << tmp.top(); // ��ջ��Ԫ�����ӵ������������
+        tmp.pop();                  // ����ջ��Ԫ��
+    }
+    cout << "[" + s.str() + "]" << '\n'; // ʹ�������������ַ�����ʾ������ӡ
+}
+
+/* Print a queue */ // ��ӡһ������
+template <typename T>
+void printQueue(queue<T> queue) // queue �Ƕ���
+{
+    // Generate the string to print // ����Ҫ��ӡ���ַ���
+    ostringstream s;
+    bool flag = true;
+    while (!queue.empty())
+    {
+        if (flag)
+        {
+            s << queue.front(); // ����־λΪ true ʱ�������еĶ���Ԫ�����ӵ������������ (true ��ʾ�ǵ�һ��Ԫ��)
+            flag = false;
+        }
+        else
+            s << ", " << queue.front(); // ����־λΪ false ʱ�������еĶ���Ԫ��ǰ������һ�����ţ������ӵ������������
+        queue.pop();                    // ��������Ԫ��
+    }
+    cout << "[" + s.str() + "]" << '\n'; // ʹ�������������ַ�����ʾ������ӡ
+}
+
+/* Print a deque */ // ��ӡһ��˫�˶���
+template <typename T>
+void printDeque(deque<T> deque) // deque ��˫�˶���(���� deck)
+{
+    // Generate the string to print // ����Ҫ��ӡ���ַ���
+    ostringstream s;
+    bool flag = true;
+    while (!deque.empty()) // ��˫�˶��в�Ϊ��ʱ
+    {
+        if (flag)
+        {
+            s << deque.front();
+            flag = false;
+        }
+        else
+            s << ", " << deque.front();
+        deque.pop_front(); // ��������Ԫ��
+    }
+    cout << "[" + s.str() + "]" << '\n';
+}
+
+/* Print a HashMap */ // ��ӡһ����ϣ��
+// ����ģ����� TKey �� TValue ������ָ����ֵ�Ե�����
+template <typename TKey, typename TValue>
+void printHashMap(unordered_map<TKey, TValue> map) // map �ǹ�ϣ��
+{
+    for (auto kv : map) // auto �ؼ��������Զ��Ƶ�����������
+    {
+        cout << kv.first << " -> " << kv.second << '\n'; // .first ��ʾ����.second ��ʾֵ
+    }
+}
+
+/* Expose the underlying storage of the priority_queue container */ // ��¶���ȶ��������ĵײ�洢
+template <typename T, typename S, typename C>
+S &Container(priority_queue<T, S, C> &pq) // pq �����ȶ���
+{
+    struct HackedQueue : private priority_queue<T, S, C> // ����һ��˽�м̳е����ȶ���
+    {
+        static S &Container(priority_queue<T, S, C> &pq) // ����һ����̬��Ա���� Container
+        {
+            return pq.*&HackedQueue::c; // �������ȶ��еĵײ�洢
+        }
+    };
+    return HackedQueue::Container(pq); // ���þ�̬��Ա���� Container
+}
+
+/* Print a Heap (PriorityQueue) */ // ��ӡһ���ѣ����ȶ��У�
+template <typename T, typename S, typename C>
+void printHeap(priority_queue<T, S, C> &heap) // heap �����ȶ���
+{
+    vector<T> vec = Container(heap); // ��ȡ���ȶ��еĵײ�洢
+    cout << "�ѵ������ʾ��";
+    printVector(vec);
+    cout << "�ѵ���״��ʾ��" << endl;
+    TreeNode *root = vectorToTree(vec); // �½�һ�������� root�������ȶ��еĵײ�洢ת��Ϊ������
+    printTree(root);
+    freeMemoryTree(root);
+}
diff --git a/utils/tree_node.hpp b/utils/tree_node.hpp
new file mode 100644
index 0000000..de54044
--- /dev/null
+++ b/utils/tree_node.hpp
@@ -0,0 +1,120 @@
+/**
+ * File: tree_node.hpp
+ * Created Time: 2021-12-19
+ * Author: krahets (krahets@163.com)
+ */
+
+#pragma once
+
+#include <limits.h>
+#include <vector>
+
+using namespace std;
+
+/* �������ڵ�ṹ�� */
+struct TreeNode
+{
+    int val{};            // �ڵ��ֵ val {} ��ʾ��ʼ��Ϊ 0 �� nullptr ({} �� C++11 ��������: ֵ��ʼ��)
+    int height = 0;       // �ڵ�ĸ߶�
+    TreeNode *parent{};   // ���ڵ� {} ��ʾ��ʼ��Ϊ nullptr
+    TreeNode *left{};     // ���� {} ��ʾ��ʼ��Ϊ nullptr
+    TreeNode *right{};    // �Һ��� {} ��ʾ��ʼ��Ϊ nullptr
+    TreeNode() = default; // Ĭ�Ϲ��캯��
+    explicit TreeNode(int x, TreeNode *parent = nullptr) : val(x), parent(parent)
+    {
+    } // ���캯��: ��ʼ���ڵ��ֵΪx, ���ڵ�Ϊparent
+};
+
+// ���л����������ο���
+// https://www.hello-algo.com/chapter_tree/array_representation_of_tree/
+// �������������ʾ��
+// [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]
+// ��������������ʾ��
+//             /������ 15
+//         /������ 7
+//     /������ 3
+//    |    \������ 6
+//    |        \������ 12
+// ������ 1
+//     \������ 2
+//        |    /������ 9
+//         \������ 4
+//             \������ 8
+
+/* ���б������л�Ϊ���������ݹ� */
+/*
+    vectorToTreeDFS ��һ���ݹ麯�������ڽ�һ���������͵����� arr ת��Ϊһ�ö����������������ĸ��ڵ㡣
+    �����IJ������� arr �� i��arr ��һ���洢����ֵ��������i �ǵ�ǰ�ڵ��������е�������
+    �������ȼ�鵱ǰ���� i �Ƿ�Խ����߶�Ӧ��ֵ�Ƿ�Ϊ INT_MAX������ǵĻ�����ʾ��ǰ�ڵ�Ϊ�սڵ㣬�������� nullptr��
+    �����ǰ�ڵ㲻Ϊ�գ������ᴴ��һ���µ� TreeNode ���󣬲��� arr[i] ��ֵ�����ڵ�� val ��Ա������
+    Ȼ�󣬺�����ݹ���� vectorToTreeDFS ������������ǰ�ڵ������������������������������Ϊ 2 * i + 1��������������Ϊ 2 * i + 2���ݹ���õ�Ŀ���ǽ� arr �е�Ԫ�����ת��Ϊ���Ľڵ㣬�������ڵ�֮��ĸ��ӹ�ϵ��
+    ��󣬺������ظ��ڵ㣬���������������������ת�����̡�
+    �������ʹ���������������DFS���ķ�ʽ��������������ͨ���ݹ�����������������δ���ÿ���ڵ㣬�������������Ķ������ṹ��
+*/
+TreeNode *vectorToTreeDFS(vector<int> &arr, int i)
+{
+    if (i < 0 || i >= arr.size() || arr[i] == INT_MAX)
+    {
+        return nullptr;
+    }
+    TreeNode *root = new TreeNode(arr[i]);
+    root->left = vectorToTreeDFS(arr, 2 * i + 1);  // �ݹ鹹��������
+    root->right = vectorToTreeDFS(arr, 2 * i + 2); // �ݹ鹹��������
+    return root;                                   // ���ظ��ڵ�
+}
+
+/* ���б������л�Ϊ������ */
+TreeNode *vectorToTree(vector<int> arr)
+{
+    return vectorToTreeDFS(arr, 0);
+}
+
+/* �����������л�Ϊ�б����ݹ� */
+/*
+treeToVecorDFS ��һ���ݹ麯�������ڽ��������Ľڵ�ֵ�����������������DFS����˳��洢��һ�������С�
+
+�����IJ���������
+
+root��ָ��ǰ�ڵ��ָ�룬��ʾ��ǰ�ݹ�Ľڵ㡣
+i����ʾ��ǰ�ڵ��������е�����λ�á�
+res���洢�ڵ�ֵ�����������á�
+������ʵ���߼����£�
+
+���ȣ���鵱ǰ�ڵ��Ƿ�Ϊ�ա����Ϊ�գ���ʾ�Ѿ�������Ҷ�ӽڵ��սڵ㣬ֱ�ӷ��ء�
+Ȼ��ͨ��һ��ѭ���������� res ��չ���㹻�ij��ȣ��Ա��ܹ��洢��ǰ�ڵ��ֵ��ѭ�������� i ���ڵ������� res �Ĵ�С��
+������ res �У�������Ϊ i ��λ�õ�ֵ����Ϊ��ǰ�ڵ��ֵ��
+�ݹ���� treeToVecorDFS �������ֱ�����ǰ�ڵ�����ӽڵ�����ӽڵ㡣�������ӽڵ㣬����λ��Ϊ 2 * i + 1���������ӽڵ㣬����λ��Ϊ 2 * i + 2��
+��������������ǽ��������Ľڵ�ֵ�����������������˳��洢��һ�������У��������ں��������ݴ����������
+*/
+void treeToVecorDFS(TreeNode *root, int i, vector<int> &res)
+{
+    if (root == nullptr)
+        return;
+    while (i >= res.size())
+    {
+        res.push_back(INT_MAX); // ��ʼ��Ϊ INT_MAX
+    }
+    res[i] = root->val;
+    treeToVecorDFS(root->left, 2 * i + 1, res);
+    treeToVecorDFS(root->right, 2 * i + 2, res);
+}
+
+/* �����������л�Ϊ�б� */
+vector<int> treeToVecor(TreeNode *root)
+{
+    vector<int> res;
+    treeToVecorDFS(root, 0, res);
+    return res;
+}
+
+/* �ͷŶ������ڴ� */
+void freeMemoryTree(TreeNode *root)
+{
+    if (root == nullptr)
+        return;
+
+    // ��Ҫ���εݹ��ͷ������������ڴ棬���ͷŸ��ڵ���ڴ�
+    freeMemoryTree(root->left);
+    freeMemoryTree(root->right);
+    delete root;
+}
diff --git a/utils/vertex.hpp b/utils/vertex.hpp
new file mode 100644
index 0000000..d40316d
--- /dev/null
+++ b/utils/vertex.hpp
@@ -0,0 +1,42 @@
+/**
+ * File: vertex.hpp
+ * Created Time: 2023-03-02
+ * Author: krahets (krahets@163.com)
+ */
+
+#pragma once // ��ֹͷ�ļ����ظ�����
+
+#include <vector>
+
+using namespace std;
+
+/* ������ */
+struct Vertex
+{
+    int val;
+    Vertex(int x) : val(x)
+    {
+    }
+};
+
+/* ����ֵ�б� vals �����ض����б� vets */
+vector<Vertex *> valsToVets(vector<int> vals)
+{
+    vector<Vertex *> vets;
+    for (int val : vals)
+    {
+        vets.push_back(new Vertex(val));
+    }
+    return vets;
+}
+
+/* ���붥���б� vets ������ֵ�б� vals */
+vector<int> vetsToVals(vector<Vertex *> vets)
+{
+    vector<int> vals;
+    for (Vertex *vet : vets)
+    {
+        vals.push_back(vet->val);
+    }
+    return vals;
+}