xmengnet/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2024-12-27 14:16:29 +08:00
Code Issues Projects Releases Packages Wiki Activity Actions

build

Browse source
This commit is contained in:
krahets 2023-04-14 05:51:42 +08:00
parent 4d318e8e6b
commit 3c1eacca7f
2 changed files with 188 additions and 383 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

206
chapter_tree/avl_tree.md
View file

@ -1196,9 +1196,8 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
```java title="avl_tree.java" ```java title="avl_tree.java"
/* 插入节点 */ /* 插入节点 */
TreeNode insert(int val) { void insert(int val) {
root = insertHelper(root, val); root = insertHelper(root, val);
return root;
} }
/* 递归插入节点（辅助方法） */ /* 递归插入节点（辅助方法） */
@ -1224,9 +1223,8 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
```cpp title="avl_tree.cpp" ```cpp title="avl_tree.cpp"
/* 插入节点 */ /* 插入节点 */
TreeNode *insert(int val) { void insert(int val) {
root = insertHelper(root, val); root = insertHelper(root, val);
return root;
} }
/* 递归插入节点（辅助方法） */ /* 递归插入节点（辅助方法） */
@ -1251,10 +1249,9 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
=== "Python" === "Python"
```python title="avl_tree.py" ```python title="avl_tree.py"
def insert(self, val) -> TreeNode: def insert(self, val) -> None:
"""插入节点""" """插入节点"""
self.__root = self.__insert_helper(self.__root, val) self.__root = self.__insert_helper(self.__root, val)
return self.__root
def __insert_helper(self, node: TreeNode | None, val: int) -> TreeNode: def __insert_helper(self, node: TreeNode | None, val: int) -> TreeNode:
"""递归插入节点（辅助方法）""" """递归插入节点（辅助方法）"""
@ -1278,9 +1275,8 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
```go title="avl_tree.go" ```go title="avl_tree.go"
/* 插入节点 */ /* 插入节点 */
func (t *aVLTree) insert(val int) *TreeNode { func (t *aVLTree) insert(val int) {
t.root = t.insertHelper(t.root, val) t.root = t.insertHelper(t.root, val)
return t.root
} }
/* 递归插入节点（辅助方法） */ /* 递归插入节点（辅助方法） */
@ -1312,7 +1308,6 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
/* 插入节点 */ /* 插入节点 */
insert(val) { insert(val) {
this.root = this.#insertHelper(this.root, val); this.root = this.#insertHelper(this.root, val);
return this.root;
} }
/* 递归插入节点（辅助方法） */ /* 递归插入节点（辅助方法） */
@ -1334,9 +1329,8 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
```typescript title="avl_tree.ts" ```typescript title="avl_tree.ts"
/* 插入节点 */ /* 插入节点 */
insert(val: number): TreeNode { insert(val: number): void {
this.root = this.insertHelper(this.root, val); this.root = this.insertHelper(this.root, val);
return this.root;
} }
/* 递归插入节点（辅助方法） */ /* 递归插入节点（辅助方法） */
@ -1370,10 +1364,9 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
```csharp title="avl_tree.cs" ```csharp title="avl_tree.cs"
/* 插入节点 */ /* 插入节点 */
TreeNode? insert(int val) void insert(int val)
{ {
root = insertHelper(root, val); root = insertHelper(root, val);
return root;
} }
/* 递归插入节点（辅助方法） */ /* 递归插入节点（辅助方法） */
@ -1400,9 +1393,8 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
```swift title="avl_tree.swift" ```swift title="avl_tree.swift"
/* 插入节点 */ /* 插入节点 */
@discardableResult @discardableResult
func insert(val: Int) -> TreeNode? { func insert(val: Int) {
root = insertHelper(node: root, val: val) root = insertHelper(node: root, val: val)
return root
} }
/* 递归插入节点（辅助方法） */ /* 递归插入节点（辅助方法） */
@ -1431,9 +1423,8 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
```zig title="avl_tree.zig" ```zig title="avl_tree.zig"
// 插入节点 // 插入节点
fn insert(self: *Self, val: T) !?*inc.TreeNode(T) { fn insert(self: *Self, val: T) void {
self.root = try self.insertHelper(self.root, val); self.root = try self.insertHelper(self.root, val);
return self.root;
} }
// 递归插入节点（辅助方法） // 递归插入节点（辅助方法）
@ -1468,9 +1459,8 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
```java title="avl_tree.java" ```java title="avl_tree.java"
/* 删除节点 */ /* 删除节点 */
TreeNode remove(int val) { void remove(int val) {
root = removeHelper(root, val); root = removeHelper(root, val);
return root;
} }
/* 递归删除节点（辅助方法） */ /* 递归删除节点（辅助方法） */
@ -1493,7 +1483,10 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
node = child; node = child;
} else { } else {
// 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点 // 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
TreeNode temp = getInOrderNext(node.right); TreeNode temp = node.right;
while (temp.left != null) {
temp = temp.left;
}
node.right = removeHelper(node.right, temp.val); node.right = removeHelper(node.right, temp.val);
node.val = temp.val; node.val = temp.val;
} }
@ -1504,26 +1497,14 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
// 返回子树的根节点 // 返回子树的根节点
return node; return node;
} }
/* 获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况） */
TreeNode getInOrderNext(TreeNode node) {
if (node == null)
return node;
// 循环访问左子节点，直到叶节点时为最小节点，跳出
while (node.left != null) {
node = node.left;
}
return node;
}
``` ```
=== "C++" === "C++"
```cpp title="avl_tree.cpp" ```cpp title="avl_tree.cpp"
/* 删除节点 */ /* 删除节点 */
TreeNode *remove(int val) { void remove(int val) {
root = removeHelper(root, val); root = removeHelper(root, val);
return root;
} }
/* 递归删除节点（辅助方法） */ /* 递归删除节点（辅助方法） */
@ -1550,7 +1531,10 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
} }
} else { } else {
// 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点 // 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
TreeNode *temp = getInOrderNext(node->right); TreeNode *temp = node->right;
while (temp->left != nullptr) {
temp = temp->left;
}
int tempVal = temp->val; int tempVal = temp->val;
node->right = removeHelper(node->right, temp->val); node->right = removeHelper(node->right, temp->val);
node->val = tempVal; node->val = tempVal;
@ -1562,26 +1546,14 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
// 返回子树的根节点 // 返回子树的根节点
return node; return node;
} }
/* 获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况） */
TreeNode *getInOrderNext(TreeNode *node) {
if (node == nullptr)
return node;
// 循环访问左子节点，直到叶节点时为最小节点，跳出
while (node->left != nullptr) {
node = node->left;
}
return node;
}
``` ```
=== "Python" === "Python"
```python title="avl_tree.py" ```python title="avl_tree.py"
def remove(self, val: int) -> TreeNode | None: def remove(self, val: int) -> None:
"""删除节点""" """删除节点"""
self.__root = self.__remove_helper(self.__root, val) self.__root = self.__remove_helper(self.__root, val)
return self.__root
def __remove_helper(self, node: TreeNode | None, val: int) -> TreeNode | None: def __remove_helper(self, node: TreeNode | None, val: int) -> TreeNode | None:
"""递归删除节点（辅助方法）""" """递归删除节点（辅助方法）"""
@ -1601,32 +1573,25 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
# 子节点数量 = 1 ，直接删除 node # 子节点数量 = 1 ，直接删除 node
else: else:
node = child node = child
else: # 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点 else:
temp = self.__get_inorder_next(node.right) # 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
temp = node.right
while temp.left is not None:
temp = temp.left
node.right = self.__remove_helper(node.right, temp.val) node.right = self.__remove_helper(node.right, temp.val)
node.val = temp.val node.val = temp.val
# 更新节点高度 # 更新节点高度
self.__update_height(node) self.__update_height(node)
# 2. 执行旋转操作，使该子树重新恢复平衡 # 2. 执行旋转操作，使该子树重新恢复平衡
return self.__rotate(node) return self.__rotate(node)
def __get_inorder_next(self, node: TreeNode | None) -> TreeNode | None:
"""获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况）"""
if node is None:
return None
# 循环访问左子节点，直到叶节点时为最小节点，跳出
while node.left is not None:
node = node.left
return node
``` ```
=== "Go" === "Go"
```go title="avl_tree.go" ```go title="avl_tree.go"
/* 删除节点 */ /* 删除节点 */
func (t *aVLTree) remove(val int) *TreeNode { func (t *aVLTree) remove(val int) {
root := t.removeHelper(t.root, val) t.root = t.removeHelper(t.root, val)
return root
} }
/* 递归删除节点（辅助方法） */ /* 递归删除节点（辅助方法） */
@ -1645,8 +1610,8 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
if node.Right != nil { if node.Right != nil {
child = node.Right child = node.Right
} }
// 子节点数量 = 0 ，直接删除 node 并返回
if child == nil { if child == nil {
// 子节点数量 = 0 ，直接删除 node 并返回
return nil return nil
} else { } else {
// 子节点数量 = 1 ，直接删除 node // 子节点数量 = 1 ，直接删除 node
@ -1654,7 +1619,10 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
} }
} else { } else {
// 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点 // 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
temp := t.getInOrderNext(node.Right) temp := node.Right
for temp.Left != nil {
temp = temp.Left
}
node.Right = t.removeHelper(node.Right, temp.Val) node.Right = t.removeHelper(node.Right, temp.Val)
node.Val = temp.Val node.Val = temp.Val
} }
@ -1666,18 +1634,6 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
// 返回子树的根节点 // 返回子树的根节点
return node return node
} }
/* 获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况） */
func (t *aVLTree) getInOrderNext(node *TreeNode) *TreeNode {
if node == nil {
return node
}
// 循环访问左子节点，直到叶节点时为最小节点，跳出
for node.Left != nil {
node = node.Left
}
return node
}
``` ```
=== "JavaScript" === "JavaScript"
@ -1686,7 +1642,6 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
/* 删除节点 */ /* 删除节点 */
remove(val) { remove(val) {
this.root = this.#removeHelper(this.root, val); this.root = this.#removeHelper(this.root, val);
return this.root;
} }
/* 递归删除节点（辅助方法） */ /* 递归删除节点（辅助方法） */
@ -1704,7 +1659,10 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
else node = child; else node = child;
} else { } else {
// 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点 // 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
const temp = this.#getInOrderNext(node.right); let temp = node.right;
while (temp.left !== null) {
temp = temp.left;
}
node.right = this.#removeHelper(node.right, temp.val); node.right = this.#removeHelper(node.right, temp.val);
node.val = temp.val; node.val = temp.val;
} }
@ -1715,25 +1673,14 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
// 返回子树的根节点 // 返回子树的根节点
return node; return node;
} }
/* 获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况） */
#getInOrderNext(node) {
if (node === null) return node;
// 循环访问左子节点，直到叶节点时为最小节点，跳出
while (node.left !== null) {
node = node.left;
}
return node;
}
``` ```
=== "TypeScript" === "TypeScript"
```typescript title="avl_tree.ts" ```typescript title="avl_tree.ts"
/* 删除节点 */ /* 删除节点 */
remove(val: number): TreeNode { remove(val: number): void {
this.root = this.removeHelper(this.root, val); this.root = this.removeHelper(this.root, val);
return this.root;
} }
/* 递归删除节点（辅助方法） */ /* 递归删除节点（辅助方法） */
@ -1756,7 +1703,10 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
} }
} else { } else {
// 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点 // 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
const temp = this.getInOrderNext(node.right); let temp = node.right;
while (temp.left !== null) {
temp = temp.left;
}
node.right = this.removeHelper(node.right, temp.val); node.right = this.removeHelper(node.right, temp.val);
node.val = temp.val; node.val = temp.val;
} }
@ -1767,16 +1717,6 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
// 返回子树的根节点 // 返回子树的根节点
return node; return node;
} }
/* 获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况） */
getInOrderNext(node: TreeNode): TreeNode {
if (node === null) return node;
// 循环访问左子节点，直到叶节点时为最小节点，跳出
while (node.left !== null) {
node = node.left;
}
return node;
}
``` ```
=== "C" === "C"
@ -1785,18 +1725,15 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
[class]{aVLTree}-[func]{remove} [class]{aVLTree}-[func]{remove}
[class]{aVLTree}-[func]{removeHelper} [class]{aVLTree}-[func]{removeHelper}
[class]{aVLTree}-[func]{getInOrderNext}
``` ```
=== "C#" === "C#"
```csharp title="avl_tree.cs" ```csharp title="avl_tree.cs"
/* 删除节点 */ /* 删除节点 */
TreeNode? remove(int val) void remove(int val)
{ {
root = removeHelper(root, val); root = removeHelper(root, val);
return root;
} }
/* 递归删除节点（辅助方法） */ /* 递归删除节点（辅助方法） */
@ -1823,7 +1760,11 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
else else
{ {
// 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点 // 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
TreeNode? temp = getInOrderNext(node.right); TreeNode? temp = node.right;
while (temp.left != null)
{
temp = temp.left;
}
node.right = removeHelper(node.right, temp.val); node.right = removeHelper(node.right, temp.val);
node.val = temp.val; node.val = temp.val;
} }
@ -1834,18 +1775,6 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
// 返回子树的根节点 // 返回子树的根节点
return node; return node;
} }
/* 获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况） */
TreeNode? getInOrderNext(TreeNode? node)
{
if (node == null) return node;
// 循环访问左子节点，直到叶节点时为最小节点，跳出
while (node.left != null)
{
node = node.left;
}
return node;
}
``` ```
=== "Swift" === "Swift"
@ -1853,9 +1782,8 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
```swift title="avl_tree.swift" ```swift title="avl_tree.swift"
/* 删除节点 */ /* 删除节点 */
@discardableResult @discardableResult
func remove(val: Int) -> TreeNode? { func remove(val: Int) {
root = removeHelper(node: root, val: val) root = removeHelper(node: root, val: val)
return root
} }
/* 递归删除节点（辅助方法） */ /* 递归删除节点（辅助方法） */
@ -1882,7 +1810,10 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
} }
} else { } else {
// 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点 // 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
let temp = getInOrderNext(node: node?.right) let temp = node?.right
while temp?.left != nil {
temp = temp?.left
}
node?.right = removeHelper(node: node?.right, val: temp!.val) node?.right = removeHelper(node: node?.right, val: temp!.val)
node?.val = temp!.val node?.val = temp!.val
} }
@ -1893,28 +1824,14 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
// 返回子树的根节点 // 返回子树的根节点
return node return node
} }
/* 获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况） */
func getInOrderNext(node: TreeNode?) -> TreeNode? {
var node = node
if node == nil {
return node
}
// 循环访问左子节点，直到叶节点时为最小节点，跳出
while node?.left != nil {
node = node?.left
}
return node
}
``` ```
=== "Zig" === "Zig"
```zig title="avl_tree.zig" ```zig title="avl_tree.zig"
// 删除节点 // 删除节点
fn remove(self: *Self, val: T) ?*inc.TreeNode(T) { fn remove(self: *Self, val: T) void {
self.root = self.removeHelper(self.root, val); self.root = self.removeHelper(self.root, val);
return self.root;
} }
// 递归删除节点（辅助方法） // 递归删除节点（辅助方法）
@ -1938,29 +1855,20 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
} }
} else { } else {
// 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点 // 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
var temp = self.getInOrderNext(node.?.right); var temp = node.?.right;
while (temp.?.left != null) {
temp = temp.?.left;
}
node.?.right = self.removeHelper(node.?.right, temp.?.val); node.?.right = self.removeHelper(node.?.right, temp.?.val);
node.?.val = temp.?.val; node.?.val = temp.?.val;
} }
} }
self.updateHeight(node); // 更新节点高度 self.updateHeight(node); // 更新节点高度
// 2. 执行旋转操作，使该子树重新恢复平衡 // 2. 执行旋转操作，使该子树重新恢复平衡
node = self.rotate(node); node = self.rotate(node);
// 返回子树的根节点 // 返回子树的根节点
return node; return node;
} }
// 获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况）
fn getInOrderNext(self: *Self, node_: ?*inc.TreeNode(T)) ?*inc.TreeNode(T) {
_ = self;
var node = node_;
if (node == null) return node;
// 循环访问左子节点，直到叶节点时为最小节点，跳出
while (node.?.left != null) {
node = node.?.left;
}
return node;
}
``` ```
### 查找节点 ### 查找节点

