learning
/
hello-algo
mirror of https://github.com/krahets/hello-algo.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

feat: Add Dart codes for chapter_backtracking and chapter_divide_and_conquer (#680) 

* feat: Add Dart codes for chapter_backtracking

* feat: Add Dart codes for chapter_divide_and_conquer

* Format Dart Code
This commit is contained in:
liuyuxin 2023-08-10 23:48:56 +08:00 committed by GitHub
parent e97eee0e18
commit 4325974af1
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
19 changed files with 731 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

75
codes/dart/chapter_backtracking/n_queens.dart Normal file
View File

@ -0,0 +1,75 @@
/**
* File: n_queens.dart
* Created Time: 2023-08-10
* Author: liuyuxin (gvenusleo@gmail.com)
*/
/* 回溯算法：N 皇后 */
void backtrack(
int row,
int n,
List<List<String>> state,
List<List<List<String>>> res,
List<bool> cols,
List<bool> diags1,
List<bool> diags2,
) {
// 当放置完所有行时，记录解
if (row == n) {
List<List<String>> copyState = [];
for (List<String> sRow in state) {
copyState.add(List.from(sRow));
}
res.add(copyState);
return;
}
// 遍历所有列
for (int col = 0; col < n; col++) {
// 计算该格子对应的主对角线和副对角线
int diag1 = row - col + n - 1;
int diag2 = row + col;
// 剪枝：不允许该格子所在列、主对角线、副对角线存在皇后
if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
// 尝试：将皇后放置在该格子
state[row][col] = "Q";
cols[col] = true;
diags1[diag1] = true;
diags2[diag2] = true;
// 放置下一行
backtrack(row + 1, n, state, res, cols, diags1, diags2);
// 回退：将该格子恢复为空位
state[row][col] = "#";
cols[col] = false;
diags1[diag1] = false;
diags2[diag2] = false;
}
}
}
/* 求解 N 皇后 */
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<List<List<String>>> res = [];
backtrack(0, n, state, res, cols, diags1, diags2);
return res;
}
/* Driver Code */
void main() {
int n = 4;
List<List<List<String>>> res = nQueens(n);
print("输入棋盘长宽为 $n");
print("皇后放置方案共有 ${res.length} 种");
for (List<List<String>> state in res) {
print("--------------------");
for (List<String> row in state) {
print(row);
}
}
}

51
codes/dart/chapter_backtracking/permutations_i.dart Normal file
View File

@ -0,0 +1,51 @@
/**
* File: permutations_i.dart
* Created Time: 2023-08-10
* Author: liuyuxin (gvenusleo@gmail.com)
*/
/* 回溯算法：全排列 I */
void backtrack(
List<int> state,
List<int> choices,
List<bool> selected,
List<List<int>> res,
) {
// 当状态长度等于元素数量时，记录解
if (state.length == choices.length) {
res.add(List.from(state));
return;
}
// 遍历所有选择
for (int i = 0; i < choices.length; i++) {
int choice = choices[i];
// 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
if (!selected[i]) {
// 尝试：做出选择，更新状态
selected[i] = true;
state.add(choice);
// 进行下一轮选择
backtrack(state, choices, selected, res);
// 回退：撤销选择，恢复到之前的状态
selected[i] = false;
state.removeLast();
}
}
}
/* 全排列 I */
List<List<int>> permutationsI(List<int> nums) {
List<List<int>> res = [];
backtrack([], nums, List.filled(nums.length, false), res);
return res;
}
/* Driver Code */
void main() {
List<int> nums = [1, 2, 3];
List<List<int>> res = permutationsI(nums);
print("输入数组 nums = $nums");
print("所有排列 res = $res");
}

53
codes/dart/chapter_backtracking/permutations_ii.dart Normal file
View File

