代码随想录Day15—二叉树part02

最新推荐文章于 2024-11-07 23:24:07 发布

欢仔今天学习了嘛

最新推荐文章于 2024-11-07 23:24:07 发布

阅读量55

点赞数

文章标签：算法 c++ 开发语言 leetcode 数据结构

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

版权

文章介绍了如何使用队列实现二叉树的层序遍历，即广度优先搜索，以及如何通过递归方法翻转二叉树和检查二叉树的对称性。层序遍历借助队列完成，翻转通过交换节点的左右子树实现，对称性检查则通过比较左右子树的翻转关系进行。

摘要由CSDN通过智能技术生成

1. 102二叉树的层序遍历

题目：给你一个二叉树，请你返回其按 层序遍历 得到的节点值。（即逐层地，从左到右访问所有节点）

层序遍历需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。

而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上

使用队列实现二叉树广度优先遍历，动画如下：

解题步骤如下：

定义一个队列（用以模拟层序遍历过程），定义一个二维数组（记录遍历的元素）
将根节点压入队列，当队列不为空时，记录每层的size，在size范围内循环进行遍历

代码如下：

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

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

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != nullptr) que.push(root); // 如果根节点不为空，将根节点压入队列中
        vector<vector<int>> result; // 存放每一层的节点值
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec; // 存放每一层的节点值
            while (size--) { // 将当前层的节点全部取出
                TreeNode* cur = que.front(); // 取出队首元素, cur指向队首元素
                que.pop();
                vec.push_back(cur->val); // 将当前节点的值存入数组中
                if (cur->left != nullptr) que.push(cur->left);
                if (cur->right != nullptr) que.push(cur->right);
            }
            result.push_back(vec); // 将每一层的节点值存入数组中
        }
        return result;
    }
};

int main(void) {
    Solution solu;
    TreeNode* root = new TreeNode(3);
    root->left = new TreeNode(9);
    root->right = new TreeNode(20);
    root->right->left = new TreeNode(15);
    root->right->right = new TreeNode(7);
    vector<vector<int>> result = solu.levelOrder(root);

    for (auto vec : result) { // auto自动识别类型, vec为result的每一行
        for (auto num : vec) { // num为vec的每一个元素
            cout << num << "\t";
        }
        cout << endl;
    }
    system("pause");
    return 0;
}

2. 226翻转二叉树

题目：翻转一颗二叉树

递归法：(前序）

代码如下：

#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* invertTree(TreeNode* cur) {
        if (cur == nullptr) return cur; // 如果当前节点为空，直接上一层递归
        swap(cur->left, cur->right); // 交换当前节点的左右子树
        invertTree(cur->left);  // 递归翻转左子树
        invertTree(cur->right); // 递归翻转右子树
        return cur;
    }
};

int main(void) {
    Solution solu;
    TreeNode* root = new TreeNode(4);
    root->left = new TreeNode(2);
    root->right = new TreeNode(7);
    root->left->left = new TreeNode(1);
    root->left->right = new TreeNode(3);
    root->right->left = new TreeNode(6);
    root->right->right = new TreeNode(9);
    TreeNode* result = solu.invertTree(root); // root为根节点, 为实参, 传入形参cur,cur为当前节点
    cout << result->val << endl;
    cout << result->left->val << " " << result->right->val << endl;
    cout << result->left->left->val << " " << result->left->right->val << " " << result->right->left->val << " " << result->right->right->val << endl;
    system("pause");
    return 0;
}

3. 101对称二叉树

题目：给定一个二叉树，检查它是否是镜像对称的。

思路：

对于二叉树是否对称，要比较的是根节点的左子树与右子树是不是相互翻转的，所以要比较的是两个树

只能采用后序遍历，要通过递归函数的返回值判断两个子树的内侧节点和外侧节点是否相等
正是因为要遍历两棵树而且要比较内侧和外侧节点，所以准确的来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中

递归法：

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

比较根节点的左子树和右子树是否可以翻转，参数是左子树节点和右子树节点

bool compare(TreeNode* left, TreeNode* right)

2.确定终止条件

要比较两个节点数值是否相同，首先要把两个节点为空的情况弄清楚！否则可能操作空指针

节点为空的情况有：

左节点为空，右节点不为空，不对称，return false
左不为空，右为空，不对称，return false
左右都为空，对称，返回true

节点不为空的情况：

左右都不为空，比较节点数值，不相同就 return false

代码如下：

if (left == nullptr && right != nullptr) return false;
else if (left != nullptr && right == nullptr) return false;
else if (left == nullptr && right == nulllptr) return true;
else if (left->val != right->val) return flase; // 注意没有使用else

注意上面最后一种情况，没有使用else，而是else if，因为把上述情况排除后，剩下的就是左右节点都不为空，且数值相等的情况

3.确定单层递归的逻辑

此时才进入单层递归的逻辑，单层递归的逻辑就是处理左右节点都不为空，且数值相同的情况（默认往下走，继续遍历）。

比较二叉树外侧是否对称：传入的是左节点的左孩子，右节点的右孩子
比较内侧是否对称，传入左节点的右孩子，右节点的左孩子
如果左右都对称就返回true，有一侧不对称就返回false

代码如下：

bool outside = compare(left->left, right->right); // 左子树：左、右子树：右
bool inside =  compare(left->right, right->left); // 左子树：右、右子树：左
bool isSame = outside && inside; // 左子树：中、右子树：中（逻辑处理）
return isSame;

完整代码如下：

#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.确定递归函数的参数和返回值
    bool compare(TreeNode* left, TreeNode* right) {
        // 2.确定终止条件
        // 2.1排除空节点情况
        if (left == nullptr && right != nullptr)  return false;
        else if (left != nullptr && right == nullptr)  return false;
        else if (left == nullptr && right == nullptr) return true;
        // 2.2排除数值不相同的情况
        else if (left->val != right->val) return false;

        // 此时就是：左右节点都不为空，其数值相等的情况。
        // 3.确定单层递归的逻辑
        bool outside = compare(left->left, right->right); // 外侧
        bool inside = compare(left->right, right->left); // 内侧
        bool isSame = outside && inside; //中
        return isSame;
    }
    bool isSymmetric(TreeNode* root) {
        if (root == nullptr) return true;
        return compare(root->left, root->right);
    }
};

int main(void) {
    Solution solu;
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(2);
    root->left->left = new TreeNode(3);
    root->left->right = new TreeNode(4);
    root->right->left = new TreeNode(4);
    root->right->right = new TreeNode(3); // 1 2 2 3 4 4 3
    cout << solu.isSymmetric(root) << endl;

    system("pause");
    return 0;
}