代码随想录算法训练营第十五天|102.二叉树的层序遍历（十个题）、226.翻转二叉树、101.对称二叉树

最新推荐文章于 2024-08-05 20:49:33 发布

吾恩日记

最新推荐文章于 2024-08-05 20:49:33 发布

阅读量1k

点赞数 37

文章标签：算法

本文链接：https://blog.csdn.net/m0_62792363/article/details/136888949

版权

文档链接：代码随想录

LeetCode102.二叉树的层序遍历

题目链接：https://leetcode.cn/problems/binary-tree-level-order-traversal/

思路：用队列存储二叉树的每一层！

代码：

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

LeetCode107.二叉树的层序遍历Ⅱ

题目链接：https://leetcode.cn/problems/binary-tree-level-order-traversal-ii/

思路：最后reverse一下result数组即可。

代码：

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        queue<TreeNode*> que;
        vector<vector<int>> result;
        if(root != NULL) que.push(root);
        while(!que.empty()) {
            int size = que.size();
            vector<int> vec;
            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.二叉树的右视图

题目链接：https://leetcode.cn/problems/binary-tree-right-side-view/

思路：插入result之前判断一下是否为二叉树的最右边节点即可。

代码：

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> que;
        vector<int> result;
        if(root != NULL) 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.二叉树的层平均值

题目链接：https://leetcode.cn/problems/average-of-levels-in-binary-tree/

思路：记录一下每一层的和，插入result之前取一下平均值即可。

代码：

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        queue<TreeNode*> que;
        vector<double> result;
        if(root != NULL) 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;
    }
};

LeetCode429.N叉树的层序遍历

题目链接：https://leetcode.cn/problems/n-ary-tree-level-order-traversal/

思路：一样的思路，多插入几个节点。

代码：

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        queue<Node*> que;
        vector<vector<int>> result;
        if(root != NULL) que.push(root);
        while(!que.empty()) {
            int size = que.size();
            vector<int> vec;
            for(int i = 0; i < size; i++) {
                Node* node = que.front();
                que.pop();
                vec.push_back(node->val);
                for(int j = 0; j < node->children.size(); j++) {
                    if(node->children[j]) que.push(node->children[j]);
                }
            }
            result.push_back(vec);
        }
        return result;
    }
};

LeetCode515.在每个树行中找最大值

题目链接：https://leetcode.cn/problems/find-largest-value-in-each-tree-row/

思路：一样的。

代码：

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

LeetCode116.补充每一个节点的下一个右侧节点指针、117.补充每一个节点的下一个右侧节点指针Ⅱ

题目链接：https://leetcode.cn/problems/populating-next-right-pointers-in-each-node/

思路：两题一样的代码

代码：

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if(root) que.push(root);
        while(!que.empty()) {
            int size = que.size();
            for(int i = 0; i < size; i++) {
                Node* node = que.front();
                que.pop();
                if(i == size - 1) {
                    node->next = NULL;
                } else {
                    node->next = que.front();
                }
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return root;
    }
};

LeetCode104.二叉树的最大深度

题目链接：https://leetcode.cn/problems/maximum-depth-of-binary-tree/

思路：找个变量depth记录一下即可。

代码：

class Solution {
public:
    int maxDepth(TreeNode* root) {
        queue<TreeNode*> que;
        int depth = 0;
        if(root) que.push(root);
        while(!que.empty()) {
            int size = que.size();
            for(int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            depth++;
        }
        return depth;
    }
};

LeetCode111.二叉树的最小深度

题目链接：https://leetcode.cn/problems/minimum-depth-of-binary-tree/

思路：只有当左右孩子都空时才说明到底了，此时返回depth

代码：

class Solution {
public:
    int minDepth(TreeNode* root) {
        queue<TreeNode*> que;
        if(root) que.push(root);
        int depth = 0;
        while(!que.empty()) {
            int size = que.size();
            depth++;
            for(int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
                if(!node->left && !node->right) return depth;
            }
        }
        return depth;
    }
};

LeetCode226.翻转二叉树

题目链接：. - 力扣（LeetCode）

思路：可以使用前序遍历、后序遍历、层序遍历，不建议使用中序遍历。

前序遍历：

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(root == NULL) return root;
        swap(root->left, root->right);
        invertTree(root->left);
        invertTree(root->right);
        return root;
    }
};

层序遍历：

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        queue<TreeNode*> que;
        if(root != NULL) 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 != NULL) que.push(node->left);
                if(node->right != NULL) que.push(node->right);
            }
        }
        return root;
    }
};

LeetCode101.对称二叉树

题目链接：https://leetcode.cn/problems/symmetric-tree/

思路：用后序遍历（其实我自己感觉用层序遍历+栈也能实现，只不过我自己实现的时候老是有问题），明确熟悉递归三部曲。

本题遍历只能是“后序遍历”，因为我们要通过递归函数的返回值来判断两个子树的内侧节点和外侧节点是否相等。

正是因为要遍历两棵树而且要比较内侧和外侧节点，所以准确的来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中。

但都可以理解算是后序遍历，尽管已经不是严格上在一个树上进行遍历的后序遍历了。

后序遍历：

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 false;
        return compare(root->left, root->right);
    }
};

总结：不知道补第几天的任务了，因为层序遍历那十道题加上这周一些乱七八糟的事打乱了我原本的计划，已经在尽力找补了。层序遍历已经差不多掌握了，这个对称二叉树的思想还不算完全掌握。加油！跟上进度，不要掉队！

吾恩日记

关注

37
点赞
踩
17

收藏

觉得还不错? 一键收藏
1
评论
代码随想录算法训练营第十五天|102.二叉树的层序遍历（十个题）、226.翻转二叉树、101.对称二叉树

总结：不知道补第几天的任务了，因为层序遍历那十道题加上这周一些乱七八糟的事打乱了我原本的计划，已经在尽力找补了。思路：用后序遍历（其实我自己感觉用层序遍历+栈也能实现，只不过我自己实现的时候老是有问题），明确熟悉递归三部曲。LeetCode116.补充每一个节点的下一个右侧节点指针、117.补充每一个节点的下一个右侧节点指针Ⅱ。本题遍历只能是“后序遍历”，因为我们要通过递归函数的返回值来判断两个子树的内侧节点和外侧节点是否相等。但都可以理解算是后序遍历，尽管已经不是严格上在一个树上进行遍历的后序遍历了。
复制链接

扫一扫