算法学习——LeetCode力扣二叉树篇7

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

236. 二叉树的最近公共祖先 - 力扣（LeetCode）

描述

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

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

示例

示例 1：

输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出：3
解释：节点 5 和节点 1 的最近公共祖先是节点 3 。

示例 2：

输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
输出：5
解释：节点 5 和节点 4 的最近公共祖先是节点 5 。因为根据定义最近公共祖先节点可以为节点本身。

示例 3：

输入：root = [1,2], p = 1, q = 2
输出：1

提示

• 树中节点数目在范围 [2, 105] 内。
• -109 <= Node.val <= 109
• 所有 Node.val 互不相同 。
• p != q
• p 和 q 均存在于给定的二叉树中。

代码解析

递归非回溯法（内存消耗大）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<TreeNode*>  result;
    int find_node(TreeNode* cur, TreeNode* p, TreeNode* q)
    {
        int cur_val=0;
        if(cur==NULL) return 0;
        //找到p权值是1，找到q权值是2
        if(cur->val == p->val) cur_val += 1;
        if(cur->val == q->val) cur_val += 2;

        int left_val = find_node(cur->left , p, q);
        int right_val = find_node(cur->right , p, q);
		//当这个节点及左右子树里面满足3，也就是同时存在pq时候，存入vector
        if(left_val+right_val+cur_val==3) result.push_back(cur) ;
		//返回权值和
        return left_val+right_val+cur_val;
    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        int val = find_node(root,p,q);
        //因为最进公共祖先最后发现，但是由于递归是最先存入vector，因此取第一个
        return result[0];
    }
};
片

递归回溯法

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:

    TreeNode* find_node(TreeNode* cur, TreeNode* p, TreeNode* q)
    {		
    		//发现pq或者空，返回该节点
            if (cur == q || cur == p || cur == NULL) return cur;
            
            TreeNode* left = find_node(cur->left, p, q);
            TreeNode* right = find_node(cur->right, p, q);
            //发现两边均有点，返回当前点
            if (left != NULL && right != NULL) return cur;
 			//发现右子树有点返回
            if (left == NULL && right != NULL) return right;
            //发现左子树有点返回
            else if (left != NULL && right == NULL) return left;
            else  return NULL;  //  (left == NULL && right == NULL)
            
        }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        return find_node(root,p,q);
    }
};

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

235. 二叉搜索树的最近公共祖先 - 力扣（LeetCode）

描述

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

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

例如，给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]

示例

示例 1:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
输出: 6
解释: 节点 2 和节点 8 的最近公共祖先是 6。

示例 2:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
输出: 2
解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。

说明

• 所有节点的值都是唯一的。
• p、q 为不同节点且均存在于给定的二叉搜索树中。

代码解析

搜索二叉树不需要回溯，直接判断当前点在目标点两端就可以。普通二叉树要回溯

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

class Solution {
public:
    TreeNode* find_node(TreeNode* cur, TreeNode* p, TreeNode* q)
    {
    	//发现目标点或者空点返回
        if(cur==NULL || cur->val == p->val || cur->val == q->val) return cur;

        //当前值大于目标点，则目标点在左子树
        if(cur->val > p->val && cur->val > q->val) 
        {
            TreeNode * left_tree = find_node(cur->left,p,q);
            return left_tree;
        }
        //当前值小于目标点，则目标点在右子树
        else if (cur->val < p->val && cur->val < q->val) 
        {
            TreeNode * right_tree = find_node(cur->right,p,q);
            return right_tree;
        }
        //当前值在两个目标点中间，则当前值是公共祖先返回
        else 
        {
           return cur;
        }


    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        return find_node(root,p,q);
    }
};

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

701. 二叉搜索树中的插入操作 - 力扣（LeetCode）

描述

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

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

示例

示例 1：

输入：root = [4,2,7,1,3], val = 5
输出：[4,2,7,1,3,5]
解释：另一个满足题目要求可以通过的树是：

示例 2：

