代码随想录算法训练营day20 | LeetCode 654. 最大二叉树 617. 合并二叉树 700. 二叉搜索树中的搜索 98. 验证二叉搜索树

654. 最大二叉树（题目链接：力扣）

思路：这道题只想到了递归的做法，因为需要随时记录要用到数组的哪一段（并且该段还具有回溯性），因此没法用迭代法，明确了用递归法做后，要考虑的就是递归函数的参数传递了，因为用到了数组作为参数，所以在函数体内部不需要构造新数组，只需在递归函数参数传递时记录这次遍历要用到的起点到终点索引就可以了。

TreeNode* traversal(vector& nums, int start, int end)  {
        int size = end - start;
        if(size == 0) return NULL;
        int rootValue = -1;
        int rootIndex;
        for(int i=start; i rootValue){
                rootValue = nums[i];
                rootIndex = i;
            }
        }
        TreeNode* root = new TreeNode(rootValue);
        if(size == 1) return root;
        root->left = traversal(nums, start, rootIndex);
        root->right = traversal(nums, rootIndex+1, end);
        return root;
    }

    TreeNode* constructMaximumBinaryTree(vector& nums) {
        return traversal(nums, 0, nums.size());
    }

617. 合并二叉树（题目链接：力扣）

思路：需要遍历完整棵二叉树，递归和迭代的做法都可以，不过此次迭代的做法采用层次遍历，前中后序遍历应该也可以，但是应该比较复杂。到目前为止已经采用过多次将两颗二叉树的节点同时push进队列或栈中了，无疑这将是以后一种常见的做法。

TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
    if(root1 == NULL) return root2;
    if(root2 == NULL) return root1;
    root1->val += root2->val;
    root1->left = mergeTrees(root1->left, root2->left);
    root1->right = mergeTrees(root1->right, root2->right);
    return root1;
}

TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
    queue que;
    if(root1 == NULL) return root2;
    if(root2 == NULL) return root1;
    que.push(root1);
    que.push(root2);
    while(!que.empty()){
        TreeNode* node1 = que.front();
        que.pop();
        TreeNode* node2 = que.front();
        que.pop();
        node1->val += node2->val;
        if(node1->left != NULL && node2->left != NULL){
            que.push(node1->left);
            que.push(node2->left);
        }
        if(node1->right != NULL && node2->right != NULL){
            que.push(node1->right);
            que.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;
}

700. 二叉搜索树中的搜索（题目链接：力扣）

思路：找到满足条件的就返回，典型的用递归做，并且需要返回值，不能让递归函数一直遍历下去（这样会增加无谓耗时），因为是二叉搜索树，所以只要遍历到第一处叶子节点即可知道结果。

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

98. 验证二叉搜索树（题目链接：力扣）

思路：一开始很粗心的想错了，以为只要判断每个节点的左右节点和该节点的关系就可以了。后来细一想才发现是要判断某棵树左右字树中所有节点和根节点的关系。那么就正好可以采用中序遍历，同时记录上一个访问节点的值，把本节点的值和该值做比较即可。同时一旦发现不满足条件立即返回，所以函数应有返回值。

long long maxVal = LONG_MIN;

bool isValidBST(TreeNode* root) {
    if(root == NULL) return true;
    bool left = isValidBST(root->left);
    if(root->val > maxVal) maxVal = root->val;
    else return false;
    bool right = isValidBST(root->right);
    return left && right;
}

bool isValidBST(TreeNode* root) {
    long long maxVal = LONG_MIN;
    stack st;
    TreeNode* cur = root;
    while(!st.empty() || cur != NULL){
        while(cur){
            st.push(cur);
            cur = cur->left;
        }
        cur = st.top();
        st.pop();
        if(cur->val > maxVal) maxVal = cur->val;
        else return false;
        cur = cur->right;
    }
    return true;
}