算法刷题day15|二叉树：654. 最大二叉树、617. 合并二叉树、700. 二叉搜索树中的搜索、98. 验证二叉搜索树

654. 最大二叉树

和昨天的根据前序、中序构建二叉树思路一样

class Solution {
public:
    TreeNode* traversal(vector<int>& nums, int begin, int end){
        if (begin >= end) return nullptr;
        //分割点下标
        //不能像下方代码那样定义，因为下方代码要找的值的下标是确定的
        //而此段代码找最大值的下标是不止何时才是最大值，所有要不断记录下标，不像下方可以break
        int index = begin;
        for (int i = index + 1; i < end; i++){
            if (nums[i] > nums[index]){
                index = i;
            }
        }
        /*
        int index;
        for (index = inorderBegin; index < inorderEnd; index++){
            if (inorder[index] == rootVal) break;
        }
        */
        TreeNode* root = new TreeNode(nums[index]);

        root->left = traversal(nums, begin, index);
        root->right = traversal(nums, index + 1, end);

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

617. 合并二叉树

递归法

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        //二者都为空
        if (root1 == NULL && root2 == NULL) return NULL;
        //root1为空，返回root2
        if (root1 == NULL && root2 != NULL) return root2;
        //root2为空，返回root1
        if (root1 != NULL && root2 == NULL) return root1;
        TreeNode* root = new TreeNode(0);
        root->val = root1->val + root2->val;
        root->left =  mergeTrees(root1->left, root2->left);
        root->right =  mergeTrees(root1->right, root2->right);
        return root;
    }
};

迭代法

在t1上操作，最后返回t1

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        if (t1 == NULL) return t2;
        if (t2 == NULL) return t1;
        queue<TreeNode*> que;
        que.push(t1);
        que.push(t2);
        while(!que.empty()) {
            TreeNode* node1 = que.front(); que.pop();
            TreeNode* node2 = que.front(); que.pop();
            // 此时两个节点一定不为空，val相加
            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);
            }

            // 当t1的左节点 为空 t2左节点不为空，就赋值过去
            if (node1->left == NULL && node2->left != NULL) {
                node1->left = node2->left;
            }
            // 当t1的右节点 为空 t2右节点不为空，就赋值过去
            if (node1->right == NULL && node2->right != NULL) {
                node1->right = node2->right;
            }
        }
        return t1;
    }
};

700. 二叉搜索树中的搜索

递归法

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

注：当时写第一遍的时候习惯直接写 searchBST(root->left, val)，却忘了 递归函数还有返回值。

递归函数的返回值是什么? 是 左子树如果搜索到了val，要将该节点返回。 如果不用一个变量将其接住，那么返回值不就没了。

所以要 result = searchBST(root->left, val)。

迭代法

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

98. 验证二叉搜索树

中序遍历

利用二叉搜索树的特性：中序遍历序列是有序的

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

递归法

class Solution {
public:
    bool helper(TreeNode* root, long long lower, long long upper) {
        if (root == nullptr) {
            return true;
        }
        if (root -> val <= lower || root -> val >= upper) {
            return false;
        }
        return helper(root -> left, lower, root -> val) && helper(root -> right, root -> val, upper);
    }
    bool isValidBST(TreeNode* root) {
        return helper(root, LONG_MIN, LONG_MAX);
    }
};