算法训练 day20 | 654.最大二叉树 617.合并二叉树 700.二叉搜索树中的搜索 98.验证二叉搜索树-CSDN博客

本文链接：https://blog.csdn.net/qq_41943352/article/details/135594826

654.最大二叉树

题目链接:最大二叉树

视频讲解:又是构造二叉树！

构造二叉树一般采用前序遍历，因为要先构造中间节点，然后递归构造左子树和右子树。

递归

1、确定递归函数返回值和参数

传入的是存放元素的数组，返回的是构造的二叉树的头结点；

2、确定递归终止条件

题目中说了数组的大小大于零，那么当递归的时候，传入的数组大小为1时，说明遍历到叶子节点；

3、确定单层递归逻辑

先找到数组中最大值作为新构造二叉树头结点，以最大值为界，数组中最大值左边元素用于递归构造左子树，右边元素递归构造右子树。

/**
 * 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 {
private:
    TreeNode* traversal(vector<int>& nums)
    {
        if (nums.size() == 0) return NULL;
        int tmp = 0;
        int cur;
        for (int i = 0; i < nums.size(); ++i)
        {
            if (nums[i] >= tmp)
            {
                tmp = nums[i];
                cur = i;
            }
        }

        int inVal = nums[cur];
        TreeNode* root = new TreeNode(inVal);

        if (nums.size() == 1) return root;

        vector<int> left(nums.begin(), nums.begin() + cur);
        vector<int> right(nums.begin() + cur + 1, nums.end());

        root->left = traversal(left);
        root->right = traversal(right);

        return root;
    }

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

优化后

class Solution {
private:
    TreeNode* traversal(vector<int>& nums, int Begin, int End)
    {
        if (Begin >= End) return NULL;
        int tmp = 0;
        int cur = Begin;
        for (int i = Begin + 1; i < End; ++i)
        {
            if (nums[i] > tmp)
            {
                tmp = nums[i];
                cur = i;
            }
        }

        int inVal = nums[cur];
        TreeNode* root = new TreeNode(inVal);

        //if (nums.size() == 1) return root;

        root->left = traversal(nums, Begin, cur);
        root->right = traversal(nums, cur + 1, End);

        return root;
    }

public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        if (nums.size() == 0) return NULL; // 可以省去
        return traversal(nums, 0, nums.size());
    }
};

617.合并二叉树

题目链接:合并二叉树

视频讲解:一起操作两个二叉树？

依然用递归最方便

1、确定递归函数返回值和参数

传入的是两个二叉树的根节点，返回值是合并后二叉树的根节点；

2、确定终止条件

两个树中，是同时遍历，其中一棵树节点为空时取另一棵树的节点。（另一棵树为空也无所谓，合并之后就是NULL）；

3、确定单层递归逻辑

把两棵树同一位置节点的值相加，构造新树；

/**
 * 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:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if (!root1 && !root2) return NULL;  // 其实不需要这句话
        if (!root1) return root2;
        if (!root2) return root1;

        int Val = root1->val + root2->val;
        TreeNode* root = new TreeNode(Val);

        root->left = mergeTrees(root1->left, root2->left);
        root->right = mergeTrees(root1->right, root2->right);

        return root;
    }
};

700.二叉搜索树中的搜索

题目链接:二叉搜索树中的搜索

视频讲解:搜索有方向！

对于二叉搜索树，它是一个有序树

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

所以它的递归遍历和迭代遍历和普通的二叉树不一样，特别是迭代遍历要简单很多。

递归

1、确定递归函数返回值和参数

传入的是根节点和要搜索的值，返回的是要搜索的值所在的节点；

2、确定终止条件

当root为空或找到搜索值，返回节点；

3、确定单层递归逻辑

由二叉搜索树的特性，遍历到的节点比搜索值小则向右遍历，比搜索值大向左遍历；

/**
 * 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:
    TreeNode* searchBST(TreeNode* root, int val) {
       if (root == NULL || root->val == val) return root;
       TreeNode* result = NULL; 
       if (root->val < val) result = searchBST(root->right, val);
       if (root->val > val) result = searchBST(root->left, val);
       return result;
    }
};

迭代

/**
 * 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:
    TreeNode* searchBST(TreeNode* root, int val) {
        while (root != nullptr)
        {
            if (root->val < val) root = root->right;
            else if (root->val > val) root = root->left;
            else return root;
        }
        return NULL;
    }
};

98.验证二叉搜索树

题目链接:验证二叉搜索树

视频讲解:你对二叉搜索树了解的还不够！

要知道中序遍历下，输出的二叉搜索树节点的数值是有序序列。有了这个特性，验证二叉搜索树，就相当于变成了判断一个序列是不是递增的了。

递归

1、确定递归函数的返回值和参数

传入二叉树的根节点，判断是否是二叉搜索树，返回值为bool；

2、确定终止条件

如果是空节点，返回true；

3、确定单层递归逻辑

采用中序遍历，用一个指针记录遍历的前一个节点，并于当前节点比较，如果比当前节点小，说明不是二叉搜索树，返回false；

/**
 * 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:
    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);
    }
};