代码随想录算法训练营第二十天|654. 最大二叉树、617. 合并二叉树、700. 二叉搜索树中的搜索、98. 验证二叉搜索树-CSDN博客

本文链接：https://blog.csdn.net/qq_63241956/article/details/132890767

第六章二叉树part06

654. 最大二叉树

给定一个不重复的整数数组 nums 。 最大二叉树 可以用下面的算法从 nums 递归地构建:

创建一个根节点，其值为 nums 中的最大值。
递归地在最大值左边的 子数组前缀上 构建左子树。
递归地在最大值右边的 子数组后缀上 构建右子树。

返回 nums 构建的 最大二叉树 。

思路：与前一天已知前序（后序）和中序求二叉树思路一致，一遍ac

class Solution {
public:
    TreeNode* traversal(vector<int>& nums,int start,int end){
        //终止条件
        if(start==end)  return NULL;

        //找到最大值以及相应的下标
        int maxNum=INT_MIN;
        int maxIndex=0;
        for(int i=start;i<end;i++){
            if(nums[i]>maxNum)  {
                maxNum=nums[i];
                maxIndex=i;
            }
        }
        TreeNode* root=new TreeNode(maxNum);
        //终止条件
        if(end-start==1)  return root;

        int leftStart=start;
        int leftEnd=maxIndex;
        int rightStart=maxIndex+1;
        int rightEnd=end;
        //递归单层逻辑
        root->left=traversal(nums,leftStart,leftEnd);
        root->right=traversal(nums,rightStart,rightEnd);

        return root;
    }
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        if(nums.size()==0)  return NULL;
        return traversal(nums,0,nums.size());
    }
};

617. 合并二叉树

给你两棵二叉树： root1 和 root2 。

想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。

返回合并后的二叉树。

注意: 合并过程必须从两个树的根节点开始。

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

700. 二叉搜索树中的搜索

给定二叉搜索树（BST）的根节点 root 和一个整数值 val。

你需要在 BST 中找到节点值等于 val 的节点。返回以该节点为根的子树。如果节点不存在，则返回 null 。

思路：使用递归，一开始没有考虑BST特性即左节点值小于中间节点值小于右节点值，没有加节点值条件判断，导致先在左子树判断，不符合则返回空值导致错误。

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

    }
};

98. 验证二叉搜索树

给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效二叉搜索树定义如下：

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

一开始解法错误，只比较中间节点与左右子节点大小关系，忽视下面情况

递归法

中序遍历存入数组再逐一进行大小比较

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

不适用额外空间存储，同样使用中序遍历，保存最大值与后面数值比较

class Solution {
public:
    TreeNode* pre=NULL;       //避免使用最小值
    //long long maxVal=LONG_MIN;         //测试用例中包含INT最小值
    bool isValidBST(TreeNode* root) {
        if(root==NULL)  return true;
        bool left=isValidBST(root->left);

        //if(root->val>maxVal)  maxVal=root->val;
        //else  return false;
        if(pre!=NULL&&root->val<=pre->val)  return false;
        pre=root;

        bool right=isValidBST(root->right);
        return left&&right;
    }
};

迭代法

复习一下中序遍历


class Solution {
public:
    bool isValidBST(TreeNode* root) {
        //迭代法
        stack<TreeNode*> st;
        TreeNode* cur=root;
        TreeNode* pre=NULL;
        while(cur!=NULL||!st.empty()){
            if(cur!=NULL){
                st.push(cur);
                cur=cur->left;     //前
            }
            else{
                cur=st.top();     //中
                st.pop();
                if(pre!=NULL&&pre->val>=cur->val)  return false;
                pre=cur;
                cur=cur->right;     //后
            }
        }
        return true;
    }
};