代码随想录|day20|二叉树 part06 ● 654.最大二叉树 ● 617.合并二叉树 ● 700.二叉搜索树中的搜索 ● 98.验证二叉搜索树

 654.最大二叉树

链接：代码随想录

 

自己原来的做法：

/**
 * 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) {}
 * };
 */
 //原本的做法，单次递归中，只需要找到最大值所在的index即可
class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        int n=nums.size()-1;
        TreeNode *root=digui(nums,0,n);
        return root;



    }
    TreeNode *digui(vector<int> &nums,int start,int end)
    {
        if(start>nums.size()-1 || end<0 ||start>end)
        {
            return nullptr;
        }
        int maxx_index=start;
        for(int i=start;i<=end;i++)
        {
            if(nums[i]>nums[maxx_index])
            {
                maxx_index=i;
            }
        }
        //cout<<start<<"   "<<end<<endl;
        TreeNode *temp=new TreeNode(nums[maxx_index]);
        temp->left=digui(nums,start,maxx_index-1);
        temp->right=digui(nums,maxx_index+1,end);
        return temp;

    }
};

 其实跟代码随想录上的是一样的。嗯，思路很不错。

617.合并二叉树 

链接：代码随想录

 自己的做法，代码随想录的思路相同，我的更好理解

//直接加到root1上
class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if(root1==nullptr && root2==nullptr)
        {
            return nullptr;
        }
        else if(root1==nullptr && root2!=nullptr)
        {
            return root2;
        }
        else if(root1!=nullptr && root2==nullptr)
        {
            return root1;
        }
        else
        {
            root1->val+=root2->val;
            root1->left=mergeTrees(root1->left,root2->left);
            root1->right=mergeTrees(root1->right,root2->right);
            return root1;
        }
        

    }
};

 700. 二叉搜索树中的搜索

 

/**
 * 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:
    bool find=false;
    TreeNode* searchBST(TreeNode* root, int val) {
        if(root==nullptr)
        {
            return nullptr;
        }
        if(val==root->val)
        {
            return root;
        }
        else if(val<root->val)//遍历左子树
        {
            return  searchBST(root->left,val);
        }
        else
        {
            return searchBST(root->right,val);
        }

    }
};
二、迭代法 */
class Solution {
public:
    bool find=false;
    TreeNode* searchBST(TreeNode* root, int val) {
        TreeNode *r=root;
        while(r!=nullptr)
        {
            if(val==r->val)
            {
                return r;
            }
            else if(val<r->val)
            {
                r=r->left;
            }
            else
            {
                r=r->right;
            }
        }
        return nullptr;
    }
};

98. 验证二叉搜索树 

链接：代码随想录

自己的解法出错：

 原因：要考虑到root需要小于右子树的最小值，大于左子树的最大值。

这道题目比较容易陷入两个陷阱：

• 陷阱1

不能单纯的比较左节点小于中间节点，右节点大于中间节点就完事了。

 

• 陷阱2

样例中最小节点 可能是int的最小值，如果这样使用最小的int来比较也是不行的。

此时可以初始化比较元素为longlong的最小值。

class Solution {
public:
    long long maxVal = LONG_MIN; // 因为后台测试数据中有int最小值
    bool isValidBST(TreeNode* root) {
        if (root == NULL) return true;

        bool left = isValidBST(root->left);
        // 中序遍历，验证遍历的元素是不是从小到大
        if (maxVal < root->val) maxVal = root->val;
        else return false;
        bool right = isValidBST(root->right);

        return left && right;
    }

更好理解的：

/**
 * 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:
    //验证二叉树，要从子树范围的角度考虑，本节点一定是左子树的最大值，右子树的最小值
    bool isValidBST(TreeNode* root) {
        long long minn=LONG_MIN;
        long long maxx=LONG_MAX;
        return isBST(root,minn,maxx);

    }
    bool isBST(TreeNode *root,long long minn,long long maxx)
    {
        if(root!=nullptr)
        {
           if(root->val<=minn || root->val>=maxx)
           {
               return false;
           }
           return isBST(root->left,minn,root->val)&&isBST(root->right,root->val,maxx);
        }
        return true;
    }
};