@ -0,0 +1,53 @@
/**
* File: permutations_ii.dart
* Created Time: 2023-08-10
* Author: liuyuxin (gvenusleo@gmail.com)
*/
/* 回溯算法：全排列 II */
void backtrack(
List<int> state,
List<int> choices,
List<bool> selected,
List<List<int>> res,
) {
// 当状态长度等于元素数量时，记录解
if (state.length == choices.length) {
res.add(List.from(state));
return;
}
// 遍历所有选择
Set<int> duplicated = {};
for (int i = 0; i < choices.length; i++) {
int choice = choices[i];
// 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
if (!selected[i] && !duplicated.contains(choice)) {
// 尝试：做出选择，更新状态
duplicated.add(choice); // 记录选择过的元素值
selected[i] = true;
state.add(choice);
// 进行下一轮选择
backtrack(state, choices, selected, res);
// 回退：撤销选择，恢复到之前的状态
selected[i] = false;
state.removeLast();
}
}
}
/* 全排列 II */
List<List<int>> permutationsII(List<int> nums) {
List<List<int>> res = [];
backtrack([], nums, List.filled(nums.length, false), res);
return res;
}
/* Driver Code */
void main() {
List<int> nums = [1, 2, 2];
List<List<int>> res = permutationsII(nums);
print("输入数组 nums = $nums");
print("所有排列 res = $res");
}

35
codes/dart/chapter_backtracking/preorder_traversal_i_compact.dart Normal file
View File

@ -0,0 +1,35 @@
/**
* File: preorder_traversal_i_compact.dart
* Created Time: 2023-08-10
* Author: liuyuxin (gvenusleo@gmail.com)
*/
import '../utils/print_util.dart';
import '../utils/tree_node.dart';
/* 前序遍历：例题一 */
void preOrder(TreeNode? root, List<TreeNode> res) {
if (root == null) {
return;
}
if (root.val == 7) {
// 记录解
res.add(root);
}
preOrder(root.left, res);
preOrder(root.right, res);
}
/* Driver Code */
void main() {
TreeNode? root = listToTree([1, 7, 3, 4, 5, 6, 7]);
print("\n初始化二叉树");
printTree(root);
// 前序遍历
List<TreeNode> res = [];
preOrder(root, res);
print("\n输出所有值为 7 的节点");
print(List.generate(res.length, (i) => res[i].val));
}

47
codes/dart/chapter_backtracking/preorder_traversal_ii_compact.dart Normal file
View File

@ -0,0 +1,47 @@
/**
* File: preorder_traversal_ii_compact.dart
* Created Time: 2023-08-10
* Author: liuyuxin (gvenusleo@gmail.com)
*/
import '../utils/print_util.dart';
import '../utils/tree_node.dart';
/* 前序遍历：例题二 */
void preOrder(
TreeNode? root,
List<TreeNode> path,
List<List<TreeNode>> res,
) {
if (root == null) {
return;
}
// 尝试
path.add(root);
if (root.val == 7) {
// 记录解
res.add(List.from(path));
}
preOrder(root.left, path, res);
preOrder(root.right, path, res);
// 回退
path.removeLast();
}
/* Driver Code */
void main() {
TreeNode? root = listToTree([1, 7, 3, 4, 5, 6, 7]);
print("\n初始化二叉树");
printTree(root);
// 前序遍历
List<TreeNode> path = [];
List<List<TreeNode>> res = [];
preOrder(root, path, res);
print("\n输出所有根节点到节点 7 的路径");
for (List<TreeNode> vals in res) {
print(List.generate(vals.length, (i) => vals[i].val));
}
}

49
codes/dart/chapter_backtracking/preorder_traversal_iii_compact.dart Normal file
View File

@ -0,0 +1,49 @@
/**
* File: preorder_traversal_iii_compact.dart
* Created Time: 2023-08-10
* Author: liuyuxin (gvenusleo@gmail.com)
*/
import '../utils/print_util.dart';
import '../utils/tree_node.dart';
/* 前序遍历：例题三 */
void preOrder(
TreeNode? root,
List<TreeNode> path,
List<List<TreeNode>> res,
) {
if (root == null || root.val == 3) {
return;
}
// 尝试
path.add(root);
if (root.val == 7) {
// 记录解
res.add(List.from(path));
path.removeLast();
return;
}
preOrder(root.left, path, res);
preOrder(root.right, path, res);
// 回退
path.removeLast();
}
/* Driver Code */
void main() {
TreeNode? root = listToTree([1, 7, 3, 4, 5, 6, 7]);
print("\n初始化二叉树");
printTree(root);
// 前序遍历
List<TreeNode> path = [];
List<List<TreeNode>> res = [];
preOrder(root, path, res);
print("\n输出所有根节点到节点 7 的路径");
for (List<TreeNode> vals in res) {
print(List.generate(vals.length, (i) => vals[i].val));
}
}