输入：root = [40,20,60,10,30,50,70], val = 25
输出：[40,20,60,10,30,50,70,null,null,25]

示例 3：

输入：root = [4,2,7,1,3,null,null,null,null,null,null], val = 5
输出：[4,2,7,1,3,5]

提示

• 树中的节点数将在 [0, 104]的范围内。
• -108 <= Node.val <= 108
• 所有值 Node.val 是 独一无二 的。
• -108 <= val <= 108
• 保证 val 在原始BST中不存在。

代码解析

/**
 * 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:
   
    void find_node(TreeNode* cur, int val)
    {
        if(cur==nullptr) return ; 
        //当前值大于目标值，插入左子树
        if(cur->val > val ) 
        {
        	//找到空点，插入        	.
            if(cur->left == nullptr)
            {
                TreeNode* new_node = new TreeNode(val);
                cur->left = new_node;
            }else
            {
                find_node(cur->left , val);
            }
            
        }
        //当前值小于目标值，插入右子树
        else if(cur->val <val )  
        {
        	//找到空点，插入
             if(cur->right == nullptr)
            {
                TreeNode* new_node = new TreeNode(val);
                cur->right = new_node;
            }else
            {
                find_node(cur->right , val);
            }
        }

    }

    TreeNode* insertIntoBST(TreeNode* root, int val) {
    	//如果根节点是空的，设置新点作为根
        if(root==nullptr ) 
        {
             TreeNode* new_node = new TreeNode(val);
             return new_node;
        }
        else//如果根节点是非空，插入
        {
            find_node(root , val);
            return root;
        }
     
    }
};

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

450. 删除二叉搜索树中的节点 - 力扣（LeetCode）

描述

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

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

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

示例

示例 1:

输入：root = [5,3,6,2,4,null,7], key = 3
输出：[5,4,6,2,null,null,7]
解释：给定需要删除的节点值是 3，所以我们首先找到 3 这个节点，然后删除它。
一个正确的答案是 [5,4,6,2,null,null,7], 如下图所示。
另一个正确答案是 [5,2,6,null,4,null,7]。

示例 2:

输入: root = [5,3,6,2,4,null,7], key = 0
输出: [5,3,6,2,4,null,7]
解释: 二叉树不包含值为 0 的节点

示例 3:

输入: root = [], key = 0
输出: []

提示

• 节点数的范围 [0, 104].
• -105 <= Node.val <= 105
• 节点值唯一
• root 是合法的二叉搜索树
• -105 <= key <= 105

进阶

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

代码解析

/**
 * 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* traversal(TreeNode* cur , int key)
    {
    	//当为空节点的时候直接返回
        if(cur==nullptr) return cur;
		//当前值为目标值时
        if(cur->val == key)
        {
        	//当前点的左右子树都是空，删除节点返回
            if(cur->left == nullptr && cur->right == nullptr) 
            {
                delete cur;
                return nullptr;
            }
            //左子树存在，右子树空，左孩子作为新的根节点返回
            else if(cur->left != nullptr && cur->right == nullptr)
            {
                auto tmp = cur->left;
                delete cur;
                return tmp;
            }
            //左子树为空，右子树存在，右子树作为新的根节点返回
            else if(cur->left == nullptr && cur->right != nullptr)
            {
                auto tmp = cur->right;
                delete cur;
                return tmp;
            }
            //左右子树都存在，令右孩子为新的根节点，左子树放到右子树的最左边。
            else
            {
              
                TreeNode* tmp = cur->right;

                while(tmp->left !=nullptr)
                {
                    tmp = tmp->left;
                }
                tmp->left = cur->left;

                TreeNode* result = cur->right;
                delete cur;
                return result;
            }
            
        }
        //当前值不是目标值，按照二叉搜索树单边遍历
        if(cur->val > key) cur->left = traversal(cur->left , key);
        if(cur->val < key) cur->right = traversal(cur->right , key);
        
        return cur;
    }
    TreeNode* deleteNode(TreeNode* root, int key) {
        if(root==nullptr) return nullptr;
        return traversal(root,key);
    }
};