代码随想录算法训练营DAY08之二叉树（四）搜索树（2）

题目及链接：

236.二叉树的最近公共祖先

235. 二叉搜索树的最近公共祖先

701. 二叉搜索树中的插入操作

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

669. 修剪二叉搜索树

108. 将有序数组转换为二叉搜索树

538. 把二叉搜索树转换为累加树

236. 二叉树的最近公共祖先

题意：

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

做题状态和思路：

看题解前的想法是找到p或q的所有父节点，放进map里面，遍历令一个时再找map里面有没有，有便找到了最近的公共祖先。

首先是如何找到父节点，自己做的时候是从下往上，所以写不出来，应该从上往下遍历的时候就记录，fa [ root -> left -> val ] = root，右边同理，于是便完成了每个结点父亲的记录

再标记p的所有祖先，这里用了bool map标记，再遍历q的父亲，如果vis为true，就返回该结点，遍历完也没有则返回null

code

class Solution {
public:
    unordered_map<int, TreeNode*> fa;
    unordered_map<int, bool> vis;
    void dfs(TreeNode* root){
        if (root->left != nullptr) {
            fa[root->left->val] = root;
            dfs(root->left);
        }
        if (root->right != nullptr) {
            fa[root->right->val] = root;
            dfs(root->right);
        }
    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        fa[root->val] = nullptr;
        dfs(root);
        while (p != nullptr) {
            vis[p->val] = true;
            p = fa[p->val];
        }
        while (q != nullptr) {
            if (vis[q->val]) return q;
            q = fa[q->val];
        }
        return nullptr;
    }
};

235. 二叉搜索树的最近公共祖先

题意：

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先

做题状态和思路：

首先是不是二叉搜索树都可以用前面那种方法做，那么二叉搜索树有什么好方法呢

根据二叉搜索树的特点，让p和q的值与根结点做比较，如果都小与该根结点的值，

则root=root->left，都大于则root=root->right，一大一小则退出循环。

code

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

701.二叉搜索树中的插入操作

题意：

给定二叉搜索树（BST）的根节点 root 和要插入树中的值 value ，将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 输入数据 保证 ，新值和原始二叉搜索树中的任意节点值都不同。

注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。 你可以返回 任意有效的结果 。

做题状态和思路：

简单模拟就行，题解用了一个pre指针以便于最后一步的操作，插入操作，因为cur一定会指向空后才推出循环

code

class Solution {
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        if(root==nullptr) {
            TreeNode* node=new TreeNode(val);
            return node;
        }
        TreeNode* pre=root;
        TreeNode* cur=root;
        while(cur){
            pre=cur;
            if(val<cur->val) cur=cur->left;
            else cur=cur->right;

        }
        TreeNode* node=new TreeNode(val);
        if(val<pre->val) pre->left=node;
        else pre->right=node;
        return root;
    }
};

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

题意：

给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。

一般来说，删除节点可分为两个步骤：

1. 首先找到需要删除的节点；
2. 如果找到了，删除它。

做题状态和思路：

好难……只会找到那个要删的结点，不同情况的代码不会写

code

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        if(!root) return root;
        if(root->val==key) {
            if(!root->right&&!root->left) {
                delete root;
                return nullptr;}
            else if(root->right&&!root->left) {
                TreeNode* copynode=root->right;
                delete root;
                return copynode;}
            else if(!root->right&&root->left) {
                TreeNode* copynode=root->left;
                delete root;
                return copynode;}
            else if(root->right&&root->left){
                TreeNode* cur=root->right;
                while(cur->left){
                    cur=cur->left;
                }
                cur->left=root->left;
                TreeNode* tem=root;
                root=root->right;
                delete tem;
                return  root;
            }
            
        }
        if(key<root->val) root->left=deleteNode(root->left,key);
            else root->right=deleteNode(root->right,key);
            return root;
    }
};

 

108.将有序数组转换为二叉搜索树

题意：

给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 

平衡二叉搜索树。

 code：

只需要使用递归就行，三部曲：返回值类型和参数，退出条件：Left > right，单层逻辑:开辟mid的值为root，root->left指向左递归，root->right指向右递归，最后返回root

class Solution {
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        return helper(nums, 0, nums.size() - 1);
    }

    TreeNode* helper(vector<int>& nums, int left, int right) {
        if (left > right) {
            return nullptr;
        }

        // 总是选择中间位置左边的数字作为根节点
        int mid = (left + right) / 2;

        TreeNode* root = new TreeNode(nums[mid]);
        root->left = helper(nums, left, mid - 1);
        root->right = helper(nums, mid + 1, right);
        return root;
    }
};

538.把二叉搜索树转换为累加树

题意：

给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。

code

根据二叉搜索树的特点，每个结点的值将变成它右边所有结点的值的和，即反中序遍历后，它前面所有的值的和。那么用递归就很好理解了。不过题解真的很精简。

class Solution {
public:
    int sum = 0;

    TreeNode* convertBST(TreeNode* root) {
        if (root != nullptr) {
            convertBST(root->right);
            sum += root->val;
            root->val = sum;
            convertBST(root->left);
        }
        return root;
    }
};