365
chapter_tree/binary_search_tree.md
View file

@ -263,16 +263,16 @@ comments: true
```java title="binary_search_tree.java" ```java title="binary_search_tree.java"
/* 插入节点 */ /* 插入节点 */
TreeNode insert(int num) { void insert(int num) {
// 若树为空，直接提前返回 // 若树为空，直接提前返回
if (root == null) if (root == null)
return null; return;
TreeNode cur = root, pre = null; TreeNode cur = root, pre = null;
// 循环查找，越过叶节点后跳出 // 循环查找，越过叶节点后跳出
while (cur != null) { while (cur != null) {
// 找到重复节点，直接返回 // 找到重复节点，直接返回
if (cur.val == num) if (cur.val == num)
return null; return;
pre = cur; pre = cur;
// 插入位置在 cur 的右子树中 // 插入位置在 cur 的右子树中
if (cur.val < num) if (cur.val < num)
@ -287,7 +287,6 @@ comments: true
pre.right = node; pre.right = node;
else else
pre.left = node; pre.left = node;
return node;
} }
``` ```
@ -295,16 +294,16 @@ comments: true
```cpp title="binary_search_tree.cpp" ```cpp title="binary_search_tree.cpp"
/* 插入节点 */ /* 插入节点 */
TreeNode *insert(int num) { void insert(int num) {
// 若树为空，直接提前返回 // 若树为空，直接提前返回
if (root == nullptr) if (root == nullptr)
return nullptr; return;
TreeNode *cur = root, *pre = nullptr; TreeNode *cur = root, *pre = nullptr;
// 循环查找，越过叶节点后跳出 // 循环查找，越过叶节点后跳出
while (cur != nullptr) { while (cur != nullptr) {
// 找到重复节点，直接返回 // 找到重复节点，直接返回
if (cur->val == num) if (cur->val == num)
return nullptr; return;
pre = cur; pre = cur;
// 插入位置在 cur 的右子树中 // 插入位置在 cur 的右子树中
if (cur->val < num) if (cur->val < num)
@ -319,25 +318,24 @@ comments: true
pre->right = node; pre->right = node;
else else
pre->left = node; pre->left = node;
return node;
} }
``` ```
=== "Python" === "Python"
```python title="binary_search_tree.py" ```python title="binary_search_tree.py"
def insert(self, num: int) -> TreeNode | None: def insert(self, num: int) -> None:
"""插入节点""" """插入节点"""
# 若树为空，直接提前返回 # 若树为空，直接提前返回
if self.__root is None: if self.__root is None:
return None return
# 循环查找，越过叶节点后跳出 # 循环查找，越过叶节点后跳出
cur, pre = self.__root, None cur, pre = self.__root, None
while cur is not None: while cur is not None:
# 找到重复节点，直接返回 # 找到重复节点，直接返回
if cur.val == num: if cur.val == num:
return None return
pre = cur pre = cur
# 插入位置在 cur 的右子树中 # 插入位置在 cur 的右子树中
if cur.val < num: if cur.val < num:
@ -352,25 +350,24 @@ comments: true
pre.right = node pre.right = node
else: else:
pre.left = node pre.left = node
return node
``` ```
=== "Go" === "Go"
```go title="binary_search_tree.go" ```go title="binary_search_tree.go"
/* 插入节点 */ /* 插入节点 */
func (bst *binarySearchTree) insert(num int) *TreeNode { func (bst *binarySearchTree) insert(num int) {
cur := bst.root cur := bst.root
// 若树为空，直接提前返回 // 若树为空，直接提前返回
if cur == nil { if cur == nil {
return nil return
} }
// 待插入节点之前的节点位置 // 待插入节点之前的节点位置
var pre *TreeNode = nil var pre *TreeNode = nil
// 循环查找，越过叶节点后跳出 // 循环查找，越过叶节点后跳出
for cur != nil { for cur != nil {
if cur.Val == num { if cur.Val == num {
return nil return
} }
pre = cur pre = cur
if cur.Val < num { if cur.Val < num {
@ -386,7 +383,6 @@ comments: true
} else { } else {
pre.Left = node pre.Left = node
} }
return cur
} }
``` ```
@ -396,12 +392,12 @@ comments: true
/* 插入节点 */ /* 插入节点 */
function insert(num) { function insert(num) {
// 若树为空，直接提前返回 // 若树为空，直接提前返回
if (root === null) return null; if (root === null) return;
let cur = root, pre = null; let cur = root, pre = null;
// 循环查找，越过叶节点后跳出 // 循环查找，越过叶节点后跳出
while (cur !== null) { while (cur !== null) {
// 找到重复节点，直接返回 // 找到重复节点，直接返回
if (cur.val === num) return null; if (cur.val === num) return;
pre = cur; pre = cur;
// 插入位置在 cur 的右子树中 // 插入位置在 cur 的右子树中
if (cur.val < num) cur = cur.right; if (cur.val < num) cur = cur.right;
@ -412,7 +408,6 @@ comments: true
let node = new TreeNode(num); let node = new TreeNode(num);
if (pre.val < num) pre.right = node; if (pre.val < num) pre.right = node;
else pre.left = node; else pre.left = node;
return node;
} }
``` ```
@ -420,17 +415,17 @@ comments: true
```typescript title="binary_search_tree.ts" ```typescript title="binary_search_tree.ts"
/* 插入节点 */ /* 插入节点 */
function insert(num: number): TreeNode | null { function insert(num: number): void {
// 若树为空，直接提前返回 // 若树为空，直接提前返回
if (root === null) { if (root === null) {
return null; return;
} }
let cur = root, let cur = root,
pre: TreeNode | null = null; pre: TreeNode | null = null;
// 循环查找，越过叶节点后跳出 // 循环查找，越过叶节点后跳出
while (cur !== null) { while (cur !== null) {
if (cur.val === num) { if (cur.val === num) {
return null; // 找到重复节点，直接返回 return; // 找到重复节点，直接返回
} }
pre = cur; pre = cur;
if (cur.val < num) { if (cur.val < num) {
@ -446,7 +441,6 @@ comments: true
} else { } else {
pre!.left = node; pre!.left = node;
} }
return node;
} }
``` ```
@ -460,16 +454,16 @@ comments: true
```csharp title="binary_search_tree.cs" ```csharp title="binary_search_tree.cs"
/* 插入节点 */ /* 插入节点 */
TreeNode? insert(int num) void insert(int num)
{ {
// 若树为空，直接提前返回 // 若树为空，直接提前返回
if (root == null) return null; if (root == null) return;
TreeNode? cur = root, pre = null; TreeNode? cur = root, pre = null;
// 循环查找，越过叶节点后跳出 // 循环查找，越过叶节点后跳出
while (cur != null) while (cur != null)
{ {
// 找到重复节点，直接返回 // 找到重复节点，直接返回
if (cur.val == num) return null; if (cur.val == num) return;
pre = cur; pre = cur;
// 插入位置在 cur 的右子树中 // 插入位置在 cur 的右子树中
if (cur.val < num) cur = cur.right; if (cur.val < num) cur = cur.right;
@ -484,7 +478,6 @@ comments: true
if (pre.val < num) pre.right = node; if (pre.val < num) pre.right = node;
else pre.left = node; else pre.left = node;
} }
return node;
} }
``` ```
@ -492,10 +485,10 @@ comments: true
```swift title="binary_search_tree.swift" ```swift title="binary_search_tree.swift"
/* 插入节点 */ /* 插入节点 */
func insert(num: Int) -> TreeNode? { func insert(num: Int) {
// 若树为空，直接提前返回 // 若树为空，直接提前返回
if root == nil { if root == nil {
return nil return
} }
var cur = root var cur = root
var pre: TreeNode? var pre: TreeNode?
@ -503,7 +496,7 @@ comments: true
while cur != nil { while cur != nil {
// 找到重复节点，直接返回 // 找到重复节点，直接返回
if cur!.val == num { if cur!.val == num {
return nil return
} }
pre = cur pre = cur
// 插入位置在 cur 的右子树中 // 插入位置在 cur 的右子树中
@ -522,7 +515,6 @@ comments: true
} else { } else {
pre?.left = node pre?.left = node
} }
return node
} }
``` ```
@ -530,15 +522,15 @@ comments: true
```zig title="binary_search_tree.zig" ```zig title="binary_search_tree.zig"
// 插入节点 // 插入节点
fn insert(self: *Self, num: T) !?*inc.TreeNode(T) { fn insert(self: *Self, num: T) !void {
// 若树为空，直接提前返回 // 若树为空，直接提前返回
if (self.root == null) return null; if (self.root == null) return;
var cur = self.root; var cur = self.root;
var pre: ?*inc.TreeNode(T) = null; var pre: ?*inc.TreeNode(T) = null;
// 循环查找，越过叶节点后跳出 // 循环查找，越过叶节点后跳出
while (cur != null) { while (cur != null) {
// 找到重复节点，直接返回 // 找到重复节点，直接返回
if (cur.?.val == num) return null; if (cur.?.val == num) return;
pre = cur; pre = cur;
// 插入位置在 cur 的右子树中 // 插入位置在 cur 的右子树中
if (cur.?.val < num) { if (cur.?.val < num) {
@ -556,7 +548,6 @@ comments: true
} else { } else {
pre.?.left = node; pre.?.left = node;
} }
return node;
} }
``` ```
@ -582,9 +573,9 @@ comments: true
当待删除节点的子节点数量 $= 2$ 时，删除操作分为三步： 当待删除节点的子节点数量 $= 2$ 时，删除操作分为三步：
1. 找到待删除节点在“中序遍历序列”中的下一个节点，记为 nex； 1. 找到待删除节点在“中序遍历序列”中的下一个节点，记为 `tmp` ；
2. 在树中递归删除节点 `nex` ； 2. 在树中递归删除节点 `tmp` ；
3. 使用 `nex` 替换待删除节点； 3. 用 `tmp` 的值覆盖待删除节点的值；
=== "<1>" === "<1>"
![bst_remove_case3_step1](binary_search_tree.assets/bst_remove_case3_step1.png) ![bst_remove_case3_step1](binary_search_tree.assets/bst_remove_case3_step1.png)
@ -604,10 +595,10 @@ comments: true
```java title="binary_search_tree.java" ```java title="binary_search_tree.java"
/* 删除节点 */ /* 删除节点 */
TreeNode remove(int num) { void remove(int num) {
// 若树为空，直接提前返回 // 若树为空，直接提前返回
if (root == null) if (root == null)
return null; return;
TreeNode cur = root, pre = null; TreeNode cur = root, pre = null;
// 循环查找，越过叶节点后跳出 // 循环查找，越过叶节点后跳出
while (cur != null) { while (cur != null) {
@ -624,7 +615,7 @@ comments: true
} }
// 若无待删除节点，则直接返回 // 若无待删除节点，则直接返回
if (cur == null) if (cur == null)
return null; return;
// 子节点数量 = 0 or 1 // 子节点数量 = 0 or 1
if (cur.left == null || cur.right == null) { if (cur.left == null || cur.right == null) {
// 当子节点数量 = 0 / 1 时， child = null / 该子节点 // 当子节点数量 = 0 / 1 时， child = null / 该子节点
@ -638,25 +629,15 @@ comments: true
// 子节点数量 = 2 // 子节点数量 = 2
else { else {
// 获取中序遍历中 cur 的下一个节点 // 获取中序遍历中 cur 的下一个节点
TreeNode nex = getInOrderNext(cur.right); TreeNode tmp = cur.right;
int tmp = nex.val; while (tmp.left != null) {
// 递归删除节点 nex tmp = tmp.left;
remove(nex.val); }
// 将 nex 的值复制给 cur // 递归删除节点 tmp
cur.val = tmp; remove(tmp.val);
// 用 tmp 覆盖 cur
cur.val = tmp.val;
} }
return cur;
}
/* 获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况） */
TreeNode getInOrderNext(TreeNode root) {
if (root == null)
return root;
// 循环访问左子节点，直到叶节点时为最小节点，跳出
while (root.left != null) {
root = root.left;
}
return root;
} }
``` ```
@ -664,10 +645,10 @@ comments: true
```cpp title="binary_search_tree.cpp" ```cpp title="binary_search_tree.cpp"
/* 删除节点 */ /* 删除节点 */
TreeNode *remove(int num) { void remove(int num) {
// 若树为空，直接提前返回 // 若树为空，直接提前返回
if (root == nullptr) if (root == nullptr)
return nullptr; return;
TreeNode *cur = root, *pre = nullptr; TreeNode *cur = root, *pre = nullptr;
// 循环查找，越过叶节点后跳出 // 循环查找，越过叶节点后跳出
while (cur != nullptr) { while (cur != nullptr) {
@ -684,7 +665,7 @@ comments: true
} }
// 若无待删除节点，则直接返回 // 若无待删除节点，则直接返回
if (cur == nullptr) if (cur == nullptr)
return nullptr; return;
// 子节点数量 = 0 or 1 // 子节点数量 = 0 or 1
if (cur->left == nullptr || cur->right == nullptr) { if (cur->left == nullptr || cur->right == nullptr) {
// 当子节点数量 = 0 / 1 时， child = nullptr / 该子节点 // 当子节点数量 = 0 / 1 时， child = nullptr / 该子节点
@ -700,36 +681,27 @@ comments: true
// 子节点数量 = 2 // 子节点数量 = 2
else { else {
// 获取中序遍历中 cur 的下一个节点 // 获取中序遍历中 cur 的下一个节点
TreeNode *nex = getInOrderNext(cur->right); TreeNode *tmp = cur->right;
int tmp = nex->val; while (tmp->left != nullptr) {
// 递归删除节点 nex tmp = tmp->left;
remove(nex->val); }
// 将 nex 的值复制给 cur int tmpVal = tmp->val;
cur->val = tmp; // 递归删除节点 tmp
remove(tmp->val);
// 用 tmp 覆盖 cur
cur->val = tmpVal;
} }
return cur;
}
/* 获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况） */
TreeNode *getInOrderNext(TreeNode *root) {
if (root == nullptr)
return root;
// 循环访问左子节点，直到叶节点时为最小节点，跳出
while (root->left != nullptr) {
root = root->left;
}
return root;
} }
``` ```
=== "Python" === "Python"
```python title="binary_search_tree.py" ```python title="binary_search_tree.py"
def remove(self, num: int) -> TreeNode | None: def remove(self, num: int) -> None:
"""删除节点""" """删除节点"""
# 若树为空，直接提前返回 # 若树为空，直接提前返回
if self.__root is None: if self.__root is None:
return None return
# 循环查找，越过叶节点后跳出 # 循环查找，越过叶节点后跳出
cur, pre = self.__root, None cur, pre = self.__root, None
@ -738,13 +710,15 @@ comments: true
if cur.val == num: if cur.val == num:
break break
pre = cur pre = cur
if cur.val < num: # 待删除节点在 cur 的右子树中 # 待删除节点在 cur 的右子树中
if cur.val < num:
cur = cur.right cur = cur.right
else: # 待删除节点在 cur 的左子树中 # 待删除节点在 cur 的左子树中
else:
cur = cur.left cur = cur.left
# 若无待删除节点，则直接返回 # 若无待删除节点，则直接返回
if cur is None: if cur is None:
return None return
# 子节点数量 = 0 or 1 # 子节点数量 = 0 or 1
if cur.left is None or cur.right is None: if cur.left is None or cur.right is None:
@ -758,33 +732,24 @@ comments: true
# 子节点数量 = 2 # 子节点数量 = 2
else: else:
# 获取中序遍历中 cur 的下一个节点 # 获取中序遍历中 cur 的下一个节点
nex: TreeNode = self.get_inorder_next(cur.right) tmp: TreeNode = cur.right
tmp: int = nex.val while tmp.left is not None:
# 递归删除节点 nex tmp = tmp.left
self.remove(nex.val) # 递归删除节点 tmp
# 将 nex 的值复制给 cur self.remove(tmp.val)
cur.val = tmp # 用 tmp 覆盖 cur
return cur cur.val = tmp.val
def get_inorder_next(self, root: TreeNode | None) -> TreeNode | None:
"""获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况）"""
if root is None:
return root
# 循环访问左子节点，直到叶节点时为最小节点，跳出
while root.left is not None:
root = root.left
return root
``` ```
=== "Go" === "Go"
```go title="binary_search_tree.go" ```go title="binary_search_tree.go"
/* 删除节点 */ /* 删除节点 */
func (bst *binarySearchTree) remove(num int) *TreeNode { func (bst *binarySearchTree) remove(num int) {
cur := bst.root cur := bst.root
// 若树为空，直接提前返回 // 若树为空，直接提前返回
if cur == nil { if cur == nil {
return nil return
} }
// 待删除节点之前的节点位置 // 待删除节点之前的节点位置
var pre *TreeNode = nil var pre *TreeNode = nil
@ -804,7 +769,7 @@ comments: true
} }
// 若无待删除节点，则直接返回 // 若无待删除节点，则直接返回
if cur == nil { if cur == nil {
return nil return
} }
// 子节点数为 0 或 1 // 子节点数为 0 或 1
if cur.Left == nil || cur.Right == nil { if cur.Left == nil || cur.Right == nil {
@ -824,26 +789,15 @@ comments: true
// 子节点数为 2 // 子节点数为 2
} else { } else {
// 获取中序遍历中待删除节点 cur 的下一个节点 // 获取中序遍历中待删除节点 cur 的下一个节点
next := bst.getInOrderNext(cur) tmp := cur.Right
temp := next.Val for tmp.Left != nil {
// 递归删除节点 next tmp = tmp.Left
bst.remove(next.Val) }
// 将 next 的值复制给 cur // 递归删除节点 tmp
cur.Val = temp bst.remove(tmp.Val)
// 用 tmp 覆盖 cur
cur.Val = tmp.Val
} }
return cur
}
/* 获取中序遍历的下一个节点（仅适用于 root 有左子节点的情况） */
func (bst *binarySearchTree) getInOrderNext(node *TreeNode) *TreeNode {
if node == nil {
return node
}
// 循环访问左子节点，直到叶节点时为最小节点，跳出
for node.Left != nil {
node = node.Left
}
return node
} }
``` ```
@ -853,7 +807,7 @@ comments: true
/* 删除节点 */ /* 删除节点 */
function remove(num) { function remove(num) {
// 若树为空，直接提前返回 // 若树为空，直接提前返回
if (root === null) return null; if (root === null) return;
let cur = root, pre = null; let cur = root, pre = null;
// 循环查找，越过叶节点后跳出 // 循环查找，越过叶节点后跳出
while (cur !== null) { while (cur !== null) {
@ -866,7 +820,7 @@ comments: true
else cur = cur.left; else cur = cur.left;
} }
// 若无待删除节点，则直接返回 // 若无待删除节点，则直接返回
if (cur === null) return null; if (cur === null) return;
// 子节点数量 = 0 or 1 // 子节点数量 = 0 or 1
if (cur.left === null || cur.right === null) { if (cur.left === null || cur.right === null) {
// 当子节点数量 = 0 / 1 时， child = null / 该子节点 // 当子节点数量 = 0 / 1 时， child = null / 该子节点
@ -878,24 +832,15 @@ comments: true
// 子节点数量 = 2 // 子节点数量 = 2
else { else {
// 获取中序遍历中 cur 的下一个节点 // 获取中序遍历中 cur 的下一个节点
let nex = getInOrderNext(cur.right); let tmp = cur.right;
let tmp = nex.val; while (tmp.left !== null) {
// 递归删除节点 nex tmp = tmp.left;
remove(nex.val); }
// 将 nex 的值复制给 cur // 递归删除节点 tmp
cur.val = tmp; remove(tmp.val);
// 用 tmp 覆盖 cur
cur.val = tmp.val;
} }
return cur;
}
/* 获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况） */
function getInOrderNext(root) {
if (root === null) return root;
// 循环访问左子节点，直到叶节点时为最小节点，跳出
while (root.left !== null) {
root = root.left;
}
return root;
} }
``` ```
@ -903,10 +848,10 @@ comments: true
```typescript title="binary_search_tree.ts" ```typescript title="binary_search_tree.ts"
/* 删除节点 */ /* 删除节点 */
function remove(num: number): TreeNode | null { function remove(num: number): void {
// 若树为空，直接提前返回 // 若树为空，直接提前返回
if (root === null) { if (root === null) {
return null; return;
} }
let cur = root, let cur = root,
pre: TreeNode | null = null; pre: TreeNode | null = null;
@ -925,7 +870,7 @@ comments: true
} }
// 若无待删除节点，则直接返回 // 若无待删除节点，则直接返回
if (cur === null) { if (cur === null) {
return null; return;
} }
// 子节点数量 = 0 or 1 // 子节点数量 = 0 or 1
if (cur.left === null || cur.right === null) { if (cur.left === null || cur.right === null) {
@ -941,26 +886,15 @@ comments: true
// 子节点数量 = 2 // 子节点数量 = 2
else { else {
// 获取中序遍历中 cur 的下一个节点 // 获取中序遍历中 cur 的下一个节点
let next = getInOrderNext(cur.right); let tmp = cur.right;
let tmp = next!.val; while (tmp.left !== null) {
// 递归删除节点 nex tmp = tmp.left;
remove(next!.val); }
// 将 nex 的值复制给 cur // 递归删除节点 tmp
cur.val = tmp; remove(tmp!.val);
// 用 tmp 覆盖 cur
cur.val = tmp.val;
} }
return cur;
}
/* 获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况） */
function getInOrderNext(root: TreeNode | null): TreeNode | null {
if (root === null) {
return null;
}
// 循环访问左子节点，直到叶节点时为最小节点，跳出
while (root.left !== null) {
root = root.left;
}
return root;
} }
``` ```
@ -968,18 +902,16 @@ comments: true
```c title="binary_search_tree.c" ```c title="binary_search_tree.c"
[class]{binarySearchTree}-[func]{remove} [class]{binarySearchTree}-[func]{remove}
[class]{binarySearchTree}-[func]{getInOrderNext}
``` ```
=== "C#" === "C#"
```csharp title="binary_search_tree.cs" ```csharp title="binary_search_tree.cs"
/* 删除节点 */ /* 删除节点 */
TreeNode? remove(int num) void remove(int num)
{ {
// 若树为空，直接提前返回 // 若树为空，直接提前返回
if (root == null) return null; if (root == null) return;
TreeNode? cur = root, pre = null; TreeNode? cur = root, pre = null;
// 循环查找，越过叶节点后跳出 // 循环查找，越过叶节点后跳出
while (cur != null) while (cur != null)
@ -993,7 +925,7 @@ comments: true
else cur = cur.left; else cur = cur.left;
} }
// 若无待删除节点，则直接返回 // 若无待删除节点，则直接返回
if (cur == null || pre == null) return null; if (cur == null || pre == null) return;
// 子节点数量 = 0 or 1 // 子节点数量 = 0 or 1
if (cur.left == null || cur.right == null) if (cur.left == null || cur.right == null)
{ {
@ -1013,29 +945,16 @@ comments: true
else else
{ {
// 获取中序遍历中 cur 的下一个节点 // 获取中序遍历中 cur 的下一个节点
TreeNode? nex = getInOrderNext(cur.right); TreeNode? tmp = cur.right;
if (nex != null) while (tmp.left != null)
{ {
int tmp = nex.val; tmp = tmp.left;
// 递归删除节点 nex
remove(nex.val);
// 将 nex 的值复制给 cur
cur.val = tmp;
} }
// 递归删除节点 tmp
remove(tmp.val);
// 用 tmp 覆盖 cur
cur.val = tmp.val;
} }
return cur;
}
/* 获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况） */
TreeNode? getInOrderNext(TreeNode? root)
{
if (root == null) return root;
// 循环访问左子节点，直到叶节点时为最小节点，跳出
while (root.left != null)
{
root = root.left;
}
return root;
} }
``` ```
@ -1044,10 +963,10 @@ comments: true
```swift title="binary_search_tree.swift" ```swift title="binary_search_tree.swift"
/* 删除节点 */ /* 删除节点 */
@discardableResult @discardableResult
func remove(num: Int) -> TreeNode? { func remove(num: Int) {
// 若树为空，直接提前返回 // 若树为空，直接提前返回
if root == nil { if root == nil {
return nil return
} }
var cur = root var cur = root
var pre: TreeNode? var pre: TreeNode?
@ -1069,7 +988,7 @@ comments: true
} }
// 若无待删除节点，则直接返回 // 若无待删除节点，则直接返回
if cur == nil { if cur == nil {
return nil return
} }
// 子节点数量 = 0 or 1 // 子节点数量 = 0 or 1
if cur?.left == nil || cur?.right == nil { if cur?.left == nil || cur?.right == nil {
@ -1085,27 +1004,15 @@ comments: true
// 子节点数量 = 2 // 子节点数量 = 2
else { else {
// 获取中序遍历中 cur 的下一个节点 // 获取中序遍历中 cur 的下一个节点
let nex = getInOrderNext(root: cur?.right) let tmp = cur?.right
let tmp = nex!.val while tmp?.left != nil {
// 递归删除节点 nex tmp = tmp?.left
remove(num: nex!.val) }
// 将 nex 的值复制给 cur // 递归删除节点 tmp
cur?.val = tmp remove(num: tmp!.val)
// 用 tmp 覆盖 cur
cur?.val = tmp!.val
} }
return cur
}
/* 获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况） */
func getInOrderNext(root: TreeNode?) -> TreeNode? {
var root = root
if root == nil {
return root
}
// 循环访问左子节点，直到叶节点时为最小节点，跳出
while root?.left != nil {
root = root?.left
}
return root
} }
``` ```
@ -1113,9 +1020,9 @@ comments: true
```zig title="binary_search_tree.zig" ```zig title="binary_search_tree.zig"
// 删除节点 // 删除节点
fn remove(self: *Self, num: T) ?*inc.TreeNode(T) { fn remove(self: *Self, num: T) !void {
// 若树为空，直接提前返回 // 若树为空，直接提前返回
if (self.root == null) return null; if (self.root == null) return;
var cur = self.root; var cur = self.root;
var pre: ?*inc.TreeNode(T) = null; var pre: ?*inc.TreeNode(T) = null;
// 循环查找，越过叶节点后跳出 // 循环查找，越过叶节点后跳出
@ -1132,7 +1039,7 @@ comments: true
} }
} }
// 若无待删除节点，则直接返回 // 若无待删除节点，则直接返回
if (cur == null) return null; if (cur == null) return;
// 子节点数量 = 0 or 1 // 子节点数量 = 0 or 1
if (cur.?.left == null or cur.?.right == null) { if (cur.?.left == null or cur.?.right == null) {
// 当子节点数量 = 0 / 1 时， child = null / 该子节点 // 当子节点数量 = 0 / 1 时， child = null / 该子节点
@ -1146,26 +1053,16 @@ comments: true
// 子节点数量 = 2 // 子节点数量 = 2
} else { } else {
// 获取中序遍历中 cur 的下一个节点 // 获取中序遍历中 cur 的下一个节点
var nex = self.getInOrderNext(cur.?.right); var tmp = cur.?.right;
var tmp = nex.?.val; while (tmp.?.left != null) {
// 递归删除节点 nex tmp = tmp.?.left;
_ = self.remove(nex.?.val); }
// 将 nex 的值复制给 cur var tmpVal = tmp.?.val;
cur.?.val = tmp; // 递归删除节点 tmp
_ = self.remove(tmp.?.val);
// 用 tmp 覆盖 cur
cur.?.val = tmpVal;
} }
return cur;
}
// 获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况）
fn getInOrderNext(self: *Self, node: ?*inc.TreeNode(T)) ?*inc.TreeNode(T) {
_ = self;
var node_tmp = node;
if (node_tmp == null) return null;
// 循环访问左子节点，直到叶节点时为最小节点，跳出
while (node_tmp.?.left != null) {
node_tmp = node_tmp.?.left;
}
return node_tmp;
} }
``` ```