代码随想录Day20—二叉树part06

最新推荐文章于 2024-07-25 21:08:08 发布

欢仔今天学习了嘛

最新推荐文章于 2024-07-25 21:08:08 发布

阅读量85

点赞数

文章标签：算法数据结构 c++

本文链接：https://blog.csdn.net/XPZGG233/article/details/131447596

版权

1. 654最大二叉树

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

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

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

示例：

思路：

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

解题步骤：

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

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

2.确定终止条件

题目要求输入的数组一定是大于等于1的，所以我们不用考虑小于1的情况，那么当递归遍历的时候，如果传入的数组大小为1，说明遍历到了叶子节点了。

那么应该定义一个新的节点，并把这个数组的数值赋给新的节点，然后返回这个节点。这表示一个数组大小是1的时候，构造了一个新的节点，并返回。

3.确定单层递归的逻辑

先找到数组中最大值及其下标，最大的值构造根节点，下标用来下一步分割数组
最大值所在的下标左区间构造左子树
最大值所在的下标右区间构造右子树

代码如下：

#include<iostream>
#include<vector>
using namespace std;

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

class Solution {
public:
    // 1.确定递归函数的参数和返回值
    TreeNode* traversal(vector<int>& nums) {
        // 2.确定终止条件
        TreeNode* node = new TreeNode(0);
        if (nums.size() == 1) {
            node->val = nums[0];
            return node;
        }
        // 3.确定单层递归的逻辑
        // 3.1找到数组中最大的值和对应的下标
        int maxValue = 0;
        int index = 0;
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] > maxValue) {
                maxValue = nums[i];
                index = i;
            }
        }
        node->val = maxValue;
        // 3.2最大值所在的下标左区间 构造左子树
        if (index > 0) {
            vector<int> newVec(nums.begin(), nums.begin() + index);
            node->left = traversal(newVec);
        }
        // 3.3最大值所在的下标右区间 构造右子树
        if (index < (nums.size() - 1)) {
            vector<int> newVec(nums.begin() + index + 1, nums.end());
            node->right = traversal(newVec);
        }
        return node;
    }

    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        return traversal(nums);
    }
};

int main(void) {
    Solution solu;
    vector<int> nums = { 3,2,1,6,0,5 };
    TreeNode* root = solu.constructMaximumBinaryTree(nums);
    cout << root->val << endl;
    cout << root->left->val << " " << root->right->val << endl;
    cout << root->left->right->val << " " << root->right->left->val << endl;
    cout << root->left->right->right->val << endl;
    system("pause");
    return 0;
}

2. 617合并二叉树

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

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

示例:

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

思路：

和遍历一个树逻辑是一样的，只不过传入两个树的节点，同时操作。

解题步骤：

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

首先要合入两个二叉树，那么参数至少是要传入两个二叉树的根节点，返回值就是合并之后二叉树的根节点。

2.确定终止条件

因为是传入了两个树，那么就有两个树遍历的节点t1 和 t2，如果t1 == NULL 了，两个树合并就应该是 t2 了（如果t2也为NULL也无所谓，合并之后就是NULL）。

反过来如果t2 == NULL，那么两个数合并就是t1（如果t1也为NULL也无所谓，合并之后就是NULL）

3.确定单层递归的逻辑

单层递归的逻辑就比较好写了，这里我们重复利用一下t1这个树，t1就是合并之后树的根节点（就是修改了原来树的结构）。

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

接下来t1 的左子树是：合并 t1左子树 t2左子树之后的左子树。

t1 的右子树：是合并 t1右子树 t2右子树之后的右子树。

最终t1就是合并之后的根节点。

代码如下：

#include<iostream>
#include<vector>
using namespace std;

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        if (t1 == nullptr) return t2;
        if (t2 == nullptr) return t1;
        t1->val += t2->val;
        t1->left = mergeTrees(t1->left, t2->left);
        t1->right = mergeTrees(t1->right, t2->right);
        return t1;
    }
};

int main(void) {
    Solution solu;
    TreeNode* t1 = new TreeNode(1);
    t1->left = new TreeNode(3);
    t1->right = new TreeNode(2);
    t1->left->left = new TreeNode(5);
    TreeNode* t2 = new TreeNode(2);
    t2->left = new TreeNode(1);
    t2->right = new TreeNode(3);
    t2->left->right = new TreeNode(4);
    t2->right->right = new TreeNode(7);
    TreeNode* root = solu.mergeTrees(t1, t2);
    // 输出结果
    cout << root->val << endl;
    cout << root->left->val << " " << root->right->val << endl;
    cout << root->left->left->val << " " << root->left->right->val << " " << root->right->right->val << endl;
    system("pause");
    return 0;
}

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

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

例如，

在上述示例中，如果要找的值是 5，但因为没有节点值为 5，我们应该返回 NULL。

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

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

解题步骤：

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

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

2.确定终止条件

如果root为空，或者找到这个数值了，就返回root节点。

3.确定单层递归的逻辑

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

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

代码如下：

#include<iostream>
#include<vector>
using namespace std;

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        if (t1 == nullptr) return t2;
        if (t2 == nullptr) return t1;
        t1->val += t2->val;
        t1->left = mergeTrees(t1->left, t2->left);
        t1->right = mergeTrees(t1->right, t2->right);
        return t1;
    }
};

int main(void) {
    Solution solu;
    TreeNode* t1 = new TreeNode(1);
    t1->left = new TreeNode(3);
    t1->right = new TreeNode(2);
    t1->left->left = new TreeNode(5);
    TreeNode* t2 = new TreeNode(2);
    t2->left = new TreeNode(1);
    t2->right = new TreeNode(3);
    t2->left->right = new TreeNode(4);
    t2->right->right = new TreeNode(7);
    TreeNode* root = solu.mergeTrees(t1, t2);
    // 输出结果
    cout << root->val << endl;
    cout << root->left->val << " " << root->right->val << endl;
    cout << root->left->left->val << " " << root->left->right->val << " " << root->right->right->val << endl;
    system("pause");
    return 0;
}

4. 98验证二叉搜索时

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

假设一个二叉搜索树具有如下特征：

节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。

解题步骤：

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

只有寻找某一条边（或者一个节点）的时候，递归函数会有bool类型的返回值。

本题旨在寻找一个不符合条件的节点，如果没有找到这个系欸但那就遍历了整个树，如果找到不符合的节点，立刻返回。

2.确定终止条件

如果是空节点是不是二叉搜索树呢？

是的，二叉搜索树也可以为空！

3.确定单层递归的逻辑

中序遍历，定义两个指针，一个是当前节点，一个是前一个节点，只要当前节点比前一个节点大，就返回true

代码如下：

#include<iostream>
#include<vector>
using namespace std;

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

class Solution {
public:
    TreeNode* pre = nullptr; // 用来记录前一个节点
    bool isValidBST(TreeNode* root) {
        if (root == nullptr) return true;
        bool left = isValidBST(root->left); //左

        if (pre != nullptr && pre->val >= root->val) return false; //处理逻辑
        pre = root;

        bool right = isValidBST(root->right);
        return left && right;
    }
};

int main(void) {
    Solution solu;
    TreeNode* root = new TreeNode(5);
    root->left = new TreeNode(1);
    root->right = new TreeNode(4);
    root->right->left = new TreeNode(3);
    root->right->right = new TreeNode(6);
    bool result = solu.isValidBST(root);
    cout << result << endl; // false
    system("pause");
    return 0;
}