73
codes/dart/chapter_backtracking/preorder_traversal_iii_template.dart Normal file
View File

@ -0,0 +1,73 @@
/**
* File: preorder_traversal_iii_template.dart
* Created Time: 2023-08-10
* Author: liuyuxin (gvenusleo@gmail.com)
*/
import '../utils/print_util.dart';
import '../utils/tree_node.dart';
/* 判断当前状态是否为解 */
bool isSolution(List<TreeNode> state) {
return state.isNotEmpty && state.last.val == 7;
}
/* 记录解 */
void recordSolution(List<TreeNode> state, List<List<TreeNode>> res) {
res.add(List.from(state));
}
/* 判断在当前状态下，该选择是否合法 */
bool isValid(List<TreeNode> state, TreeNode? choice) {
return choice != null && choice.val != 3;
}
/* 更新状态 */
void makeChoice(List<TreeNode> state, TreeNode? choice) {
state.add(choice!);
}
/* 恢复状态 */
void undoChoice(List<TreeNode> state, TreeNode? choice) {
state.removeLast();
}
/* 回溯算法：例题三 */
void backtrack(
List<TreeNode> state,
List<TreeNode?> choices,
List<List<TreeNode>> res,
) {
// 检查是否为解
if (isSolution(state)) {
// 记录解
recordSolution(state, res);
}
// 遍历所有选择
for (TreeNode? choice in choices) {
// 剪枝：检查选择是否合法
if (isValid(state, choice)) {
// 尝试：做出选择，更新状态
makeChoice(state, choice);
// 进行下一轮选择
backtrack(state, [choice!.left, choice.right], res);
// 回退：撤销选择，恢复到之前的状态
undoChoice(state, choice);
}
}
}
/* Driver Code */
void main() {
TreeNode? root = listToTree([1, 7, 3, 4, 5, 6, 7]);
print("\n初始化二叉树");
printTree(root);
// 回溯算法
List<List<TreeNode>> res = [];
backtrack([], [root!], res);
print("\n输出所有根节点到节点 7 的路径，要求路径中不包含值为 3 的节点");
for (List<TreeNode> path in res) {
print(List.from(path.map((e) => e.val)));
}
}

56
codes/dart/chapter_backtracking/subset_sum_i.dart Normal file
View File

@ -0,0 +1,56 @@
/**
* File: subset_sum_i.dart
* Created Time: 2023-08-10
* Author: liuyuxin (gvenusleo@gmail.com)
*/
/* 回溯算法：子集和 I */
void backtrack(
List<int> state,
int target,
List<int> choices,
int start,
List<List<int>> res,
) {
// 子集和等于 target 时，记录解
if (target == 0) {
res.add(List.from(state));
return;
}
// 遍历所有选择
// 剪枝二：从 start 开始遍历，避免生成重复子集
for (int i = start; i < choices.length; i++) {
// 剪枝一：若子集和超过 target ，则直接结束循环
// 这是因为数组已排序，后边元素更大，子集和一定超过 target
if (target - choices[i] < 0) {
break;
}
// 尝试：做出选择，更新 target, start
state.add(choices[i]);
// 进行下一轮选择
backtrack(state, target - choices[i], choices, i, res);
// 回退：撤销选择，恢复到之前的状态
state.removeLast();
}
}
/* 求解子集和 I */
List<List<int>> subsetSumI(List<int> nums, int target) {
List<int> state = []; // 状态（子集）
nums.sort(); // 对 nums 进行排序
int start = 0; // 遍历起始点
List<List<int>> res = []; // 结果列表（子集列表）
backtrack(state, target, nums, start, res);
return res;
}
/* Driver Code */
void main() {
List<int> nums = [3, 4, 5];
int target = 9;
List<List<int>> res = subsetSumI(nums, target);
print("输入数组 nums = $nums, target = $target");
print("所有和等于 $target 的子集 res = $res");
}

