mirror of
https://github.com/krahets/hello-algo.git
synced 2024-12-27 00:06:28 +08:00
build
This commit is contained in:
krahets
parent
4d318e8e6b
commit
3c1eacca7f
2 changed files with 188 additions and 383 deletions
|
|
@ -1196,9 +1196,8 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
|
||||
```java title="avl_tree.java"
|
||||
/* 插入节点 */
|
||||
TreeNode insert(int val) {
|
||||
void insert(int val) {
|
||||
root = insertHelper(root, val);
|
||||
return root;
|
||||
}
|
||||
|
||||
/* 递归插入节点（辅助方法） */
|
||||
|
|
@ -1224,9 +1223,8 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
|
||||
```cpp title="avl_tree.cpp"
|
||||
/* 插入节点 */
|
||||
TreeNode *insert(int val) {
|
||||
void insert(int val) {
|
||||
root = insertHelper(root, val);
|
||||
return root;
|
||||
}
|
||||
|
||||
/* 递归插入节点（辅助方法） */
|
||||
|
|
@ -1251,10 +1249,9 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
=== "Python"
|
||||
|
||||
```python title="avl_tree.py"
|
||||
def insert(self, val) -> TreeNode:
|
||||
def insert(self, val) -> None:
|
||||
"""插入节点"""
|
||||
self.__root = self.__insert_helper(self.__root, val)
|
||||
return self.__root
|
||||
|
||||
def __insert_helper(self, node: TreeNode | None, val: int) -> TreeNode:
|
||||
"""递归插入节点（辅助方法）"""
|
||||
|
|
@ -1278,9 +1275,8 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
|
||||
```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)
|
||||
return t.root
|
||||
}
|
||||
|
||||
/* 递归插入节点（辅助方法） */
|
||||
|
|
@ -1312,7 +1308,6 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
/* 插入节点 */
|
||||
insert(val) {
|
||||
this.root = this.#insertHelper(this.root, val);
|
||||
return this.root;
|
||||
}
|
||||
|
||||
/* 递归插入节点（辅助方法） */
|
||||
|
|
@ -1334,9 +1329,8 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
|
||||
```typescript title="avl_tree.ts"
|
||||
/* 插入节点 */
|
||||
insert(val: number): TreeNode {
|
||||
insert(val: number): void {
|
||||
this.root = this.insertHelper(this.root, val);
|
||||
return this.root;
|
||||
}
|
||||
|
||||
/* 递归插入节点（辅助方法） */
|
||||
|
|
@ -1370,10 +1364,9 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
|
||||
```csharp title="avl_tree.cs"
|
||||
/* 插入节点 */
|
||||
TreeNode? insert(int val)
|
||||
void insert(int val)
|
||||
{
|
||||
root = insertHelper(root, val);
|
||||
return root;
|
||||
}
|
||||
|
||||
/* 递归插入节点（辅助方法） */
|
||||
|
|
@ -1400,9 +1393,8 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
```swift title="avl_tree.swift"
|
||||
/* 插入节点 */
|
||||
@discardableResult
|
||||
func insert(val: Int) -> TreeNode? {
|
||||
func insert(val: Int) {
|
||||
root = insertHelper(node: root, val: val)
|
||||
return root
|
||||
}
|
||||
|
||||
/* 递归插入节点（辅助方法） */
|
||||
|
|
@ -1431,9 +1423,8 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
|
||||
```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);
|
||||
return self.root;
|
||||
}
|
||||
|
||||
// 递归插入节点（辅助方法）
|
||||
|
|
@ -1468,9 +1459,8 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
|
||||
```java title="avl_tree.java"
|
||||
/* 删除节点 */
|
||||
TreeNode remove(int val) {
|
||||
void remove(int val) {
|
||||
root = removeHelper(root, val);
|
||||
return root;
|
||||
}
|
||||
|
||||
/* 递归删除节点（辅助方法） */
|
||||
|
|
@ -1493,7 +1483,10 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
node = child;
|
||||
} else {
|
||||
// 子节点数量 = 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.val = temp.val;
|
||||
}
|
||||
|
|
@ -1504,26 +1497,14 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
// 返回子树的根节点
|
||||
return node;
|
||||
}
|
||||
|
||||
/* 获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况） */
|
||||
TreeNode getInOrderNext(TreeNode node) {
|
||||
if (node == null)
|
||||
return node;
|
||||
// 循环访问左子节点，直到叶节点时为最小节点，跳出
|
||||
while (node.left != null) {
|
||||
node = node.left;
|
||||
}
|
||||
return node;
|
||||
}
|
||||
```
|
||||
|
||||
=== "C++"
|
||||
|
||||
```cpp title="avl_tree.cpp"
|
||||
/* 删除节点 */
|
||||
TreeNode *remove(int val) {
|
||||
void remove(int val) {
|
||||
root = removeHelper(root, val);
|
||||
return root;
|
||||
}
|
||||
|
||||
/* 递归删除节点（辅助方法） */
|
||||
|
|
@ -1550,7 +1531,10 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
}
|
||||
} else {
|
||||
// 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
|
||||
TreeNode *temp = getInOrderNext(node->right);
|
||||
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;
|
||||
|
|
@ -1562,26 +1546,14 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
// 返回子树的根节点
|
||||
return node;
|
||||
}
|
||||
|
||||
/* 获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况） */
|
||||
TreeNode *getInOrderNext(TreeNode *node) {
|
||||
if (node == nullptr)
|
||||
return node;
|
||||
// 循环访问左子节点，直到叶节点时为最小节点，跳出
|
||||
while (node->left != nullptr) {
|
||||
node = node->left;
|
||||
}
|
||||
return node;
|
||||
}
|
||||
```
|
||||
|
||||
=== "Python"
|
||||
|
||||
```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)
|
||||
return self.__root
|
||||
|
||||
def __remove_helper(self, node: TreeNode | None, val: int) -> TreeNode | None:
|
||||
"""递归删除节点（辅助方法）"""
|
||||
|
|
@ -1601,32 +1573,25 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
# 子节点数量 = 1 ，直接删除 node
|
||||
else:
|
||||
node = child
|
||||
else: # 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
|
||||
temp = self.__get_inorder_next(node.right)
|
||||
else:
|
||||
# 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
|
||||
temp = node.right
|
||||
while temp.left is not None:
|
||||
temp = temp.left
|
||||
node.right = self.__remove_helper(node.right, temp.val)
|
||||
node.val = temp.val
|
||||
# 更新节点高度
|
||||
self.__update_height(node)
|
||||
# 2. 执行旋转操作，使该子树重新恢复平衡
|
||||
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 title="avl_tree.go"
|
||||
/* 删除节点 */
|
||||
func (t *aVLTree) remove(val int) *TreeNode {
|
||||
root := t.removeHelper(t.root, val)
|
||||
return root
|
||||
func (t *aVLTree) remove(val int) {
|
||||
t.root = t.removeHelper(t.root, val)
|
||||
}
|
||||
|
||||
/* 递归删除节点（辅助方法） */
|
||||
|
|
@ -1645,8 +1610,8 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
if node.Right != nil {
|
||||
child = node.Right
|
||||
}
|
||||
// 子节点数量 = 0 ，直接删除 node 并返回
|
||||
if child == nil {
|
||||
// 子节点数量 = 0 ，直接删除 node 并返回
|
||||
return nil
|
||||
} else {
|
||||
// 子节点数量 = 1 ，直接删除 node
|
||||
|
|
@ -1654,7 +1619,10 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
}
|
||||
} else {
|
||||
// 子节点数量 = 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.Val = temp.Val
|
||||
}
|
||||
|
|
@ -1666,18 +1634,6 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
// 返回子树的根节点
|
||||
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"
|
||||
|
|
@ -1686,7 +1642,6 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
/* 删除节点 */
|
||||
remove(val) {
|
||||
this.root = this.#removeHelper(this.root, val);
|
||||
return this.root;
|
||||
}
|
||||
|
||||
/* 递归删除节点（辅助方法） */
|
||||
|
|
@ -1704,7 +1659,10 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
else node = child;
|
||||
} else {
|
||||
// 子节点数量 = 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.val = temp.val;
|
||||
}
|
||||
|
|
@ -1715,25 +1673,14 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
// 返回子树的根节点
|
||||
return node;
|
||||
}
|
||||
|
||||
/* 获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况） */
|
||||
#getInOrderNext(node) {
|
||||
if (node === null) return node;
|
||||
// 循环访问左子节点，直到叶节点时为最小节点，跳出
|
||||
while (node.left !== null) {
|
||||
node = node.left;
|
||||
}
|
||||
return node;
|
||||
}
|
||||
```
|
||||
|
||||
=== "TypeScript"
|
||||
|
||||
```typescript title="avl_tree.ts"
|
||||
/* 删除节点 */
|
||||
remove(val: number): TreeNode {
|
||||
remove(val: number): void {
|
||||
this.root = this.removeHelper(this.root, val);
|
||||
return this.root;
|
||||
}
|
||||
|
||||
/* 递归删除节点（辅助方法） */
|
||||
|
|
@ -1756,7 +1703,10 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
}
|
||||
} else {
|
||||
// 子节点数量 = 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.val = temp.val;
|
||||
}
|
||||
|
|
@ -1767,16 +1717,6 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
// 返回子树的根节点
|
||||
return node;
|
||||
}
|
||||
|
||||
/* 获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况） */
|
||||
getInOrderNext(node: TreeNode): TreeNode {
|
||||
if (node === null) return node;
|
||||
// 循环访问左子节点，直到叶节点时为最小节点，跳出
|
||||
while (node.left !== null) {
|
||||
node = node.left;
|
||||
}
|
||||
return node;
|
||||
}
|
||||
```
|
||||
|
||||
=== "C"
|
||||
|
|
@ -1785,18 +1725,15 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
[class]{aVLTree}-[func]{remove}
|
||||
|
||||
[class]{aVLTree}-[func]{removeHelper}
|
||||
|
||||
[class]{aVLTree}-[func]{getInOrderNext}
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
```csharp title="avl_tree.cs"
|
||||
/* 删除节点 */
|
||||
TreeNode? remove(int val)
|
||||
void remove(int val)
|
||||
{
|
||||
root = removeHelper(root, val);
|
||||
return root;
|
||||
}
|
||||
|
||||
/* 递归删除节点（辅助方法） */
|
||||
|
|
@ -1823,7 +1760,11 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
else
|
||||
{
|
||||
// 子节点数量 = 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.val = temp.val;
|
||||
}
|
||||
|
|
@ -1834,18 +1775,6 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
// 返回子树的根节点
|
||||
return node;
|
||||
}
|
||||
|
||||
/* 获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况） */
|
||||
TreeNode? getInOrderNext(TreeNode? node)
|
||||
{
|
||||
if (node == null) return node;
|
||||
// 循环访问左子节点，直到叶节点时为最小节点，跳出
|
||||
while (node.left != null)
|
||||
{
|
||||
node = node.left;
|
||||
}
|
||||
return node;
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
|
@ -1853,9 +1782,8 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
```swift title="avl_tree.swift"
|
||||
/* 删除节点 */
|
||||
@discardableResult
|
||||
func remove(val: Int) -> TreeNode? {
|
||||
func remove(val: Int) {
|
||||
root = removeHelper(node: root, val: val)
|
||||
return root
|
||||
}
|
||||
|
||||
/* 递归删除节点（辅助方法） */
|
||||
|
|
@ -1882,7 +1810,10 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
}
|
||||
} else {
|
||||
// 子节点数量 = 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?.val = temp!.val
|
||||
}
|
||||
|
|
@ -1893,28 +1824,14 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
// 返回子树的根节点
|
||||
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 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);
|
||||
return self.root;
|
||||
}
|
||||
|
||||
// 递归删除节点（辅助方法）
|
||||
|
|
@ -1938,7 +1855,10 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
}
|
||||
} else {
|
||||
// 子节点数量 = 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.?.val = temp.?.val;
|
||||
}
|
||||
|
|
@ -1949,18 +1869,6 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
|
|||
// 返回子树的根节点
|
||||
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;
|
||||
}
|
||||
```
|
||||
|
||||
### 查找节点
|
||||
|
|
|
|||
|
|
@ -263,16 +263,16 @@ comments: true
|
|||
|
||||
```java title="binary_search_tree.java"
|
||||
/* 插入节点 */
|
||||
TreeNode insert(int num) {
|
||||
void insert(int num) {
|
||||
// 若树为空，直接提前返回
|
||||
if (root == null)
|
||||
return null;
|
||||
return;
|
||||
TreeNode cur = root, pre = null;
|
||||
// 循环查找，越过叶节点后跳出
|
||||
while (cur != null) {
|
||||
// 找到重复节点，直接返回
|
||||
if (cur.val == num)
|
||||
return null;
|
||||
return;
|
||||
pre = cur;
|
||||
// 插入位置在 cur 的右子树中
|
||||
if (cur.val < num)
|
||||
|
|
@ -287,7 +287,6 @@ comments: true
|
|||
pre.right = node;
|
||||
else
|
||||
pre.left = node;
|
||||
return node;
|
||||
}
|
||||
```
|
||||
|
||||
|
|
@ -295,16 +294,16 @@ comments: true
|
|||
|
||||
```cpp title="binary_search_tree.cpp"
|
||||
/* 插入节点 */
|
||||
TreeNode *insert(int num) {
|
||||
void insert(int num) {
|
||||
// 若树为空，直接提前返回
|
||||
if (root == nullptr)
|
||||
return nullptr;
|
||||
return;
|
||||
TreeNode *cur = root, *pre = nullptr;
|
||||
// 循环查找，越过叶节点后跳出
|
||||
while (cur != nullptr) {
|
||||
// 找到重复节点，直接返回
|
||||
if (cur->val == num)
|
||||
return nullptr;
|
||||
return;
|
||||
pre = cur;
|
||||
// 插入位置在 cur 的右子树中
|
||||
if (cur->val < num)
|
||||
|
|
@ -319,25 +318,24 @@ comments: true
|
|||
pre->right = node;
|
||||
else
|
||||
pre->left = node;
|
||||
return node;
|
||||
}
|
||||
```
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python title="binary_search_tree.py"
|
||||
def insert(self, num: int) -> TreeNode | None:
|
||||
def insert(self, num: int) -> None:
|
||||
"""插入节点"""
|
||||
# 若树为空，直接提前返回
|
||||
if self.__root is None:
|
||||
return None
|
||||
return
|
||||
|
||||
# 循环查找，越过叶节点后跳出
|
||||
cur, pre = self.__root, None
|
||||
while cur is not None:
|
||||
# 找到重复节点，直接返回
|
||||
if cur.val == num:
|
||||
return None
|
||||
return
|
||||
pre = cur
|
||||
# 插入位置在 cur 的右子树中
|
||||
if cur.val < num:
|
||||
|
|
@ -352,25 +350,24 @@ comments: true
|
|||
pre.right = node
|
||||
else:
|
||||
pre.left = node
|
||||
return node
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
|
||||
```go title="binary_search_tree.go"
|
||||
/* 插入节点 */
|
||||
func (bst *binarySearchTree) insert(num int) *TreeNode {
|
||||
func (bst *binarySearchTree) insert(num int) {
|
||||
cur := bst.root
|
||||
// 若树为空，直接提前返回
|
||||
if cur == nil {
|
||||
return nil
|
||||
return
|
||||
}
|
||||
// 待插入节点之前的节点位置
|
||||
var pre *TreeNode = nil
|
||||
// 循环查找，越过叶节点后跳出
|
||||
for cur != nil {
|
||||
if cur.Val == num {
|
||||
return nil
|
||||
return
|
||||
}
|
||||
pre = cur
|
||||
if cur.Val < num {
|
||||
|
|
@ -386,7 +383,6 @@ comments: true
|
|||
} else {
|
||||
pre.Left = node
|
||||
}
|
||||
return cur
|
||||
}
|
||||
```
|
||||
|
||||
|
|
@ -396,12 +392,12 @@ comments: true
|
|||
/* 插入节点 */
|
||||
function insert(num) {
|
||||
// 若树为空，直接提前返回
|
||||
if (root === null) return null;
|
||||
if (root === null) return;
|
||||
let cur = root, pre = null;
|
||||
// 循环查找，越过叶节点后跳出
|
||||
while (cur !== null) {
|
||||
// 找到重复节点，直接返回
|
||||
if (cur.val === num) return null;
|
||||
if (cur.val === num) return;
|
||||
pre = cur;
|
||||
// 插入位置在 cur 的右子树中
|
||||
if (cur.val < num) cur = cur.right;
|
||||
|
|
@ -412,7 +408,6 @@ comments: true
|
|||
let node = new TreeNode(num);
|
||||
if (pre.val < num) pre.right = node;
|
||||
else pre.left = node;
|
||||
return node;
|
||||
}
|
||||
```
|
||||
|
||||
|
|
@ -420,17 +415,17 @@ comments: true
|
|||
|
||||
```typescript title="binary_search_tree.ts"
|
||||
/* 插入节点 */
|
||||
function insert(num: number): TreeNode | null {
|
||||
function insert(num: number): void {
|
||||
// 若树为空，直接提前返回
|
||||
if (root === null) {
|
||||
return null;
|
||||
return;
|
||||
}
|
||||
let cur = root,
|
||||
pre: TreeNode | null = null;
|
||||
// 循环查找，越过叶节点后跳出
|
||||
while (cur !== null) {
|
||||
if (cur.val === num) {
|
||||
return null; // 找到重复节点，直接返回
|
||||
return; // 找到重复节点，直接返回
|
||||
}
|
||||
pre = cur;
|
||||
if (cur.val < num) {
|
||||
|
|
@ -446,7 +441,6 @@ comments: true
|
|||
} else {
|
||||
pre!.left = node;
|
||||
}
|
||||
return node;
|
||||
}
|
||||
```
|
||||
|
||||
|
|
@ -460,16 +454,16 @@ comments: true
|
|||
|
||||
```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;
|
||||
// 循环查找，越过叶节点后跳出
|
||||
while (cur != null)
|
||||
{
|
||||
// 找到重复节点，直接返回
|
||||
if (cur.val == num) return null;
|
||||
if (cur.val == num) return;
|
||||
pre = cur;
|
||||
// 插入位置在 cur 的右子树中
|
||||
if (cur.val < num) cur = cur.right;
|
||||
|
|
@ -484,7 +478,6 @@ comments: true
|
|||
if (pre.val < num) pre.right = node;
|
||||
else pre.left = node;
|
||||
}
|
||||
return node;
|
||||
}
|
||||
```
|
||||
|
||||
|
|
@ -492,10 +485,10 @@ comments: true
|
|||
|
||||
```swift title="binary_search_tree.swift"
|
||||
/* 插入节点 */
|
||||
func insert(num: Int) -> TreeNode? {
|
||||
func insert(num: Int) {
|
||||
// 若树为空，直接提前返回
|
||||
if root == nil {
|
||||
return nil
|
||||
return
|
||||
}
|
||||
var cur = root
|
||||
var pre: TreeNode?
|
||||
|
|
@ -503,7 +496,7 @@ comments: true
|
|||
while cur != nil {
|
||||
// 找到重复节点，直接返回
|
||||
if cur!.val == num {
|
||||
return nil
|
||||
return
|
||||
}
|
||||
pre = cur
|
||||
// 插入位置在 cur 的右子树中
|
||||
|
|
@ -522,7 +515,6 @@ comments: true
|
|||
} else {
|
||||
pre?.left = node
|
||||
}
|
||||
return node
|
||||
}
|
||||
```
|
||||
|
||||
|
|
@ -530,15 +522,15 @@ comments: true
|
|||
|
||||
```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 pre: ?*inc.TreeNode(T) = null;
|
||||
// 循环查找，越过叶节点后跳出
|
||||
while (cur != null) {
|
||||
// 找到重复节点，直接返回
|
||||
if (cur.?.val == num) return null;
|
||||
if (cur.?.val == num) return;
|
||||
pre = cur;
|
||||
// 插入位置在 cur 的右子树中
|
||||
if (cur.?.val < num) {
|
||||
|
|
@ -556,7 +548,6 @@ comments: true
|
|||
} else {
|
||||
pre.?.left = node;
|
||||
}
|
||||
return node;
|
||||
}
|
||||
```
|
||||
|
||||
|
|
@ -582,9 +573,9 @@ comments: true
|
|||
|
||||
当待删除节点的子节点数量 $= 2$ 时，删除操作分为三步：
|
||||
|
||||
1. 找到待删除节点在“中序遍历序列”中的下一个节点，记为 nex；
|
||||
2. 在树中递归删除节点 `nex` ；
|
||||
3. 使用 `nex` 替换待删除节点；
|
||||
1. 找到待删除节点在“中序遍历序列”中的下一个节点，记为 `tmp` ；
|
||||
2. 在树中递归删除节点 `tmp` ；
|
||||
3. 用 `tmp` 的值覆盖待删除节点的值；
|
||||
|
||||
=== "<1>"
|
||||
|
||||
|
|
@ -604,10 +595,10 @@ comments: true
|
|||
|
||||
```java title="binary_search_tree.java"
|
||||
/* 删除节点 */
|
||||
TreeNode remove(int num) {
|
||||
void remove(int num) {
|
||||
// 若树为空，直接提前返回
|
||||
if (root == null)
|
||||
return null;
|
||||
return;
|
||||
TreeNode cur = root, pre = null;
|
||||
// 循环查找，越过叶节点后跳出
|
||||
while (cur != null) {
|
||||
|
|
@ -624,7 +615,7 @@ comments: true
|
|||
}
|
||||
// 若无待删除节点，则直接返回
|
||||
if (cur == null)
|
||||
return null;
|
||||
return;
|
||||
// 子节点数量 = 0 or 1
|
||||
if (cur.left == null || cur.right == null) {
|
||||
// 当子节点数量 = 0 / 1 时， child = null / 该子节点
|
||||
|
|
@ -638,25 +629,15 @@ comments: true
|
|||
// 子节点数量 = 2
|
||||
else {
|
||||
// 获取中序遍历中 cur 的下一个节点
|
||||
TreeNode nex = getInOrderNext(cur.right);
|
||||
int tmp = nex.val;
|
||||
// 递归删除节点 nex
|
||||
remove(nex.val);
|
||||
// 将 nex 的值复制给 cur
|
||||
cur.val = tmp;
|
||||
TreeNode tmp = cur.right;
|
||||
while (tmp.left != null) {
|
||||
tmp = tmp.left;
|
||||
}
|
||||
return cur;
|
||||
// 递归删除节点 tmp
|
||||
remove(tmp.val);
|
||||
// 用 tmp 覆盖 cur
|
||||
cur.val = tmp.val;
|
||||
}
|
||||
|
||||
/* 获取中序遍历中的下一个节点（仅适用于 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"
|
||||
/* 删除节点 */
|
||||
TreeNode *remove(int num) {
|
||||
void remove(int num) {
|
||||
// 若树为空，直接提前返回
|
||||
if (root == nullptr)
|
||||
return nullptr;
|
||||
return;
|
||||
TreeNode *cur = root, *pre = nullptr;
|
||||
// 循环查找，越过叶节点后跳出
|
||||
while (cur != nullptr) {
|
||||
|
|
@ -684,7 +665,7 @@ comments: true
|
|||
}
|
||||
// 若无待删除节点，则直接返回
|
||||
if (cur == nullptr)
|
||||
return nullptr;
|
||||
return;
|
||||
// 子节点数量 = 0 or 1
|
||||
if (cur->left == nullptr || cur->right == nullptr) {
|
||||
// 当子节点数量 = 0 / 1 时， child = nullptr / 该子节点
|
||||
|
|
@ -700,36 +681,27 @@ comments: true
|
|||
// 子节点数量 = 2
|
||||
else {
|
||||
// 获取中序遍历中 cur 的下一个节点
|
||||
TreeNode *nex = getInOrderNext(cur->right);
|
||||
int tmp = nex->val;
|
||||
// 递归删除节点 nex
|
||||
remove(nex->val);
|
||||
// 将 nex 的值复制给 cur
|
||||
cur->val = tmp;
|
||||
TreeNode *tmp = cur->right;
|
||||
while (tmp->left != nullptr) {
|
||||
tmp = tmp->left;
|
||||
}
|
||||
return cur;
|
||||
int tmpVal = tmp->val;
|
||||
// 递归删除节点 tmp
|
||||
remove(tmp->val);
|
||||
// 用 tmp 覆盖 cur
|
||||
cur->val = tmpVal;
|
||||
}
|
||||
|
||||
/* 获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况） */
|
||||
TreeNode *getInOrderNext(TreeNode *root) {
|
||||
if (root == nullptr)
|
||||
return root;
|
||||
// 循环访问左子节点，直到叶节点时为最小节点，跳出
|
||||
while (root->left != nullptr) {
|
||||
root = root->left;
|
||||
}
|
||||
return root;
|
||||
}
|
||||
```
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python title="binary_search_tree.py"
|
||||
def remove(self, num: int) -> TreeNode | None:
|
||||
def remove(self, num: int) -> None:
|
||||
"""删除节点"""
|
||||
# 若树为空，直接提前返回
|
||||
if self.__root is None:
|
||||
return None
|
||||
return
|
||||
|
||||
# 循环查找，越过叶节点后跳出
|
||||
cur, pre = self.__root, None
|
||||
|
|
@ -738,13 +710,15 @@ comments: true
|
|||
if cur.val == num:
|
||||
break
|
||||
pre = cur
|
||||
if cur.val < num: # 待删除节点在 cur 的右子树中
|
||||
# 待删除节点在 cur 的右子树中
|
||||
if cur.val < num:
|
||||
cur = cur.right
|
||||
else: # 待删除节点在 cur 的左子树中
|
||||
# 待删除节点在 cur 的左子树中
|
||||
else:
|
||||
cur = cur.left
|
||||
# 若无待删除节点，则直接返回
|
||||
if cur is None:
|
||||
return None
|
||||
return
|
||||
|
||||
# 子节点数量 = 0 or 1
|
||||
if cur.left is None or cur.right is None:
|
||||
|
|
@ -758,33 +732,24 @@ comments: true
|
|||
# 子节点数量 = 2
|
||||
else:
|
||||
# 获取中序遍历中 cur 的下一个节点
|
||||
nex: TreeNode = self.get_inorder_next(cur.right)
|
||||
tmp: int = nex.val
|
||||
# 递归删除节点 nex
|
||||
self.remove(nex.val)
|
||||
# 将 nex 的值复制给 cur
|
||||
cur.val = tmp
|
||||
return cur
|
||||
|
||||
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
|
||||
tmp: TreeNode = cur.right
|
||||
while tmp.left is not None:
|
||||
tmp = tmp.left
|
||||
# 递归删除节点 tmp
|
||||
self.remove(tmp.val)
|
||||
# 用 tmp 覆盖 cur
|
||||
cur.val = tmp.val
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
|
||||
```go title="binary_search_tree.go"
|
||||
/* 删除节点 */
|
||||
func (bst *binarySearchTree) remove(num int) *TreeNode {
|
||||
func (bst *binarySearchTree) remove(num int) {
|
||||
cur := bst.root
|
||||
// 若树为空，直接提前返回
|
||||
if cur == nil {
|
||||
return nil
|
||||
return
|
||||
}
|
||||
// 待删除节点之前的节点位置
|
||||
var pre *TreeNode = nil
|
||||
|
|
@ -804,7 +769,7 @@ comments: true
|
|||
}
|
||||
// 若无待删除节点，则直接返回
|
||||
if cur == nil {
|
||||
return nil
|
||||
return
|
||||
}
|
||||
// 子节点数为 0 或 1
|
||||
if cur.Left == nil || cur.Right == nil {
|
||||
|
|
@ -824,26 +789,15 @@ comments: true
|
|||
// 子节点数为 2
|
||||
} else {
|
||||
// 获取中序遍历中待删除节点 cur 的下一个节点
|
||||
next := bst.getInOrderNext(cur)
|
||||
temp := next.Val
|
||||
// 递归删除节点 next
|
||||
bst.remove(next.Val)
|
||||
// 将 next 的值复制给 cur
|
||||
cur.Val = temp
|
||||
tmp := cur.Right
|
||||
for tmp.Left != nil {
|
||||
tmp = tmp.Left
|
||||
}
|
||||
return cur
|
||||
// 递归删除节点 tmp
|
||||
bst.remove(tmp.Val)
|
||||
// 用 tmp 覆盖 cur
|
||||
cur.Val = tmp.Val
|
||||
}
|
||||
|
||||
/* 获取中序遍历的下一个节点（仅适用于 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) {
|
||||
// 若树为空，直接提前返回
|
||||
if (root === null) return null;
|
||||
if (root === null) return;
|
||||
let cur = root, pre = null;
|
||||
// 循环查找，越过叶节点后跳出
|
||||
while (cur !== null) {
|
||||
|
|
@ -866,7 +820,7 @@ comments: true
|
|||
else cur = cur.left;
|
||||
}
|
||||
// 若无待删除节点，则直接返回
|
||||
if (cur === null) return null;
|
||||
if (cur === null) return;
|
||||
// 子节点数量 = 0 or 1
|
||||
if (cur.left === null || cur.right === null) {
|
||||
// 当子节点数量 = 0 / 1 时， child = null / 该子节点
|
||||
|
|
@ -878,24 +832,15 @@ comments: true
|
|||
// 子节点数量 = 2
|
||||
else {
|
||||
// 获取中序遍历中 cur 的下一个节点
|
||||
let nex = getInOrderNext(cur.right);
|
||||
let tmp = nex.val;
|
||||
// 递归删除节点 nex
|
||||
remove(nex.val);
|
||||
// 将 nex 的值复制给 cur
|
||||
cur.val = tmp;
|
||||
let tmp = cur.right;
|
||||
while (tmp.left !== null) {
|
||||
tmp = tmp.left;
|
||||
}
|
||||
return cur;
|
||||
// 递归删除节点 tmp
|
||||
remove(tmp.val);
|
||||
// 用 tmp 覆盖 cur
|
||||
cur.val = tmp.val;
|
||||
}
|
||||
|
||||
/* 获取中序遍历中的下一个节点（仅适用于 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"
|
||||
/* 删除节点 */
|
||||
function remove(num: number): TreeNode | null {
|
||||
function remove(num: number): void {
|
||||
// 若树为空，直接提前返回
|
||||
if (root === null) {
|
||||
return null;
|
||||
return;
|
||||
}
|
||||
let cur = root,
|
||||
pre: TreeNode | null = null;
|
||||
|
|
@ -925,7 +870,7 @@ comments: true
|
|||
}
|
||||
// 若无待删除节点，则直接返回
|
||||
if (cur === null) {
|
||||
return null;
|
||||
return;
|
||||
}
|
||||
// 子节点数量 = 0 or 1
|
||||
if (cur.left === null || cur.right === null) {
|
||||
|
|
@ -941,26 +886,15 @@ comments: true
|
|||
// 子节点数量 = 2
|
||||
else {
|
||||
// 获取中序遍历中 cur 的下一个节点
|
||||
let next = getInOrderNext(cur.right);
|
||||
let tmp = next!.val;
|
||||
// 递归删除节点 nex
|
||||
remove(next!.val);
|
||||
// 将 nex 的值复制给 cur
|
||||
cur.val = tmp;
|
||||
let tmp = cur.right;
|
||||
while (tmp.left !== null) {
|
||||
tmp = tmp.left;
|
||||
}
|
||||
return cur;
|
||||
// 递归删除节点 tmp
|
||||
remove(tmp!.val);
|
||||
// 用 tmp 覆盖 cur
|
||||
cur.val = tmp.val;
|
||||
}
|
||||
|
||||
/* 获取中序遍历中的下一个节点（仅适用于 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"
|
||||
[class]{binarySearchTree}-[func]{remove}
|
||||
|
||||
[class]{binarySearchTree}-[func]{getInOrderNext}
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
```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;
|
||||
// 循环查找，越过叶节点后跳出
|
||||
while (cur != null)
|
||||
|
|
@ -993,7 +925,7 @@ comments: true
|
|||
else cur = cur.left;
|
||||
}
|
||||
// 若无待删除节点，则直接返回
|
||||
if (cur == null || pre == null) return null;
|
||||
if (cur == null || pre == null) return;
|
||||
// 子节点数量 = 0 or 1
|
||||
if (cur.left == null || cur.right == null)
|
||||
{
|
||||
|
|
@ -1013,29 +945,16 @@ comments: true
|
|||
else
|
||||
{
|
||||
// 获取中序遍历中 cur 的下一个节点
|
||||
TreeNode? nex = getInOrderNext(cur.right);
|
||||
if (nex != null)
|
||||
TreeNode? tmp = cur.right;
|
||||
while (tmp.left != null)
|
||||
{
|
||||
int tmp = nex.val;
|
||||
// 递归删除节点 nex
|
||||
remove(nex.val);
|
||||
// 将 nex 的值复制给 cur
|
||||
cur.val = tmp;
|
||||
tmp = tmp.left;
|
||||
}
|
||||
// 递归删除节点 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"
|
||||
/* 删除节点 */
|
||||
@discardableResult
|
||||
func remove(num: Int) -> TreeNode? {
|
||||
func remove(num: Int) {
|
||||
// 若树为空，直接提前返回
|
||||
if root == nil {
|
||||
return nil
|
||||
return
|
||||
}
|
||||
var cur = root
|
||||
var pre: TreeNode?
|
||||
|
|
@ -1069,7 +988,7 @@ comments: true
|
|||
}
|
||||
// 若无待删除节点，则直接返回
|
||||
if cur == nil {
|
||||
return nil
|
||||
return
|
||||
}
|
||||
// 子节点数量 = 0 or 1
|
||||
if cur?.left == nil || cur?.right == nil {
|
||||
|
|
@ -1085,27 +1004,15 @@ comments: true
|
|||
// 子节点数量 = 2
|
||||
else {
|
||||
// 获取中序遍历中 cur 的下一个节点
|
||||
let nex = getInOrderNext(root: cur?.right)
|
||||
let tmp = nex!.val
|
||||
// 递归删除节点 nex
|
||||
remove(num: nex!.val)
|
||||
// 将 nex 的值复制给 cur
|
||||
cur?.val = tmp
|
||||
let tmp = cur?.right
|
||||
while tmp?.left != nil {
|
||||
tmp = tmp?.left
|
||||
}
|
||||
return cur
|
||||
// 递归删除节点 tmp
|
||||
remove(num: tmp!.val)
|
||||
// 用 tmp 覆盖 cur
|
||||
cur?.val = tmp!.val
|
||||
}
|
||||
|
||||
/* 获取中序遍历中的下一个节点（仅适用于 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"
|
||||
// 删除节点
|
||||
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 pre: ?*inc.TreeNode(T) = null;
|
||||
// 循环查找，越过叶节点后跳出
|
||||
|
|
@ -1132,7 +1039,7 @@ comments: true
|
|||
}
|
||||
}
|
||||
// 若无待删除节点，则直接返回
|
||||
if (cur == null) return null;
|
||||
if (cur == null) return;
|
||||
// 子节点数量 = 0 or 1
|
||||
if (cur.?.left == null or cur.?.right == null) {
|
||||
// 当子节点数量 = 0 / 1 时， child = null / 该子节点
|
||||
|
|
@ -1146,26 +1053,16 @@ comments: true
|
|||
// 子节点数量 = 2
|
||||
} else {
|
||||
// 获取中序遍历中 cur 的下一个节点
|
||||
var nex = self.getInOrderNext(cur.?.right);
|
||||
var tmp = nex.?.val;
|
||||
// 递归删除节点 nex
|
||||
_ = self.remove(nex.?.val);
|
||||
// 将 nex 的值复制给 cur
|
||||
cur.?.val = tmp;
|
||||
var tmp = cur.?.right;
|
||||
while (tmp.?.left != null) {
|
||||
tmp = tmp.?.left;
|
||||
}
|
||||
return cur;
|
||||
var tmpVal = tmp.?.val;
|
||||
// 递归删除节点 tmp
|
||||
_ = self.remove(tmp.?.val);
|
||||
// 用 tmp 覆盖 cur
|
||||
cur.?.val = tmpVal;
|
||||
}
|
||||
|
||||
// 获取中序遍历中的下一个节点（仅适用于 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;
|
||||
}
|
||||
```
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue