代码随想录算法训练营第十五天 | 层序遍历、翻转二叉树、对称二叉树

Yirschen

已于 2024-01-08 21:35:21 修改

阅读量91

点赞数

文章标签： leetcode

于 2023-04-19 21:56:01 首次发布

本文链接：https://blog.csdn.net/Yirschen/article/details/130254418

版权

层序遍历

利用队列来实现。

文档讲解：代码随想录 (programmercarl.com)

视频讲解：讲透二叉树的层序遍历 | 广度优先搜索 | LeetCode：102.二叉树的层序遍历_哔哩哔哩_bilibili

代码0：不要求区分是哪一层。

void levelOrder(TreeNode* root) {
    if(root == nullptr) return;
    queue<TreeNode*> que;
    que.push(root);

    while(!que.empty()){    
        TreeNode* node = que.front();
        que.pop();
        cout << node->val << " ";
        
        if(node->left) que.push(node->left);    //左孩子入队
        if(node->right) que.push(node->right);  //右孩子入队
    }
};

代码1：结果存到二维vector，里面每个一维vector表示一层的节点值。LeetCode102

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        queue<TreeNode*> que;
        if(root != nullptr) que.push(root);

        while(!que.empty()){    // while循环每遍历一次，就遍历一层
            int size = que.size();  //!!!!当前层中的节点个数
            vector<int> vec;    //存放当前层中的节点的值

            // !!这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            for(int i = 0; i < size; ++i){  //!遍历当前层中的各个节点，弹出节点处理并将左右孩子入队
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if(node->left) que.push(node->left);    //左孩子入队
                if(node->right) que.push(node->right);  //右孩子入队
            }
            result.push_back(vec);  //将当前层的节点值存到二维vector，里面每个一维vector都包含一层节点值
        }
        return result;
    }
};

翻转二叉树（优先掌握递归）

文章讲解：代码随想录 (programmercarl.com)

视频讲解：听说一位巨佬面Google被拒了，因为没写出翻转二叉树 | LeetCode：226.翻转二叉树_哔哩哔哩_bilibili

状态：能直接写出，但是细节有些没去想。

思路

其实就把每一个节点的左右孩子交换一下就可以了。

关键在于遍历顺序，前中后序应该选哪一种遍历顺序？（一些同学这道题都过了，但是不知道自己用的是什么顺序）

注意只要把每一个节点的左右孩子翻转一下，就可以达到整体翻转的效果

这道题目使用前序遍历和后序遍历都可以，唯独中序遍历不方便，因为中序遍历会把某些节点的左右孩子翻转了两次！建议拿纸画一画，就理解了

那么层序遍历可以不可以呢？依然可以的！只要把每一个节点的左右孩子翻转一下的遍历方式都是可以的！

/*前序递归*/
class Solution {
public:
    void trans(TreeNode* node){
        if(node == nullptr) return;
        swap(node->left, node->right);
        if(node->left) trans(node->left);
        if(node->right) trans(node->right);
    }

    TreeNode* invertTree(TreeNode* root) {
        trans(root);
        return root;
    }
};

/*前序迭代*/
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        stack<TreeNode*> st;

        if(root != nullptr) st.push(root);
        while(!st.empty()){
            TreeNode* node = st.top();
            st.pop();
            swap(node->left, node->right);

            if(node->right) st.push(node->right);
            if(node->left) st.push(node->left);
        }
        return root;

    }
};

/*后序递归*/
class Solution {
public:
    void trans(TreeNode* node){
        if(node == nullptr) return;
        if(node->left) trans(node->left);
        if(node->right) trans(node->right);
        swap(node->left, node->right);
    }

    TreeNode* invertTree(TreeNode* root) {
        trans(root);
        return root;
    }
};

/*层序遍历*/
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        queue<TreeNode*> que;
        if(root != nullptr) que.push(root);
        while(!que.empty()){
            int size = que.size();
            for(int i = 0; i < size; ++i){
                TreeNode* node = que.front();
                que.pop();
                swap(node->left, node->right);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return root;
    }
};

对称二叉树（优先掌握递归）

文档讲解：代码随想录 (programmercarl.com)

视频讲解：新学期要从学习二叉树开始！ | LeetCode：101. 对称二叉树_哔哩哔哩_bilibili

状态：做不出来。

思路

对于二叉树是否对称，要比较的是根节点的左子树与右子树是不是相互翻转的，理解这一点就知道了其实我们要比较的是两个树（这两个树是根节点的左右子树），所以在递归遍历的过程中，也是要同时遍历两棵树。

那么如何比较呢？比较的是两个子树的里侧和外侧的元素是否相等。如图所示：

那么遍历的顺序应该是什么样的呢？

！！本题遍历只能是“后序遍历”，因为要不断地收集左右孩子的信息返回给父节点，我们要通过递归函数的返回值来判断两个子树的内侧节点和外侧节点是否相等。

正是因为要遍历两棵树而且要比较内侧和外侧节点，所以准确的来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中。 但都可以理解算是后序遍历，尽管已经不是严格上在一个树上进行遍历的后序遍历了。

利用递归三部曲实现
确定递归函数的参数和返回值

因为要比较的是根节点的两个子树是否是相互翻转的，进而判断这个树是不是对称树，所以要比较的是两个树，参数自然也是左子树节点和右子树节点。返回值自然是bool类型。
bool compare(TreeNode* left, TreeNode* right)
确定终止条件

要比较两个节点数值相不相同，首先要把两个节点为空的情况弄清楚！否则后面比较数值的时候就会操作空指针了。

节点为空的情况有：（注意我们比较的其实不是左孩子和右孩子，所以如下我称之为左节点右节点）

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

此时已经排除掉了节点为空的情况，那么剩下的就是左右节点不为空：

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

此时左右节点不为空，且数值也不相同的情况我们也处理了。
if (left == NULL && right != NULL) return false;
else if (left != NULL && right == NULL) return false;
else if (left == NULL && right == NULL) return true;
else if (left->val != right->val) return false; // 注意这里我没有使用else
把以上情况都排除之后，剩下的就是左右节点都不为空，且数值相同的情况。
确定单层递归的逻辑（上图红色框部分）

此时才进入单层递归的逻辑，单层递归的逻辑就是处理 左右节点都不为空，且数值相同的情况。

比较二叉树外侧是否对称：传入的是左节点的左孩子，右节点的右孩子。
比较内测是否对称，传入左节点的右孩子，右节点的左孩子。
如果左右都对称就返回true ，有一侧不对称就返回false 。
/*红色框部分*/
bool outside = compare(left->left, right->right);   // 左子树：左、 右子树：右
bool inside = compare(left->right, right->left);    // 左子树：右、 右子树：左
bool isSame = outside && inside;                    // 左子树：中、 右子树：中（逻辑处理）
return isSame;
如上代码中，我们可以看出使用的遍历方式，左子树左右中，右子树右左中，所以我把这个遍历顺序也称之为“后序遍历”（尽管不是严格的后序遍历）。

代码

class Solution {
public:
    bool compare(TreeNode* left, TreeNode* right) {
        /*注意：这里是对根节点的下一层进行比较*/
        // 首先排除空节点的情况
        if (left == NULL && right != NULL) return false;
        else if (left != NULL && right == NULL) return false;
        else if (left == NULL && right == NULL) return true;
        // 排除了空节点，再排除数值不相同的情况
        else if (left->val != right->val) return false;

        // 此时就是：左右节点都不为空，且数值相同的情况（上图第二层）
        // 此时才做递归，做下一层的判断（红色框部分）
        /*这里是对根节点的下下一层进行比较*/
        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 == NULL) return true;
        return compare(root->left, root->right);
    }
};

该题总结

需要用一个递归函数来比较两棵树，可以把这两棵树的指针分别作为函数参数传入，然后进行处理。
因为要用树A的左侧和树B的右侧比较、树A的右侧和树B的左侧比较，也就是对称关系；而两棵树是同时遍历的，所以他们的遍历顺序要对称，所以想到 “左右中”和“右左中”对称，两棵树各选一种遍历方式 即可，每棵树用哪个遍历没关系。
这道题的核心就是用一个函数来完成两棵树的遍历，而且遍历方式有些许不同。
这道题的终止条件很多种，要先处理好。

层序遍历的相关题目

LeetCode107：将层序遍历的结果存到二维vector，将该二维vector取反即可。

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> result;
        queue<TreeNode*> que;
        if(root != nullptr) que.push(root);
        while(!que.empty()){
            vector<int> vec;
            int size = que.size();
            for(int i = 0; i < size; ++i){
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            result.push_back(vec);
        }
        reverse(result.begin(), result.end());
        return result;
    }
};

LeetCode199：层序遍历每一层时，保留最后一个元素值，即for循环的最后一个i时保留。

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<int> result;
        queue<TreeNode*> que;
        if(root != nullptr) que.push(root);
        while(!que.empty()){
            int size = que.size();
            for(int i = 0 ;i < size; ++i){
                TreeNode* node = que.front();
                que.pop();

                if(i == size - 1){
                    result.push_back(node->val);
                }
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return result;
    }
};

LeetCode637

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double> result;
        queue<TreeNode*> que;
        if(root != nullptr) que.push(root);
        while(!que.empty()){
            int size = que.size();
            double sum = 0;
            for(int i = 0; i < size; ++i){
                TreeNode* node = que.front();
                que.pop();
                sum += node->val;
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            result.push_back(sum / size);
        }
        return result;
    }
};

Yirschen

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
代码随想录算法训练营第十五天 | 层序遍历、翻转二叉树、对称二叉树

*正是因为要遍历两棵树而且要比较内侧和外侧节点，所以准确的来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中。因为要比较的是根节点的两个子树是否是相互翻转的，进而判断这个树是不是对称树，所以要比较的是两个树，参数自然也是左子树节点和右子树节点。如上代码中，我们可以看出使用的遍历方式，左子树左右中，右子树右左中，所以我把这个遍历顺序也称之为“后序遍历”（尽管不是严格的后序遍历）。对于二叉树是否对称，要比较的是根节点的左子树与右子树是不是相互翻转的，理解这一点就知道了。那么遍历的顺序应该是什么样的呢？
复制链接

扫一扫