二叉树：leetcode 654.最大二叉树、617.合并二叉树、700.二叉搜索树中的搜索、98.验证二叉搜索树

最新推荐文章于 2024-07-22 09:38:37 发布

clementines_

最新推荐文章于 2024-07-22 09:38:37 发布

阅读量38

点赞数

文章标签： c++ leetcode 数据结构算法 Powered by 金山文档

本文链接：https://blog.csdn.net/qq_52097561/article/details/128847301

版权

leetcode 654.最大二叉树

leetcode 617.合并二叉树

leetcode 700.二叉搜索树中的搜索

leetcode 98.验证二叉搜索树

leetcode 654.最大二叉树

给定一个不含重复元素的整数数组。一个以此数组构建的最大二叉树定义如下：

二叉树的根是数组中的最大元素。

左子树是通过数组中最大值左边部分构造出的最大二叉树。

右子树是通过数组中最大值右边部分构造出的最大二叉树。

通过给定的数组构建最大二叉树，并且输出这个树的根节点。

涉及到构造二叉树，一定要选择合适的遍历方式。凡是构造二叉树的题目，我们都要用前序遍历。

因为前序遍历是中左右的顺序，我们一定要先把中节点构造出来，然后再去构造其左子树和右子树。

递归三部曲：

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

参数传入的是存放元素的数组，返回指向该数组构造的二叉树的头节点的指针。

TreeNode* construct(vector<int>& nums)

确定终止条件

递归遍历时如果传入的数组大小为1，则说明遍历到了叶子节点，那么我们构造完叶子节点后就可以返回其值，表示遍历到了底部。这里根据题目要求无需考虑数组为空的情况。

if(nums.size() == 1){
    return new TreeNode(nums[0]);
}

确定单层递归的逻辑

找到数组中最大的元素及其下标，将最大的元素作为根节点，将其下标作为分割数组的标准

int maxValue = 0;
int maxValueIndex = 0;
for(int i = 0; i < nums.size()){
    if(nums[i] > maxValue){
        maxValue = nums[i];
        maxValueIndex = i;
    }
}
TreeNode* node = new TreeNode(maxValue);

构造根节点的左子树（保存数组区间的定义一致，这里坚持左闭右开[ ) ）

if(maxValueIndex > 0){
    vector<int> leftTree(nums.begin(), nums.begin() + maxValueIndex);
    node->left = construct(leftTree);
}

构造根节点的右子树

if(maxValueIndex < nums.size() - 1){
    vector<int> rightTree(nums.begin() + maxValueIndex + 1, nums.end());
    node->right = construct(rightTree);
}

整体代码如下：