54
codes/dart/chapter_backtracking/subset_sum_i_naive.dart Normal file
View File

@ -0,0 +1,54 @@
/**
* File: subset_sum_i_naive.dart
* Created Time: 2023-08-10
* Author: liuyuxin (gvenusleo@gmail.com)
*/
/* 回溯算法：子集和 I */
void backtrack(
List<int> state,
int target,
int total,
List<int> choices,
List<List<int>> res,
) {
// 子集和等于 target 时，记录解
if (total == target) {
res.add(List.from(state));
return;
}
// 遍历所有选择
for (int i = 0; i < choices.length; i++) {
// 剪枝：若子集和超过 target ，则跳过该选择
if (total + choices[i] > target) {
continue;
}
// 尝试：做出选择，更新元素和 total
state.add(choices[i]);
// 进行下一轮选择
backtrack(state, target, total + choices[i], choices, res);
// 回退：撤销选择，恢复到之前的状态
state.removeLast();
}
}
/* 求解子集和 I（包含重复子集） */
List<List<int>> subsetSumINaive(List<int> nums, int target) {
List<int> state = []; // 状态（子集）
int total = 0; // 元素和
List<List<int>> res = []; // 结果列表（子集列表）
backtrack(state, target, total, nums, res);
return res;
}
/* Driver Code */
void main() {
List<int> nums = [3, 4, 5];
int target = 9;
List<List<int>> res = subsetSumINaive(nums, target);
print("输入数组 nums = $nums, target = $target");
print("所有和等于 $target 的子集 res = $res");
print("请注意，该方法输出的结果包含重复集合");
}

60
codes/dart/chapter_backtracking/subset_sum_ii.dart Normal file
View File

@ -0,0 +1,60 @@
/**
* File: subset_sum_ii.dart
* Created Time: 2023-08-10
* Author: liuyuxin (gvenusleo@gmail.com)
*/
/* 回溯算法：子集和 II */
void backtrack(
List<int> state,
int target,
List<int> choices,
int start,
List<List<int>> res,
) {
// 子集和等于 target 时，记录解
if (target == 0) {
res.add(List.from(state));
return;
}
// 遍历所有选择
// 剪枝二：从 start 开始遍历，避免生成重复子集
// 剪枝三：从 start 开始遍历，避免重复选择同一元素
for (int i = start; i < choices.length; i++) {
// 剪枝一：若子集和超过 target ，则直接结束循环
// 这是因为数组已排序，后边元素更大，子集和一定超过 target
if (target - choices[i] < 0) {
break;
}
// 剪枝四：如果该元素与左边元素相等，说明该搜索分支重复，直接跳过
if (i > start && choices[i] == choices[i - 1]) {
continue;
}
// 尝试：做出选择，更新 target, start
state.add(choices[i]);
// 进行下一轮选择
backtrack(state, target - choices[i], choices, i + 1, res);
// 回退：撤销选择，恢复到之前的状态
state.removeLast();
}
}
/* 求解子集和 II */
List<List<int>> subsetSumII(List<int> nums, int target) {
List<int> state = []; // 状态（子集）
nums.sort(); // 对 nums 进行排序
int start = 0; // 遍历起始点
List<List<int>> res = []; // 结果列表（子集列表）
backtrack(state, target, nums, start, res);
return res;
}
void main() {
List<int> nums = [4, 4, 5];
int target = 9;
List<List<int>> res = subsetSumII(nums, target);
print("输入数组 nums = $nums, target = $target");
print("所有和等于 $target 的子集 res = $res");
}

42
codes/dart/chapter_divide_and_conquer/binary_search_recur.dart Normal file
View File

