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

文档链接：https://programmercarl.com/

LeetCode654.最大二叉树

题目链接：https://leetcode.cn/problems/maximum-binary-tree/

思路：基本原理就是构造二叉树的步骤。构造树一般采用的是前序遍历，因为先构造中间节点，然后递归构造左子树和右子树。一般情况来说：如果让空节点（空指针）进入递归，就不加if，如果不让空节点进入递归，就加if限制一下， 终止条件也会相应的调整。

代码：

class Solution {
public:
    TreeNode* traversal(vector<int> vec) {
        if(vec.empty()) return NULL;
        int rootValue = *max_element(vec.begin(), vec.end());
        TreeNode* root = new TreeNode(rootValue);
        int index = max_element(vec.begin(), vec.end()) - vec.begin();
        vector<int> leftVec(vec.begin(), vec.begin() + index);
        vector<int> rightVec(vec.begin() + index + 1, vec.end());
        root->left = traversal(leftVec);
        root->right = traversal(rightVec);
        return root;
    }
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        return traversal(nums);
    }
};

不适用库函数：

class Solution {
public:
    TreeNode* traversal(vector<int> nums, int left, int right) {
        if(left >= right) return NULL;
        int maxValueIndex = left;
        for(int i = left + 1; i < right; i++) {
            if(nums[i] > nums[maxValueIndex]) maxValueIndex = i;
        }
        TreeNode* node = new TreeNode(nums[maxValueIndex]);
        node->left = traversal(nums, left, maxValueIndex);
        node->right = traversal(nums, maxValueIndex + 1, right);
        return node;
    }
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        return traversal(nums, 0, nums.size());
    }
};

---

LeetCode617.合并二叉树

题目链接：https://leetcode.cn/problems/merge-two-binary-trees/

思路：没啥思路，就直接写不就好了？

代码：

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

---

LeetCode700.二叉搜索树中的搜索

题目链接：https://leetcode.cn/problems/search-in-a-binary-search-tree/

思路：

二叉搜索树是一个有序树：

• 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
• 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
• 它的左、右子树也分别为二叉搜索树

这就决定了，二叉搜索树，递归遍历和迭代遍历和普通二叉树都不一样。

递归法：

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

迭代法：

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

---

LeetCode98.验证二叉搜索树

题目链接：https://leetcode.cn/problems/validate-binary-search-tree/

思路：二叉搜索树就要想到中序遍历！

要知道中序遍历下，输出的二叉搜索树节点的数值是有序序列。

有了这个特性，验证二叉搜索树，就相当于变成了判断一个序列是不是递增的了。

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

• 陷阱1

不能单纯的比较左节点小于中间节点，右节点大于中间节点就完事了。我们要比较的是 左子树所有节点小于中间节点，右子树所有节点大于中间节点。所以以上代码的判断逻辑是错误的。

• 陷阱2

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

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

定义全局变量：

class Solution {
public:
    long long value = LONG_MIN;
    bool isValidBST(TreeNode* root) {
        if(root == NULL) return true;
        bool left = isValidBST(root->left);
        if(root->val > value) value = root->val;
        else return false;
        bool right = isValidBST(root->right);
        return left && right;
    }
};

双指针法：

class Solution {
public:
    TreeNode* pre = NULL;
    bool isValidBST(TreeNode* root) {
        if(root == NULL) return true;
        bool left = isValidBST(root->left);
        if(pre != NULL && pre->val >= root->val) return false;
        pre = root;
        bool right = isValidBST(root->right);
        return left && right;
    }
};

总结：坚持打卡好像也没有那么难，真心觉得递归越来越得心应手了。