/**
 * 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* constructMaximumBinaryTree(vector<int>& nums) {
        if(nums.size() == 1){
            return new TreeNode(nums[0]);
        }
        int maxValue = 0;
        int maxValueIndex = 0;
        for(int i = 0; i < nums.size(); i++){
            if(nums[i] > maxValue){
                maxValue = nums[i];
                maxValueIndex = i;
            }
        }
        TreeNode* node = new TreeNode(maxValue);
        if(maxValueIndex > 0){
            vector<int> leftTree(nums.begin(), nums.begin() + maxValueIndex);
            node->left = constructMaximumBinaryTree(leftTree);
        }
        if(maxValueIndex < nums.size() - 1){
            vector<int> rightTree(nums.begin() + maxValueIndex + 1, nums.end());
            node->right = constructMaximumBinaryTree(rightTree);
        }
        return node;
    }
};

以上代码比较冗余，效率也不高，每次还要切割的时候每次都要定义新的vector（也就是数组），但逻辑比较清晰。

优化思路就是每次分隔不用定义新的数组，而是通过下标索引直接在原数组上操作。

优化后代码如下：

/**
 * 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, int left, int right){
        if(left >= right)
            return NULL;
        int maxValueIndex = left;
        for(int i = left; i < right; i++){
            if(nums[i] > nums[maxValueIndex])
                maxValueIndex = i;
        }
        TreeNode* root = new TreeNode(nums[maxValueIndex]);

        // 左闭右开：[left, maxValueIndex)
        root->left = traversal(nums, left, maxValueIndex);

        // 左闭右开：[maxValueIndex + 1, right)
        root->right = traversal(nums, maxValueIndex + 1, right);

        return root;
    }

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

可以发现上面的代码看上去简洁一些，主要是因为第二版其实是允许空节点进入递归，所以不用在递归的时候加判断节点是否为空。当然终止条件也要有相应的改变：

第一版终止条件，是遇到叶子节点就终止，因为空节点不会进入递归。

第二版相应的终止条件，是遇到空节点，也就是数组区间为0，就终止了。

leetcode 617.合并二叉树

给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。

你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。

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

合并两个二叉树的过程，按照正常思维来说是从根节点开始，然后往下遍历依次合并。所以我们的遍历顺序最好选择前序遍历，其符合我们的思维逻辑，同样中序与后序遍历同样可以实现。

递归法

递归三部曲：

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

参数是传入的两个二叉树的根节点，返回值是新生成的二叉树的根节点。

TreeNode* mergeTree(TreeNode* t1, TreeNode* t2)

确定终止条件

由于是同时操作两个二叉树t1、t2，那么当t1为空节点时，合并的树就只有t2了（对两个树是同时遍历的，即实时遍历到的树的位置相对于其根节点是相同的），对于t2为空，同理合并的树只有t1。

if(t1 == NULL) return t2;
if(t2 == NULL) return t1;

是不是t1、t2均为空节点的情况在终止条件中没有体现呢？其实二者均为空时，if判断进入任何一个返回值均为NULL，满足我们的要求。

确定单层递归的逻辑

怎么给树的某一个节点凭空填加一个原本不存在的左右子树呢？其实只需将子树返回给上一个节点即可。

这里我们重复利用一下t1这个树，t1就是合并之后树的根节点（就是修改了原来树的结构），而不重新定义一棵新的二叉树了。

那么单层递归中，就要把两棵树的元素加到一起。

t1->val += t2->val;
t1->left = mergeTree(t1->left, t2->left);
t2->right = mergeTree(t1->right, t2->right);
return t1;

整体代码如下：

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

同理中序遍历和后序遍历也可以。

迭代法

使用迭代法同时对两个树进行处理，仍然使用队列，层序遍历：

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if (root1 == NULL) return root2; 
        if (root2 == NULL) return root1; 
        queue<TreeNode*> que;
        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;
    }
};

leetcode 700.二叉搜索树中的搜索

给定二叉搜索树（BST）的根节点和一个值。你需要在BST中找到节点值等于给定值的节点。返回以该节点为根的子树。如果节点不存在，则返回 NULL。

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

若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；

若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；

它的左、右子树也分别为二叉搜索树

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

递归法

递归三部曲：

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

递归函数的参数传入的就是根节点和要搜索的数值，返回的就是以这个搜索数值所在的节点。

TreeNode* searchBST(TreeNode* root, int val)

确定终止条件

如果我们找到了要搜索的数值，则返回当前节点；如果当前节点为空，则说明没有找到要搜索的数值，根据题目要求我们返回NULL。

if(root == NULL || root->val = val) return root;

确定单层递归的逻辑

因为二叉搜索树的节点是有序的，所以可以有方向的去搜索。

如果root->val > val，搜索左子树，如果root->val < val，就搜索右子树，最后如果都没有搜索到，就返回NULL。

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

迭代法

一提到二叉树遍历的迭代法，可能立刻想起使用栈来模拟深度遍历，使用队列来模拟广度遍历。

对于二叉搜索树可就不一样了，因为二叉搜索树的特殊性，也就是节点的有序性，可以不使用辅助栈或者队列就可以写出迭代法。对于一般二叉树，递归过程中还有回溯的过程，例如走一个左方向的分支走到头了，那么要调头，在走右分支。

而对于二叉搜索树，不需要回溯的过程，因为节点的有序性就帮我们确定了搜索的方向。

例如要搜索元素为3的节点，我们不需要搜索其他节点，也不需要做回溯，查找的路径已经规划好了。

中间节点如果大于3就向左走，如果小于3就向右走，如图：

代码如下：

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;
    }
};

leetcode 98.验证二叉搜索树

给定一个二叉树，判断其是否是一个有效的二叉搜索树。

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

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

所以说遇到搜索树，一定想着中序遍历，这样才能利用上特性。

递归法

可以递归中序遍历将二叉搜索树转变成一个数组，然后看这个数组是否有序即可：

/**
 * 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:
    vector<int> vec;
    void traversal(TreeNode* root){
        if(root == NULL) return;
        traversal(root->left);
        vec.push_back(root->val);
        traversal(root->right);
    }
public:
    bool isValidBST(TreeNode* root) {
        traversal(root);
        for(int i = 1; i < vec.size(); i++){
            if(vec[i] <= vec[i - 1]) return false;    // 二叉搜索树中不能有相等的值
        }
        return true;
    }
};

我们也可以在递归遍历中直接判断是否有序。

但是要特别注意的地方：不能单纯的比较左节点小于中间节点，右节点大于中间节点。

我们要比较的是左子树所有节点小于中间节点，右子树所有节点大于中间节点。如下：

上图满足左节点小于中间节点，右节点大于中间节点，但它并不是一个二叉搜索树。

而且leetcode中的样例节点数值可能出现int的最小值，所以我们不能使用INT_MIN来与之进行比较。此时可以初始化比较元素为longlong的最小值。

递归三部曲：

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

要定义一个longlong的全局变量，用来比较遍历的节点是否有序，因为后台测试数据中有int最小值，所以定义为longlong的类型，初始化为longlong最小值。返回值为bool型。

long long maxVal = LONG_MIN;
bool isValidBST(TreeNode* root)

确定终止条件

要注意空节点也为二叉搜索树，所以：

if(root == NULL) return true;

确定单层递归的逻辑

中序遍历，一直更新maxVal，一旦发现maxVal >= root->val，就返回false，注意元素相同时候也要返回false。

bool left = isValidBST(root->left);
if(maxVal < root->val)
    maxVal = root->val;
else
    return false;
bool right = isValidBST(root->right);
return left && right;

整体代码如下：

/**
 * 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:
    long long maxVal = LONG_MIN;
    bool isValidBST(TreeNode* root) {
        if(root == NULL) return true;
        bool left = isValidBST(root->left);
        if(maxVal < root->val)
            maxVal = root->val;
        else
            return false;
        bool right = isValidBST(root->right);
        return left && right;
    }
};

如果测试数据中有 longlong的最小值，怎么办？

不可能在初始化一个更小的值了吧。建议避免初始化最小值，如下方法取到最左面节点的数值来比较。

代码如下：

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;
    }
};

迭代法

栈中序遍历：

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 && cur->val <= pre->val)
                return false;
                pre = cur; //保存前一个访问的结点

                cur = cur->right;               // 右
            }
        }
        return true;
    }
};