@ -0,0 +1,42 @@
/**
* File: binary_search_recur.dart
* Created Time: 2023-08-10
* Author: liuyuxin (gvenusleo@gmail.com)
*/
/* 二分查找：问题 f(i, j) */
int dfs(List<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(List<int> nums, int target) {
int n = nums.length;
// 求解问题 f(0, n-1)
return dfs(nums, target, 0, n - 1);
}
/* Driver Code */
void main() {
int target = 6;
List<int> nums = [1, 3, 6, 8, 12, 15, 23, 26, 31, 35];
// 二分查找（双闭区间）
int index = binarySearch(nums, target);
print("目标元素 6 的索引 = $index");
}

56
codes/dart/chapter_divide_and_conquer/build_tree.dart Normal file
View File

@ -0,0 +1,56 @@
/**
* File: build_tree.dart
* Created Time: 2023-08-10
* Author: liuyuxin (gvenusleo@gmail.com)
*/
import '../utils/print_util.dart';
import '../utils/tree_node.dart';
/* 构建二叉树：分治 */
TreeNode? dfs(
List<int> preorder,
List<int> inorder,
Map<int, int> hmap,
int i,
int l,
int r,
) {
// 子树区间为空时终止
if (r - l < 0) {
return null;
}
// 初始化根节点
TreeNode? root = TreeNode(preorder[i]);
// 查询 m ，从而划分左右子树
int m = hmap[preorder[i]]!;
// 子问题：构建左子树
root.left = dfs(preorder, inorder, hmap, i + 1, l, m - 1);
// 子问题：构建右子树
root.right = dfs(preorder, inorder, hmap, i + 1 + m - l, m + 1, r);
// 返回根节点
return root;
}
/* 构建二叉树 */
TreeNode? buildTree(List<int> preorder, List<int> inorder) {
// 初始化哈希表，存储 inorder 元素到索引的映射
Map<int, int> hmap = {};
for (int i = 0; i < inorder.length; i++) {
hmap[inorder[i]] = i;
}
TreeNode? root = dfs(preorder, inorder, hmap, 0, 0, inorder.length - 1);
return root;
}
/* Driver Code */
void main() {
List<int> preorder = [3, 9, 2, 1, 7];
List<int> inorder = [9, 3, 1, 2, 7];
print("前序遍历 = $preorder");
print("中序遍历 = $inorder");
TreeNode? root = buildTree(preorder, inorder);
print("构建的二叉树为：");
printTree(root!);
}

54
codes/dart/chapter_divide_and_conquer/hanota.dart Normal file
View File

@ -0,0 +1,54 @@
/**
* File: hanota.dart
* Created Time: 2023-08-10
* Author: liuyuxin (gvenusleo@gmail.com)
*/
/* 移动一个圆盘 */
void move(List<int> src, List<int> tar) {
// 从 src 顶部拿出一个圆盘
int pan = src.removeLast();
// 将圆盘放入 tar 顶部
tar.add(pan);
}
/* 求解汉诺塔：问题 f(i) */
void dfs(int i, List<int> src, List<int> buf, List<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 hanota(List<int> A, List<int> B, List<int> C) {
int n = A.length;
// 将 A 顶部 n 个圆盘借助 B 移到 C
dfs(n, A, B, C);
}
/* Driver Code */
void main() {
// 列表尾部是柱子顶部
List<int> A = [5, 4, 3, 2, 1];
List<int> B = [];
List<int> C = [];
print("初始状态下：");
print("A = $A");
print("B = $B");
print("C = $C");
hanota(A, B, C);
print("圆盘移动完成后：");
print("A = $A");
print("B = $B");
print("C = $C");
}

12
codes/dart/chapter_searching/hashing_search.dart
View File

@ -18,7 +18,7 @@ int hashingSearchArray(Map<int, int> map, int target) {
}
/* 哈希查找（链表） */
ListNode? hashingSearchLinkedList(Map<int,ListNode> map, int target) {
ListNode? hashingSearchLinkedList(Map<int, ListNode> map, int target) {
// 哈希表的 key: 目标节点值，value: 节点对象
// 若哈希表中无此 key ，返回 null
if (!map.containsKey(target)) {
@ -28,15 +28,15 @@ ListNode? hashingSearchLinkedList(Map<int,ListNode> map, int target) {
}
/* Driver Code */
void main(){
void main() {
int target = 3;
/* 哈希查找（数组） */
List<int> nums = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8];
// 初始化哈希表
Map<int,int> map = HashMap();
Map<int, int> map = HashMap();
for (int i = 0; i < nums.length; i++) {
map.putIfAbsent(nums[i], () => i);// key: 元素，value: 索引
map.putIfAbsent(nums[i], () => i); // key: 元素，value: 索引
}
int index = hashingSearchArray(map, target);
print('目标元素 3 的索引 = $index');
@ -44,11 +44,11 @@ void main(){
/* 哈希查找（链表） */
ListNode? head = listToLinkedList(nums);
// 初始化哈希表
Map<int,ListNode> map1 = HashMap();
Map<int, ListNode> map1 = HashMap();
while (head != null) {
map1.putIfAbsent(head.val, () => head!); // key: 节点值，value: 节点
head = head.next;
}
ListNode? node = hashingSearchLinkedList(map1, target);
print('目标节点值 3 的对应节点对象为 $node');
}
}

7
codes/dart/chapter_searching/linear_search.dart
View File

@ -24,8 +24,7 @@ ListNode? linearSearchList(ListNode? head, int target) {
// 遍历链表
while (head != null) {
// 找到目标节点，返回之
if (head.val == target)
return head;
if (head.val == target) return head;
head = head.next;
}
// 未找到目标元素，返回 null
@ -33,7 +32,7 @@ ListNode? linearSearchList(ListNode? head, int target) {
}
/* Driver Code */
void main(){
void main() {
int target = 3;
/* 在数组中执行线性查找 */
@ -45,4 +44,4 @@ void main(){
ListNode? head = listToLinkedList(nums);
ListNode? node = linearSearchList(head, target);
print('目标节点值 3 的对应节点对象为 $node');
}
}

4
codes/dart/chapter_sorting/bubble_sort.dart
View File

@ -8,7 +8,7 @@
void bubbleSort(List<int> nums) {
// 外循环：未排序区间为 [0, i]
for (int i = nums.length - 1; i > 0; i--) {
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for (int j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]
@ -25,7 +25,7 @@ void bubbleSortWithFlag(List<int> nums) {
// 外循环：未排序区间为 [0, i]
for (int i = nums.length - 1; i > 0; i--) {
bool flag = false; // 初始化标志位
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for (int j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]

4
codes/dart/chapter_sorting/counting_sort.dart
View File

@ -13,7 +13,7 @@ void countingSortNaive(List<int> nums) {
for (int num in nums) {
m = max(m, num);
}
// 2. 统计各数字的出现次数
// 2. 统计各数字的出现次数
// counter[num] 代表 num 的出现次数
List<int> counter = List.filled(m + 1, 0);
for (int num in nums) {
@ -54,7 +54,7 @@ void countingSort(List<int> nums) {
for (int i = n - 1; i >= 0; i--) {
int num = nums[i];
res[counter[num] - 1] = num; // 将 num 放置到对应索引处
counter[num]--; // 令前缀和自减 1 ，得到下次放置 num 的索引
counter[num]--; // 令前缀和自减 1 ，得到下次放置 num 的索引
}
// 使用结果数组 res 覆盖原数组 nums
nums.setAll(0, res);

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

@ -40,7 +40,7 @@ void countingSortDigit(List<int> nums, int exp) {
void radixSort(List<int> nums) {
// 获取数组的最大元素，用于判断最大位数
// dart 中 int 的长度是 64 位的
int m = -1 << 63;
int m = -1 << 63;
for (int num in nums) if (num > m) m = num;
// 按照从低位到高位的顺序遍历
for (int exp = 1; exp <= m; exp *= 10)
@ -54,8 +54,18 @@ void radixSort(List<int> nums) {
/* Driver Code */
void main() {
// 基数排序
List<int> nums = [10546151, 35663510, 42865989, 34862445, 81883077,
88906420, 72429244, 30524779, 82060337, 63832996];
List<int> nums = [
10546151,
35663510,
42865989,
34862445,
81883077,
88906420,
72429244,
30524779,
82060337,
63832996
];
radixSort(nums);
print("基数排序完成后 nums = $nums");
}

1
codes/dart/chapter_tree/binary_search_tree.dart
View File

@ -113,7 +113,6 @@ void remove(int num) {
// 若删除节点为根节点，则重新指定根节点
root = child;
}
} else {
// 子节点数量 = 2
// 获取中序遍历中 cur 的下一个节点