删除二叉树的节点完整测试代码

核心代码：

## 递归法
def deleteNode(root, key):
    
    if root is None:
        return root
    if root.val == key:
        if root.left is None and root.right is None:
            return None
        elif root.left is None:
            return root.right
        elif root.right is None:
            return root.left
        else:
            cur = root.right
            while cur.left is not None:
                cur = cur.left
            cur.left = root.left
            return root.right

    if root.val > key:
        root.left = deleteNode(root.left, key)
    if root.val < key:
        root.right = deleteNode(root.right, key)
    return root

如果不理解的话好好看一下递归是怎么进行的

或者举例理解

比如输入

# 50,30,60,20,40,null,70,null,null,35,45
# key = 30

输出为

完整运行代码

from collections import deque
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right


def deleteNode(root, key):
    a = root.val
    if root is None:
        return root
    if root.val == key:
        if root.left is None and root.right is None:
            return None
        elif root.left is None:
            return root.right
        elif root.right is None:
            return root.left
        else:
            cur = root.right
            while cur.left is not None:
                cur = cur.left
            cur.left = root.left
            return root.right
    if root.val > key:
        root.left = deleteNode(root.left, key)
    if root.val < key:
        root.right = deleteNode(root.right, key)
    return root

def build_tree(nodes, index):
    if index < len(nodes):
        if nodes[index] is None:
            return None
        node = TreeNode(nodes[index])
        node.left = build_tree(nodes, 2 * index + 1)
        node.right = build_tree(nodes, 2 * index + 2)
        return node
    return None


# 从键盘输入构建二叉树，输入格式为节点值的列表，例如: [5,3,6,2,4,null,7]
input_str = input("请输入二叉树节点值列表（使用逗号分隔，null表示空节点）: ")
nodes = [None if val == 'null' else int(val) for val in input_str.split(',')]
root = build_tree(nodes, 0)

# 输入要删除的节点值
key = int(input("请输入要删除的节点值: "))

# 删除节点并打印结果
new_root = deleteNode(root, key)
print("删除节点后的二叉搜索树:")
# 这里可以编写遍历打印二叉树的函数，以显示结果

#################################### 下面是前中后序打印的函数

def preorder_traversal(root):
    if root is None:
        return []
    result = []
    result.append(root.val)
    result.extend(preorder_traversal(root.left))
    result.extend(preorder_traversal(root.right))
    return result
def inorder_traversal(root):
    if root is None:
        return []
    result = []
    result.extend(inorder_traversal(root.left))
    result.append(root.val)
    result.extend(inorder_traversal(root.right))
    return result
def postorder_traversal(root):
    if root is None:
        return []
    result = []
    result.extend(postorder_traversal(root.left))
    result.extend(postorder_traversal(root.right))
    result.append(root.val)
    return result

# 分别按前中后序打印，打印出的结果为整理后的结果
def print_tree_traversal(root, traversal_type):
    if traversal_type == "preorder":
        result = preorder_traversal(root)
    elif traversal_type == "inorder":
        result = inorder_traversal(root)
    elif traversal_type == "postorder":
        result = postorder_traversal(root)
    else:
        raise ValueError("Invalid traversal type")

    print(" ".join(map(str, result)))

print_tree_traversal(root, "preorder")

####################################### 下面为删除以后的二叉树直接打印，层序遍历，可以更加直观的观察
def print_binary_tree(root):
    if root is None:
        return

    queue = deque()
    queue.append(root)

    while queue:
        level_nodes = len(queue)
        level_values = []

        for _ in range(level_nodes):
            node = queue.popleft()
            if node:
                level_values.append(str(node.val))
                queue.append(node.left)
                queue.append(node.right)
            else:
                level_values.append("null")

        print(" ".join(level_values))
print_binary_tree(root)


# 50,30,60,20,40,null,70,null,null,35,45
# key = 30