Leetcode 二叉树

最新推荐文章于 2025-12-05 21:56:57 发布

原创最新推荐文章于 2025-12-05 21:56:57 发布 · 69 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #算法

文章讲述了在二叉搜索树(BST)中查找最低公共祖先(LCA)，插入新节点，删除节点以及如何从排序数组构建BST的方法。重点在于利用BST的性质，如中序遍历的顺序，以及在不同情况下如何处理节点的关系。

235. Lowest Common Ancestor of a Binary Search Tree

可以利用BST的特性，当p,q小于root, p,q一定在root的左子树，当p.q大于root，一定在右子树，如果root为p,q中间值（从上自下第一个出现的），那么为LCA

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root == NULL) return root;

        if(root->val > p->val && root->val > q->val){
            TreeNode* left = lowestCommonAncestor(root->left, p, q);
            if(left != NULL) return left;
        }

        if(root->val < p->val && root->val < q->val){
            TreeNode* right = lowestCommonAncestor(root->right, p, q);
            if(right!= NULL) return right;
        }

        return root;
        
    }
};

701. Insert into a Binary Search Tree

class Solution {
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        if(root == NULL) return new TreeNode(val);
        if(root->val < val) root->right = insertIntoBST(root->right, val);
        if(root->val > val) root->left = insertIntoBST(root->left,val);
        return root;

    }
};

2.迭代

class Solution {
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        if(root == NULL) return new TreeNode(val);

        TreeNode* cur = root;
        TreeNode* parent = root;
        
        while(cur != NULL){
            parent = cur;
            if(cur->val > val){
                cur = cur->left;
            }else{
                cur = cur->right;
            }
        }

        TreeNode* newNode = new TreeNode(val);
        if(parent->val > val){
            parent->left = newNode;
        }else{
            parent->right = newNode;
        }

        return root;

    }
};

450. Delete Node in a BST

会遇到三种情况：

1.左右都为空，那么直接删除这个节点就可以了

2.只有一个子树，那么可以让子树直接接替删除的点

3.两边都不为空，这时需要让inorder processor（先左然后一直右）或者inorder successor（先右然后一直左

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        if(root == NULL) return root;
        if(root->val == key){
            if(root->left == NULL){
                return root->right;
            }
            if(root->right == NULL){
                return root->left;
            }

            TreeNode* inorderProcessor = getProcessor(root->left);
            root->left = deleteNode(root->left, inorderProcessor->val);
            inorderProcessor->left = root->left;
            inorderProcessor->right = root->right;
            root = inorderProcessor;
        }else if(root->val < key){
            root->right = deleteNode(root->right, key);
        }else{
            root->left = deleteNode(root->left, key);
        }

        return root;
    }

    TreeNode* getProcessor(TreeNode* root){
        while(root->right != NULL){
            root = root->right;
        }

        return root;
    }
};

）接替（这里要注意的一点是，如果接替的node有左/右子树，就需要重复进行2这种情况的分析）

108. Convert Sorted Array to Binary Search Tree

每次root都是从中间开始

class Solution {
public:
    TreeNode* traversal(vector<int>& nums, int left, int right){
        if(left > right) return NULL;
        int mid = left + (right-left)/2;
        TreeNode* root = new TreeNode(nums[mid]);
        root->left = traversal(nums, left, mid-1);
        root->right = traversal(nums, mid+1, right);
        return root;
    }
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        return traversal(nums, 0, nums.size()-1);
    }
};

二叉树的一些想法：

1.遍历（前中后序）这里需要考虑是在什么时间点做事情，前序就是在刚进入节点就做（或者说还没有进入节点），中序是在完成左子树，在进入到右子树之前，后序是离开节点再做

回溯？在退出节点时需要撤销做过的一些事（有时候如果用迭代的时候，当返回上一个函数的时候，自动就完成撤销步骤了）

2.分解问题（动态规划？）

这里是把大问题分解为小问题，简单来说，这里直接到了子叶，自下而上解决问题

3.层序遍历

BST

1. 遇到BST要学会运用BST的规律

2.很多时候可以考虑中序（感觉中序在普通二叉树用的比较少），因为BST中序遍历的值一定是从小大的顺序

3.BST删除节点的方法