algorithm/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2025-07-28 04:42:48 +08:00
Code Issues Packages Projects Releases Wiki Activity

build

Browse Source
This commit is contained in:
krahets
2024-04-09 20:43:40 +08:00
parent d8caf02e9e
commit a6adc8e20a
48 changed files with 1599 additions and 571 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
en/docs/chapter_tree/array_representation_of_tree.md
View File

@ -1172,8 +1172,8 @@ The following code implements a binary tree based on array representation, inclu
=== "Kotlin"
```kotlin title="array_binary_tree.kt"
/* 数组表示下的二叉树类 */
class ArrayBinaryTree(val tree: List<Int?>) {
/* 构造方法 */
class ArrayBinaryTree(val tree: MutableList<Int?>) {
/* 列表容量 */
fun size(): Int {
return tree.size
@ -1202,11 +1202,12 @@ The following code implements a binary tree based on array representation, inclu
}
/* 层序遍历 */
fun levelOrder(): List<Int?> {
val res = ArrayList<Int?>()
fun levelOrder(): MutableList<Int?> {
val res = mutableListOf<Int?>()
// 直接遍历数组
for (i in 0..<size()) {
if (value(i) != null) res.add(value(i))
if (value(i) != null)
res.add(value(i))
}
return res
}
@ -1214,34 +1215,38 @@ The following code implements a binary tree based on array representation, inclu
/* 深度优先遍历 */
fun dfs(i: Int, order: String, res: MutableList<Int?>) {
// 若为空位，则返回
if (value(i) == null) return
if (value(i) == null)
return
// 前序遍历
if ("pre" == order) res.add(value(i))
if ("pre" == order)
res.add(value(i))
dfs(left(i), order, res)
// 中序遍历
if ("in" == order) res.add(value(i))
if ("in" == order)
res.add(value(i))
dfs(right(i), order, res)
// 后序遍历
if ("post" == order) res.add(value(i))
if ("post" == order)
res.add(value(i))
}
/* 前序遍历 */
fun preOrder(): List<Int?> {
val res = ArrayList<Int?>()
fun preOrder(): MutableList<Int?> {
val res = mutableListOf<Int?>()
dfs(0, "pre", res)
return res
}
/* 中序遍历 */
fun inOrder(): List<Int?> {
val res = ArrayList<Int?>()
fun inOrder(): MutableList<Int?> {
val res = mutableListOf<Int?>()
dfs(0, "in", res)
return res
}
/* 后序遍历 */
fun postOrder(): List<Int?> {
val res = ArrayList<Int?>()
fun postOrder(): MutableList<Int?> {
val res = mutableListOf<Int?>()
dfs(0, "post", res)
return res
}

30
en/docs/chapter_tree/avl_tree.md
View File

@ -448,7 +448,7 @@ The "node height" refers to the distance from that node to its farthest leaf nod
/* 更新节点高度 */
fun updateHeight(node: TreeNode?) {
// 节点高度等于最高子树高度 + 1
node?.height = (max(height(node?.left).toDouble(), height(node?.right).toDouble()) + 1).toInt()
node?.height = max(height(node?.left), height(node?.right)) + 1
}
```
@ -2022,10 +2022,12 @@ The node insertion operation in AVL trees is similar to that in binary search tr
return TreeNode(value)
var node = n
/* 1. 查找插入位置并插入节点 */
if (value < node.value) node.left = insertHelper(node.left, value)
else if (value > node.value) node.right = insertHelper(node.right, value)
else return node // 重复节点不插入，直接返回
if (value < node.value)
node.left = insertHelper(node.left, value)
else if (value > node.value)
node.right = insertHelper(node.right, value)
else
return node // 重复节点不插入，直接返回
updateHeight(node) // 更新节点高度
/* 2. 执行旋转操作，使该子树重新恢复平衡 */
node = rotate(node)
@ -2601,14 +2603,22 @@ Similarly, based on the method of removing nodes in binary search trees, rotatio
fun removeHelper(n: TreeNode?, value: Int): TreeNode? {
var node = n ?: return null
/* 1. 查找节点并删除 */
if (value < node.value) node.left = removeHelper(node.left, value)
else if (value > node.value) node.right = removeHelper(node.right, value)
if (value < node.value)
node.left = removeHelper(node.left, value)
else if (value > node.value)
node.right = removeHelper(node.right, value)
else {
if (node.left == null || node.right == null) {
val child = if (node.left != null) node.left else node.right
val child = if (node.left != null)
node.left
else
node.right
// 子节点数量 = 0 ，直接删除 node 并返回
if (child == null) return null
else node = child
if (child == null)
return null
// 子节点数量 = 1 ，直接删除 node
else
node = child
} else {
// 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
var temp = node.right

50
en/docs/chapter_tree/binary_search_tree.md
View File

@ -299,11 +299,14 @@ The search operation in a binary search tree works on the same principle as the
// 循环查找，越过叶节点后跳出
while (cur != null) {
// 目标节点在 cur 的右子树中
cur = if (cur.value < num) cur.right
cur = if (cur.value < num)
cur.right
// 目标节点在 cur 的左子树中
else if (cur.value > num) cur.left
else if (cur.value > num)
cur.left
// 找到目标节点，跳出循环
else break
else
break
}
// 返回目标节点
return cur
@ -748,17 +751,22 @@ In the code implementation, note the following two points.
// 循环查找，越过叶节点后跳出
while (cur != null) {
// 找到重复节点，直接返回
if (cur.value == num) return
if (cur.value == num)
return
pre = cur
// 插入位置在 cur 的右子树中
cur = if (cur.value < num) cur.right
cur = if (cur.value < num)
cur.right
// 插入位置在 cur 的左子树中
else cur.left
else
cur.left
}
// 插入节点
val node = TreeNode(num)
if (pre?.value!! < num) pre.right = node
else pre.left = node
if (pre?.value!! < num)
pre.right = node
else
pre.left = node
}
```
@ -1482,29 +1490,39 @@ The operation of removing a node also uses $O(\log n)$ time, where finding the n
/* 删除节点 */
fun remove(num: Int) {
// 若树为空，直接提前返回
if (root == null) return
if (root == null)
return
var cur = root
var pre: TreeNode? = null
// 循环查找，越过叶节点后跳出
while (cur != null) {
// 找到待删除节点，跳出循环
if (cur.value == num) break
if (cur.value == num)
break
pre = cur
// 待删除节点在 cur 的右子树中
cur = if (cur.value < num) cur.right
cur = if (cur.value < num)
cur.right
// 待删除节点在 cur 的左子树中
else cur.left
else
cur.left
}
// 若无待删除节点，则直接返回
if (cur == null) return
if (cur == null)
return
// 子节点数量 = 0 or 1
if (cur.left == null || cur.right == null) {
// 当子节点数量 = 0 / 1 时， child = null / 该子节点
val child = if (cur.left != null) cur.left else cur.right
val child = if (cur.left != null)
cur.left
else
cur.right
// 删除节点 cur
if (cur != root) {
if (pre!!.left == cur) pre.left = child
else pre.right = child
if (pre!!.left == cur)
pre.left = child
else
pre.right = child
} else {
// 若删除节点为根节点，则重新指定根节点
root = child

33
en/docs/chapter_tree/binary_tree_traversal.md
View File

@ -229,7 +229,7 @@ Breadth-first traversal is usually implemented with the help of a "queue". The q
fn level_order(root: &Rc<RefCell<TreeNode>>) -> Vec<i32> {
// 初始化队列，加入根节点
let mut que = VecDeque::new();
que.push_back(Rc::clone(&root));
que.push_back(root.clone());
// 初始化一个列表，用于保存遍历序列
let mut vec = Vec::new();
@ -237,10 +237,10 @@ Breadth-first traversal is usually implemented with the help of a "queue". The q
// 队列出队
vec.push(node.borrow().val); // 保存节点值
if let Some(left) = node.borrow().left.as_ref() {
que.push_back(Rc::clone(left)); // 左子节点入队
que.push_back(left.clone()); // 左子节点入队
}
if let Some(right) = node.borrow().right.as_ref() {
que.push_back(Rc::clone(right)); // 右子节点入队
que.push_back(right.clone()); // 右子节点入队
};
}
vec
@ -302,13 +302,14 @@ Breadth-first traversal is usually implemented with the help of a "queue". The q
val queue = LinkedList<TreeNode?>()
queue.add(root)
// 初始化一个列表，用于保存遍历序列
val list = ArrayList<Int>()
while (!queue.isEmpty()) {
val node = queue.poll() // 队列出队
list.add(node?.value!!) // 保存节点值
if (node.left != null) queue.offer(node.left) // 左子节点入队
if (node.right != null) queue.offer(node.right) // 右子节点入队
val list = mutableListOf<Int>()
while (queue.isNotEmpty()) {
val node = queue.poll() // 队列出队
list.add(node?.value!!) // 保存节点值
if (node.left != null)
queue.offer(node.left) // 左子节点入队
if (node.right != null)
queue.offer(node.right) // 右子节点入队
}
return list
}
@ -689,8 +690,8 @@ Depth-first search is usually implemented based on recursion:
if let Some(node) = root {
// 访问优先级：根节点 -> 左子树 -> 右子树
result.push(node.borrow().val);
result.append(&mut pre_order(node.borrow().left.as_ref()));
result.append(&mut pre_order(node.borrow().right.as_ref()));
result.extend(pre_order(node.borrow().left.as_ref()));
result.extend(pre_order(node.borrow().right.as_ref()));
}
result
}
@ -701,9 +702,9 @@ Depth-first search is usually implemented based on recursion:
if let Some(node) = root {
// 访问优先级：左子树 -> 根节点 -> 右子树
result.append(&mut in_order(node.borrow().left.as_ref()));
result.extend(in_order(node.borrow().left.as_ref()));
result.push(node.borrow().val);
result.append(&mut in_order(node.borrow().right.as_ref()));
result.extend(in_order(node.borrow().right.as_ref()));
}
result
}
@ -714,8 +715,8 @@ Depth-first search is usually implemented based on recursion:
if let Some(node) = root {
// 访问优先级：左子树 -> 右子树 -> 根节点
result.append(&mut post_order(node.borrow().left.as_ref()));
result.append(&mut post_order(node.borrow().right.as_ref()));
result.extend(post_order(node.borrow().left.as_ref()));
result.extend(post_order(node.borrow().right.as_ref()));
result.push(node.borrow().val);
}
result