DAY19 最大二叉树合并二叉树二叉搜索树中的搜索验证二叉搜索树

MOMO_114514

已于 2024-02-17 18:41:22 修改

阅读量381

点赞数 8

文章标签：数据结构算法 leetcode

于 2024-02-17 18:25:21 首次发布

本文链接：https://blog.csdn.net/MOMO_114514/article/details/136140575

版权

654.最大二叉树

这是补的昨天的博客

给定一个不含重复元素的整数数组。一个以此数组构建的最大二叉树定义如下：

二叉树的根是数组中的最大元素。
左子树是通过数组中最大值左边部分构造出的最大二叉树。
右子树是通过数组中最大值右边部分构造出的最大二叉树。

通过给定的数组构建最大二叉树，并且输出这个树的根节点。

示例：

654.最大二叉树

提示：

给定的数组的大小在 [1, 1000] 之间。

这道题，我的评价是，如果你学了用前序和中序或者用中序和后序构造二叉树的话，这道题做起来应该是得心应手的，难点可能在构造左右子树，需要将最大值左右边分别放入两个数组中。

class Solution {
public:
    TreeNode* maxTree(vector<int>& nums)
    {
        if(nums.size()==0)return NULL;
        int index=0;
        int flag=INT32_MIN;
        for(int i=0;i<nums.size();i++)
        {
            if(nums[i]>flag)
            { index=i;
              flag=nums[i];
            }
        }
        int rootval=nums[index];
        auto root=new TreeNode(rootval);
        if(nums.size()==1)return root;
        vector<int> leftnums;
        vector<int> rightnums;
        for(int i=0;i<index;i++)
        leftnums.push_back(nums[i]);
        for(int i=index+1;i<nums.size();i++)
        rightnums.push_back(nums[i]);
        root->left=maxTree(leftnums);
        root->right=maxTree(rightnums);
        return root;
    }
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
         return maxTree(nums);
    }
};

617.合并二叉树

给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。

你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。

示例 1:

617.合并二叉树

这道题难想的地方是，当两个树不同的结点是，只需要将第二个树的结点插入到第一个树缺失的结点上就行，迭代法如下：

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
                queue<TreeNode*>qu;
                if(root1==NULL)return root2;
                if(root2==NULL)return root1;
                qu.push(root1);
                qu.push(root2);
                while(!qu.empty())
                {
                    auto node1=qu.front();qu.pop();
                    auto node2=qu.front();qu.pop();
                    node1->val+=node2->val;
                    if(node1->left&&node2->left)
                    {
                        qu.push(node1->left);
                        qu.push(node2->left);
                    }
                    if(node1->right&&node2->right)
                    {
                        qu.push(node1->right);
                        qu.push(node2->right);
                    }
                    if(node1->left==NULL&&node2->left!=NULL)
                    {
                        node1->left=node2->left;
                    }
                     if(node1->right==NULL&&node2->right!=NULL)
                    {
                        node1->right=node2->right;
                    }
                }
                return root1;
    }
};

需要注意，这是两个树一起遍历的：

class Solution {
public:
    TreeNode* merge(TreeNode* r1,TreeNode* r2)
    {
        if(r1==NULL)return r2;
        if(r2==NULL)return r1;
        auto root=new TreeNode(0);
        root->val=r1->val+r2->val;
        root->left=merge(r1->left,r2->left);
        root->right=merge(r1->right,r2->right);
        return root;
    }
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
                return merge(root1,root2);
    }
}

700.二叉搜索树中的搜索

给定二叉搜索树（BST）的根节点和一个值。你需要在BST中找到节点值等于给定值的节点。返回以该节点为根的子树。如果节点不存在，则返回 NULL。

例如，

700.二叉搜索树中的搜索

普通二叉树可以直接遍历出结果：

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
              queue<TreeNode*> qu;
              int size=0;
              if(root==NULL)return NULL;
              qu.push(root);
              while(!qu.empty())
              {
                  size=qu.size();
                  while(size--)
                  {
                      auto node=qu.front();
                      qu.pop();
                      if(node->val==val)
                      return node;
                      if(node->left) qu.push(node->left);
                      if(node->right)qu.push(node->right);
                  }
              }
              return NULL;
    }

但是这是二叉搜索树，我们不要忘了它的性质，这时递归就简单了不少：

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

迭代也很简单：

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
              if(root==NULL)return NULL;
              while(root!=NULL)
              {
                  if(val>root->val)
                  {
                      root=root->right;
                  }
                  else if(val<root->val)
                  root=root->left;
                  else
                  return root;
              }
              return NULL;
    }
};

98.验证二叉搜索树

给定一个二叉树，判断其是否是一个有效的二叉搜索树。

假设一个二叉搜索树具有如下特征：

节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。

98.验证二叉搜索树

简单做法就是使用中序遍历得到一个有序的数组，看数组里的元素是否有序就行

class Solution {
public:
    void isBST(TreeNode* root,vector<int>& res){
        if(root==NULL)return ;
        isBST(root->left,res);
        res.push_back(root->val);
        isBST(root->right,res);
        
    }
    bool isValidBST(TreeNode* root) {
        vector<int> res;
        isBST(root,res);
     
        for(int i=0;i<res.size();i++)
        {  if(i>0)
           {
             if(res[i-1]>=res[i])
             return 0;
           }
        }

        return 1;
    }
};

如果不开辟新的空间，这时就需要一个变量来保存前一个结点的值，如下：

class Solution {
public:
      long long int maxvalue=LONG_MIN;
    bool isBST(TreeNode* root){
        if(root==NULL)return 1;
       bool left=isBST(root->left);
       if(maxvalue<root->val)
       maxvalue=root->val;
       else
       return 0;
       bool right=isBST(root->right);
       return right&&left;        
    }
    bool isValidBST(TreeNode* root) {
       
        return isBST(root);
    }
};

可以单独开一个prenode解决问题：

class Solution {
public:
      TreeNode * prenode=NULL;
    bool isBST(TreeNode* root){
        if(root==NULL)return 1;
       bool left=isBST(root->left);
       if(prenode!=NULL&&prenode->val>=root->val)
       return 0;
       prenode=root;
       bool right=isBST(root->right);
       return right&&left;        
    }
    bool isValidBST(TreeNode* root) {
       
        return isBST(root);
    }

总之，解法很多。

MOMO_114514

关注

8
点赞
踩
5

收藏

觉得还不错? 一键收藏
1
评论
DAY19 最大二叉树合并二叉树二叉搜索树中的搜索验证二叉搜索树

给定一个不含重复元素的整数数组。通过给定的数组构建最大二叉树，并且输出这个树的根节点。示例：提示：给定的数组的大小在 [1, 1000] 之间。这道题，我的评价是，如果你学了用前序和中序或者用中序和后序构造二叉树的话，这道题做起来应该是得心应手的，难点可能在构造左右子树，需要将最大值左右边分别放入两个数组中。
复制链接

扫一扫