LeetCode 450 - 删除二叉搜索树中的节点

原创于 2025-12-16 20:35:57 发布 · 441 阅读

7 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #算法 #职场和发展

Swift 同时被 3 个专栏收录

472 篇文章

订阅专栏

实战

211 篇文章

订阅专栏

LeetCode

93 篇文章

订阅专栏

2025博客之星年度评选已开启 10w+人浏览 1.1k人参与

在这里插入图片描述

文章目录

摘要

在所有二叉搜索树（BST）的操作里，删除节点算是最容易让人写崩的一道题。

插入很好写，查找也没什么难度，但一到删除，就会遇到各种情况：

要删的节点是叶子节点怎么办
只有一个子节点怎么办
左右子树都存在又该怎么办

而这道 LeetCode 450，几乎把 BST 删除能遇到的所有坑都覆盖到了。

这篇文章会一步一步拆解 BST 删除节点的完整思路，用「分类讨论」的方式，把每一种情况都讲清楚，再给出一份可运行、好理解、好维护的 Swift 实现。

描述

题目要求我们：

给定一棵合法的二叉搜索树
给定一个要删除的值 key
删除对应节点，并保持 BST 的性质不变
返回更新后的根节点

BST 的基本规则还是那一条：

左子树所有节点值 < 当前节点
右子树所有节点值 > 当前节点

同时题目还强调了一点：

要求算法时间复杂度为 O(h)，h 为树的高度

这其实在暗示我们：
不能把整棵树拍平重建，只能沿着搜索路径递归处理。

题解答案（整体思路）

删除 BST 节点，本质上可以拆成两步：

第一步：找到要删除的节点

这一点和普通 BST 查找完全一样：

key < root.val → 去左子树找
key > root.val → 去右子树找
key == root.val → 找到了，开始处理删除逻辑

第二步：根据节点的结构分类处理

找到目标节点后，分三种情况：

叶子节点（没有子节点）
- 直接删除，返回 nil
只有一个子节点
- 用它的子节点顶替它的位置
左右子节点都存在
- 找到右子树中的最小节点（或左子树中的最大节点）
- 用这个值替换当前节点
- 再递归删除被“借用”的那个节点

这三种情况，是整个题目的核心。

题解代码（Swift 可运行 Demo）

下面是完整的 Swift 实现，包括 TreeNode 定义和删除逻辑。

import Foundation

public class TreeNode {
    public var val: Int
    public var left: TreeNode?
    public var right: TreeNode?
    
    public init(_ val: Int) {
        self.val = val
        self.left = nil
        self.right = nil
    }
}

class Solution {
    
    func deleteNode(_ root: TreeNode?, _ key: Int) -> TreeNode? {
        guard let root = root else {
            return nil
        }
        
        if key < root.val {
            root.left = deleteNode(root.left, key)
        } else if key > root.val {
            root.right = deleteNode(root.right, key)
        } else {
            // 找到要删除的节点
            
            // 情况 1：没有左子树
            if root.left == nil {
                return root.right
            }
            
            // 情况 2：没有右子树
            if root.right == nil {
                return root.left
            }
            
            // 情况 3：左右子树都存在
            let minNode = findMin(root.right)
            root.val = minNode.val
            root.right = deleteNode(root.right, minNode.val)
        }
        
        return root
    }
    
    private func findMin(_ node: TreeNode?) -> TreeNode {
        var current = node
        while current?.left != nil {
            current = current?.left
        }
        return current!
    }
}

题解代码分析

1. 为什么删除一定要分类讨论？

因为 BST 的结构不统一，删除节点后，必须保证：

中序遍历仍然是有序的
父子关系不能乱

如果不分情况直接暴力删，很容易破坏 BST 的结构。

2. 叶子节点的删除

if root.left == nil && root.right == nil {
    return nil
}

这是最简单的一种情况，直接删掉即可。

在递归结构中，其实可以合并到：

if root.left == nil {
    return root.right
}

因为 root.right 本身就是 nil。

3. 只有一个子节点的情况

if root.left == nil {
    return root.right
}
if root.right == nil {
    return root.left
}

这种情况下，用子节点直接“顶上来”，不会破坏 BST 的规则。

4. 左右子树都存在时怎么处理？

这是最关键、也最容易写错的部分。

正确做法是：

找一个 能替换当前节点，又不破坏 BST 的值
这个值只能来自：
- 右子树的最小值（中序遍历的后继）
- 或左子树的最大值（中序遍历的前驱）

本题中我们选的是：右子树最小节点。

let minNode = findMin(root.right)
root.val = minNode.val
root.right = deleteNode(root.right, minNode.val)

这一步的本质是：

用后继节点的值覆盖当前节点
再把那个后继节点删掉

5. 为什么时间复杂度是 O(h)？

因为：

每次递归只往左或右走
没有遍历整棵树
最坏情况是树退化成链表，高度为 h

示例测试及结果

我们用示例 1 来跑一遍：

let root = TreeNode(5)
root.left = TreeNode(3)
root.right = TreeNode(6)
root.left?.left = TreeNode(2)
root.left?.right = TreeNode(4)
root.right?.right = TreeNode(7)

let solution = Solution()
let newRoot = solution.deleteNode(root, 3)

print(newRoot?.val ?? -1)

删除 3 后，可能得到：

或另一种等价 BST 结构，都是正确结果。

时间复杂度

查找节点：O(h)
删除节点：O(h)

总体时间复杂度：O(h)
其中 h 是树的高度。

空间复杂度

递归调用栈占用：O(h)
没有使用额外的数据结构

空间复杂度：O(h)

总结

LeetCode 450 是一道非常典型、也非常值得反复消化的 BST 基础题。

它教会你的不是“怎么写删除”，而是：

如何用递归精确控制结构变化
如何通过分类讨论避免复杂度爆炸
为什么 BST 的性质能帮我们缩小问题范围