algorithm/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2025-11-02 21:24:53 +08:00
Code Issues Packages Projects Releases Wiki Activity

feat: Revised the book (#978)

Browse Source 
* Sync recent changes to the revised Word.

* Revised the preface chapter

* Revised the introduction chapter

* Revised the computation complexity chapter

* Revised the chapter data structure

* Revised the chapter array and linked list

* Revised the chapter stack and queue

* Revised the chapter hashing

* Revised the chapter tree

* Revised the chapter heap

* Revised the chapter graph

* Revised the chapter searching

* Reivised the sorting chapter

* Revised the divide and conquer chapter

* Revised the chapter backtacking

* Revised the DP chapter

* Revised the greedy chapter

* Revised the appendix chapter

* Revised the preface chapter doubly

* Revised the figures
This commit is contained in:
Yudong Jin
2023-12-02 06:21:34 +08:00
committed by GitHub
parent b824d149cb
commit e720aa2d24
404 changed files with 1537 additions and 1558 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
codes/dart/chapter_array_and_linkedlist/array.dart
View File

@ -39,7 +39,7 @@ void insert(List<int> nums, int _num, int index) {
nums[index] = _num;
}
/* 删除索引 index 处元素 */
/* 删除索引 index 处的元素 */
void remove(List<int> nums, int index) {
// 把索引 index 之后的所有元素向前移动一位
for (var i = index; i < nums.length - 1; i++) {

2
codes/dart/chapter_array_and_linkedlist/linked_list.dart
View File

@ -54,7 +54,7 @@ void main() {
ListNode n2 = ListNode(2);
ListNode n3 = ListNode(5);
ListNode n4 = ListNode(4);
// 构建引用指向
// 构建节点之间的引用
n0.next = n1;
n1.next = n2;
n2.next = n3;

4
codes/dart/chapter_array_and_linkedlist/list.dart
View File

@ -24,7 +24,7 @@ void main() {
nums.clear();
print('清空列表后 nums = $nums');
/* 尾部添加元素 */
/* 在尾部添加元素 */
nums.add(1);
nums.add(3);
nums.add(2);
@ -32,7 +32,7 @@ void main() {
nums.add(4);
print('添加元素后 nums = $nums');
/* 中间插入元素 */
/* 在中间插入元素 */
nums.insert(3, 6);
print('在索引 3 处插入数字 6 ，得到 nums = $nums');

14
codes/dart/chapter_array_and_linkedlist/my_list.dart
View File

@ -4,11 +4,11 @@
* Author: Jefferson (JeffersonHuang77@gmail.com)
*/
/* 列表类简易实现 */
/* 列表类 */
class MyList {
late List<int> _arr; // 数组（存储列表元素）
int _capacity = 10; // 列表容量
int _size = 0; // 列表长度（即当前元素数量）
int _size = 0; // 列表长度（当前元素数量）
int _extendRatio = 2; // 每次列表扩容的倍数
/* 构造方法 */
@ -16,7 +16,7 @@ class MyList {
_arr = List.filled(_capacity, 0);
}
/* 获取列表长度（即当前元素数量）*/
/* 获取列表长度（当前元素数量）*/
int size() => _size;
/* 获取列表容量 */
@ -34,7 +34,7 @@ class MyList {
_arr[index] = _num;
}
/* 尾部添加元素 */
/* 在尾部添加元素 */
void add(int _num) {
// 元素数量超出容量时，触发扩容机制
if (_size == _capacity) extendCapacity();
@ -43,7 +43,7 @@ class MyList {
_size++;
}
/* 中间插入元素 */
/* 在中间插入元素 */
void insert(int index, int _num) {
if (index >= _size) throw RangeError('索引越界');
// 元素数量超出容量时，触发扩容机制
@ -97,7 +97,7 @@ class MyList {
void main() {
/* 初始化列表 */
MyList nums = MyList();
/* 尾部添加元素 */
/* 在尾部添加元素 */
nums.add(1);
nums.add(3);
nums.add(2);
@ -106,7 +106,7 @@ void main() {
print(
'列表 nums = ${nums.toArray()} ，容量 = ${nums.capacity()} ，长度 = ${nums.size()}');
/* 中间插入元素 */
/* 在中间插入元素 */
nums.insert(3, 6);
print('在索引 3 处插入数字 6 ，得到 nums = ${nums.toArray()}');

6
codes/dart/chapter_backtracking/n_queens.dart
View File

@ -28,7 +28,7 @@ void backtrack(
// 计算该格子对应的主对角线和副对角线
int diag1 = row - col + n - 1;
int diag2 = row + col;
// 剪枝：不允许该格子所在列、主对角线、副对角线存在皇后
// 剪枝：不允许该格子所在列、主对角线、副对角线上存在皇后
if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
// 尝试：将皇后放置在该格子
state[row][col] = "Q";
@ -51,8 +51,8 @@ List<List<List<String>>> nQueens(int n) {
// 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
List<List<String>> state = List.generate(n, (index) => List.filled(n, "#"));
List<bool> cols = List.filled(n, false); // 记录列是否有皇后
List<bool> diags1 = List.filled(2 * n - 1, false); // 记录主对角线是否有皇后
List<bool> diags2 = List.filled(2 * n - 1, false); // 记录副对角线是否有皇后
List<bool> diags1 = List.filled(2 * n - 1, false); // 记录主对角线上是否有皇后
List<bool> diags2 = List.filled(2 * n - 1, false); // 记录副对角线上是否有皇后
List<List<List<String>>> res = [];
backtrack(0, n, state, res, cols, diags1, diags2);

2
codes/dart/chapter_computational_complexity/iteration.dart
View File

@ -30,7 +30,7 @@ int whileLoop(int n) {
int whileLoopII(int n) {
int res = 0;
int i = 1; // 初始化条件变量
// 循环求和 1, 4, ...
// 循环求和 1, 4, 10, ...
while (i <= n) {
res += i;
// 更新条件变量

4
codes/dart/chapter_divide_and_conquer/hanota.dart
View File

@ -12,7 +12,7 @@ void move(List<int> src, List<int> tar) {
tar.add(pan);
}
/* 求解汉诺塔：问题 f(i) */
/* 求解汉诺塔问题 f(i) */
void dfs(int i, List<int> src, List<int> buf, List<int> tar) {
// 若 src 只剩下一个圆盘，则直接将其移到 tar
if (i == 1) {
@ -27,7 +27,7 @@ void dfs(int i, List<int> src, List<int> buf, List<int> tar) {
dfs(i - 1, buf, src, tar);
}
/* 求解汉诺塔 */
/* 求解汉诺塔问题 */
void solveHanota(List<int> A, List<int> B, List<int> C) {
int n = A.length;
// 将 A 顶部 n 个圆盘借助 B 移到 C

2
codes/dart/chapter_dynamic_programming/climbing_stairs_backtrack.dart
View File

@ -22,7 +22,7 @@ void backtrack(List<int> choices, int state, int n, List<int> res) {
/* 爬楼梯：回溯 */
int climbingStairsBacktrack(int n) {
List<int> choices = [1, 2]; // 可选择向上爬 1 或 2 阶
List<int> choices = [1, 2]; // 可选择向上爬 1 阶或 2 阶
int state = 0; // 从第 0 阶开始爬
List<int> res = [];
res.add(0); // 使用 res[0] 记录方案数量

2
codes/dart/chapter_dynamic_programming/coin_change.dart
View File

@ -16,7 +16,7 @@ int coinChangeDP(List<int> coins, int amt) {
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) {

2
codes/dart/chapter_dynamic_programming/edit_distance.dart
View File

@ -56,7 +56,7 @@ int editDistanceDP(String s, String t) {
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]) {

8
codes/dart/chapter_dynamic_programming/knapsack.dart
View File

@ -8,11 +8,11 @@ import 'dart:math';
/* 0-1 背包：暴力搜索 */
int knapsackDFS(List<int> wgt, List<int> val, int i, int c) {
// 若已选完所有物品或背包无容量，则返回价值 0
// 若已选完所有物品或背包无剩余容量，则返回价值 0
if (i == 0 || c == 0) {
return 0;
}
// 若超过背包容量，则只能不放入背包
// 若超过背包容量，则只能选择不放入背包
if (wgt[i - 1] > c) {
return knapsackDFS(wgt, val, i - 1, c);
}
@ -31,7 +31,7 @@ int knapsackDFSMem(
int i,
int c,
) {
// 若已选完所有物品或背包无容量，则返回价值 0
// 若已选完所有物品或背包无剩余容量，则返回价值 0
if (i == 0 || c == 0) {
return 0;
}
@ -39,7 +39,7 @@ int knapsackDFSMem(
if (mem[i][c] != -1) {
return mem[i][c];
}
// 若超过背包容量，则只能不放入背包
// 若超过背包容量，则只能选择不放入背包
if (wgt[i - 1] > c) {
return knapsackDFSMem(wgt, val, mem, i - 1, c);
}

2
codes/dart/chapter_dynamic_programming/min_path_sum.dart
View File

@ -61,7 +61,7 @@ int minPathSumDP(List<List<int>> grid) {
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];

2
codes/dart/chapter_graph/graph_adjacency_list.dart
View File

@ -8,7 +8,7 @@ import '../utils/vertex.dart';
/* 基于邻接表实现的无向图类 */
class GraphAdjList {
// 邻接表，key: 顶点，value：该顶点的所有邻接顶点
// 邻接表，key：顶点，value：该顶点的所有邻接顶点
Map<Vertex, List<Vertex>> adjList = {};
/* 构造方法 */

2
codes/dart/chapter_graph/graph_adjacency_matrix.dart
View File

@ -67,7 +67,7 @@ class GraphAdjMat {
if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {
throw IndexError;
}
// 在无向图中，邻接矩阵沿主对角线对称，即满足 (i, j) == (j, i)
// 在无向图中，邻接矩阵关于主对角线对称，即满足 (i, j) == (j, i)
adjMat[i][j] = 1;
adjMat[j][i] = 1;
}

2
codes/dart/chapter_graph/graph_bfs.dart
View File

@ -27,7 +27,7 @@ List<Vertex> graphBFS(GraphAdjList graph, Vertex startVet) {
// 遍历该顶点的所有邻接顶点
for (Vertex adjVet in graph.adjList[vet]!) {
if (visited.contains(adjVet)) {
continue; // 跳过已被访问过的顶点
continue; // 跳过已被访问的顶点
}
que.add(adjVet); // 只入队未访问的顶点
visited.add(adjVet); // 标记该顶点已被访问

2
codes/dart/chapter_graph/graph_dfs.dart
View File

@ -19,7 +19,7 @@ void dfs(
// 遍历该顶点的所有邻接顶点
for (Vertex adjVet in graph.adjList[vet]!) {
if (visited.contains(adjVet)) {
continue; // 跳过已被访问过的顶点
continue; // 跳过已被访问的顶点
}
// 递归访问邻接顶点
dfs(graph, visited, res, adjVet);

2
codes/dart/chapter_hashing/array_hash_map.dart
View File

@ -11,7 +11,7 @@ class Pair {
Pair(this.key, this.val);
}
/* 基于数组简易实现的哈希表 */
/* 基于数组实现的哈希表 */
class ArrayHashMap {
late List<Pair?> _buckets;

2
codes/dart/chapter_heap/my_heap.dart
View File

@ -85,7 +85,7 @@ class MaxHeap {
int pop() {
// 判空处理
if (isEmpty()) throw Exception('堆为空');
// 交换根节点与最右叶节点（即交换首元素与尾元素）
// 交换根节点与最右叶节点（交换首元素与尾元素）
_swap(0, size() - 1);
// 删除节点
int val = _maxHeap.removeLast();

2
codes/dart/chapter_heap/top_k.dart
View File

@ -115,7 +115,7 @@ class MinHeap {
int pop() {
// 判空处理
if (isEmpty()) throw Exception('堆为空');
// 交换根节点与最右叶节点（即交换首元素与尾元素）
// 交换根节点与最右叶节点（交换首元素与尾元素）
_swap(0, size() - 1);
// 删除节点
int val = _minHeap.removeLast();

2
codes/dart/chapter_searching/binary_search.dart
View File

@ -28,7 +28,7 @@ int binarySearch(List<int> nums, int target) {
/* 二分查找（左闭右开区间） */
int binarySearchLCRO(List<int> nums, int target) {
// 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
// 初始化左闭右开区间 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
int i = 0, j = nums.length;
// 循环，当搜索区间为空时跳出（当 i = j 时为空）
while (i < j) {

6
codes/dart/chapter_searching/two_sum.dart
View File

@ -9,7 +9,7 @@ import 'dart:collection';
/* 方法一： 暴力枚举 */
List<int> twoSumBruteForce(List<int> nums, int target) {
int size = nums.length;
// 两层循环，时间复杂度 O(n^2)
// 两层循环，时间复杂度为 O(n^2)
for (var i = 0; i < size - 1; i++) {
for (var j = i + 1; j < size; j++) {
if (nums[i] + nums[j] == target) return [i, j];
@ -21,9 +21,9 @@ List<int> twoSumBruteForce(List<int> nums, int target) {
/* 方法二： 辅助哈希表 */
List<int> twoSumHashTable(List<int> nums, int target) {
int size = nums.length;
// 辅助哈希表，空间复杂度 O(n)
// 辅助哈希表，空间复杂度为 O(n)
Map<int, int> dic = HashMap();
// 单层循环，时间复杂度 O(n)
// 单层循环，时间复杂度为 O(n)
for (var i = 0; i < size; i++) {
if (dic.containsKey(target - nums[i])) {
return [dic[target - nums[i]]!, i];

2
codes/dart/chapter_sorting/bucket_sort.dart
View File

@ -12,7 +12,7 @@ void bucketSort(List<double> nums) {
// 1. 将数组元素分配到各个桶中
for (double _num in nums) {
// 输入数据范围 [0, 1)，使用 _num * k 映射到索引范围 [0, k-1]
// 输入数据范围为 [0, 1)，使用 _num * k 映射到索引范围 [0, k-1]
int i = (_num * k).toInt();
// 将 _num 添加进桶 bucket_idx
buckets[i].add(_num);

2
codes/dart/chapter_sorting/heap_sort.dart
View File

@ -32,7 +32,7 @@ void heapSort(List<int> nums) {
}
// 从堆中提取最大元素，循环 n-1 轮
for (int i = nums.length - 1; i > 0; i--) {
// 交换根节点与最右叶节点（即交换首元素与尾元素）
// 交换根节点与最右叶节点（交换首元素与尾元素）
int tmp = nums[0];
nums[0] = nums[i];
nums[i] = tmp;

8
codes/dart/chapter_sorting/quick_sort.dart
View File

@ -15,7 +15,7 @@ class QuickSort {
/* 哨兵划分 */
static int _partition(List<int> nums, int left, int right) {
// 以 nums[left] 作为基准数
// 以 nums[left] 为基准数
int i = left, j = right;
while (i < j) {
while (i < j && nums[j] >= nums[left]) j--; // 从右向左找首个小于基准数的元素
@ -65,7 +65,7 @@ class QuickSortMedian {
int med = _medianThree(nums, left, (left + right) ~/ 2, right);
// 将中位数交换至数组最左端
_swap(nums, left, med);
// 以 nums[left] 作为基准数
// 以 nums[left] 为基准数
int i = left, j = right;
while (i < j) {
while (i < j && nums[j] >= nums[left]) j--; // 从右向左找首个小于基准数的元素
@ -99,7 +99,7 @@ class QuickSortTailCall {
/* 哨兵划分 */
static int _partition(List<int> nums, int left, int right) {
// 以 nums[left] 作为基准数
// 以 nums[left] 为基准数
int i = left, j = right;
while (i < j) {
while (i < j && nums[j] >= nums[left]) j--; // 从右向左找首个小于基准数的元素
@ -116,7 +116,7 @@ class QuickSortTailCall {
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]

2
codes/dart/chapter_sorting/radix_sort.dart
View File

@ -12,7 +12,7 @@ int digit(int _num, int exp) {
/* 计数排序（根据 nums 第 k 位排序） */
void countingSortDigit(List<int> nums, int exp) {
// 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
// 十进制的位范围为 0~9 ，因此需要长度为 10 的桶数组
List<int> counter = List<int>.filled(10, 0);
int n = nums.length;
// 统计 0~9 各数字的出现次数

2
codes/dart/chapter_tree/binary_tree.dart
View File

@ -15,7 +15,7 @@ void main() {
TreeNode n3 = TreeNode(3);
TreeNode n4 = TreeNode(4);
TreeNode n5 = TreeNode(5);
// 构建引用指向（即指针）
// 构建节点之间的引用（指针）
n1.left = n2;
n1.right = n3;
n2.left = n4;