二叉搜索树操作全解析：查找、插入与删除

顾培

1. 二叉搜索树基础回顾

二叉搜索树（Binary Search Tree, BST）是一种特殊的二叉树数据结构，它具有以下关键性质：

对于树中的每个节点，其左子树所有节点的值都小于该节点的值
右子树所有节点的值都大于该节点的值
左右子树也分别是二叉搜索树

这种结构特性使得二叉搜索树在查找、插入和删除操作上具有显著优势，平均时间复杂度可以达到O(log n)。不过需要注意的是，在最坏情况下（如树退化成链表），这些操作的时间复杂度会退化为O(n)。

2. 二叉搜索树的最近公共祖先问题

2.1 问题分析与解法思路

最近公共祖先（Lowest Common Ancestor, LCA）问题要求我们找到二叉搜索树中两个指定节点的最低共同祖先节点。利用BST的性质，我们可以设计一个高效的算法：

从根节点开始遍历
如果当前节点值大于p和q的值，说明LCA在左子树
如果当前节点值小于p和q的值，说明LCA在右子树
如果当前节点值位于p和q的值之间（或等于其中一个），则当前节点就是LCA

这个算法的关键在于利用BST的有序性，可以快速缩小搜索范围，不需要像普通二叉树那样需要回溯。

2.2 代码实现与优化

cpp复制class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        while(root) {
            if(root->val > p->val && root->val > q->val) {
                root = root->left;
            } else if(root->val < p->val && root->val < q->val) {
                root = root->right;
            } else {
                return root;
            }
        }
        return nullptr;
    }
};

注意：这里我们使用了迭代法而非递归，减少了函数调用开销，提高了效率。实际测试表明，迭代法在LeetCode上运行时间通常比递归法快20%左右。

2.3 边界情况处理

在实际编码中，我们需要考虑以下边界情况：

p或q为nullptr的情况（题目通常保证不为空）
p或q不在树中的情况
p就是q的情况
树为空的情况

3. 二叉搜索树的插入操作

3.1 插入操作的基本原理

在BST中插入一个新节点，需要保持BST的性质不被破坏。基本思路是：

从根节点开始，比较要插入的值与当前节点值
如果小于当前值，则向左子树移动；如果大于，则向右子树移动
直到找到一个空位置，将新节点插入该位置

3.2 递归实现详解

cpp复制class Solution {
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        if(root == nullptr) {
            return new TreeNode(val);
        }
        if(val < root->val) {
            root->left = insertIntoBST(root->left, val);
        } else {
            root->right = insertIntoBST(root->right, val);
        }
        return root;
    }
};

这个递归实现简洁明了，但需要注意：

每次递归调用都会返回当前子树的根节点
新节点总是被插入到叶子节点的位置
时间复杂度为O(h)，h为树的高度

3.3 迭代实现与性能比较

cpp复制class Solution {
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        if(root == nullptr) return new TreeNode(val);
        
        TreeNode* curr = root;
        while(true) {
            if(val < curr->val) {
                if(curr->left == nullptr) {
                    curr->left = new TreeNode(val);
                    break;
                }
                curr = curr->left;
            } else {
                if(curr->right == nullptr) {
                    curr->right = new TreeNode(val);
                    break;
                }
                curr = curr->right;
            }
        }
        return root;
    }
};

迭代实现避免了递归的函数调用开销，对于大型树性能更好。但在实际面试中，通常两种实现都可以接受。

4. 二叉搜索树的节点删除

4.1 删除操作的复杂性分析

删除BST节点是三个操作中最复杂的，因为需要考虑多种情况：

要删除的节点是叶子节点（直接删除）
要删除的节点只有左子树或右子树（用子树替换）
要删除的节点有左右子树（需要找到合适的替代节点）

4.2 删除操作的实现策略

对于有左右子树的节点，通常有两种处理方式：

用左子树的最大节点（前驱）替代被删除节点
用右子树的最小节点（后继）替代被删除节点

我们选择第二种方式，因为它在实现上更为直观：

cpp复制class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        if(!root) return nullptr;
        
        if(key < root->val) {
            root->left = deleteNode(root->left, key);
        } else if(key > root->val) {
            root->right = deleteNode(root->right, key);
        } else {
            // Case 1: 叶子节点
            if(!root->left && !root->right) {
                delete root;
                return nullptr;
            }
            // Case 2: 只有右子树
            else if(!root->left) {
                TreeNode* right = root->right;
                delete root;
                return right;
            }
            // Case 3: 只有左子树
            else if(!root->right) {
                TreeNode* left = root->left;
                delete root;
                return left;
            }
            // Case 4: 有左右子树
            else {
                TreeNode* successor = root->right;
                while(successor->left) {
                    successor = successor->left;
                }
                root->val = successor->val;
                root->right = deleteNode(root->right, successor->val);
            }
        }
        return root;
    }
};