Day15 层序遍历 226.翻转二叉树 101. 对称二叉树

最新推荐文章于 2024-09-27 15:30:00 发布

NoahNC

最新推荐文章于 2024-09-27 15:30:00 发布

阅读量39

点赞数

文章标签： leetcode 算法数据结构

本文链接：https://blog.csdn.net/lunareader/article/details/130231210

版权

文章介绍了多种与二叉树和N叉树层序遍历相关的算法，包括二叉树的层序遍历、层次遍历II、右视图、层平均值以及N叉树的层序遍历。此外，还涉及在每个树行中找最大值、填充节点的下一个右侧节点指针等问题的解法，主要利用队列进行层次遍历并处理节点信息。

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

层序遍历

102.二叉树的层序遍历

https://leetcode.cn/problems/binary-tree-level-order-traversal/
层序遍历：借助队列实现

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        queue<TreeNode*> que;
        if(root != NULL) que.push(root);
        while(!que.empty()){
            int size = que.size();
            vector<int> vec;
            while(size--){
                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);
            }
            res.push_back(vec);
        }
        return res;
    }
};

107.二叉树的层次遍历 II

https://leetcode.cn/problems/binary-tree-level-order-traversal-ii/

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> res;
        queue<TreeNode*> que;
        if(root != NULL) que.push(root);
        while(!que.empty()){
            int size = que.size();
            vector<int> vec;
            while(size--){
                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);
            }
            res.push_back(vec);
        }
        reverse(res.begin(), res.end());
        return res;
    }
};

199.二叉树的右视图

https://leetcode.cn/problems/binary-tree-right-side-view/
层序遍历的时候，判断是否遍历到单层的最后面的元素，如果是，就放进result数组中，随后返回result就可以了。

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

637.二叉树的层平均值

https://leetcode.cn/problems/average-of-levels-in-binary-tree/

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double> res;
        queue<TreeNode*> que;
        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);
            }
            res.push_back(sum / size);
        }
        return res;
    }
};

429.N叉树的层序遍历

https://leetcode.cn/problems/n-ary-tree-level-order-traversal/


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

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

https://leetcode.cn/problems/find-largest-value-in-each-tree-row/

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

116.填充每个节点的下一个右侧节点指针

https://leetcode.cn/problems/populating-next-right-pointers-in-each-node/
本题依然是层序遍历，只不过在单层遍历的时候记录一下本层的头部节点，然后在遍历的时候让前一个节点指向本节点就可以了

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

117.填充每个节点的下一个右侧节点指针II

https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii/

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

104.二叉树的最大深度

https://leetcode.cn/problems/maximum-depth-of-binary-tree/

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

111.二叉树的最小深度

https://leetcode.cn/problems/minimum-depth-of-binary-tree/
只有当左右孩子都为空的时候，才说明遍历的最低点了。如果其中一个孩子为空则不是最低点

class Solution {
public:
    int minDepth(TreeNode* root) {
        queue<TreeNode*> que;
        int res = 0;
        if(root != NULL) que.push(root);
        while(!que.empty()){
            int size = que.size();
            res++;
            while(size--){
                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 res;
            }
        }
        return res;
    }
};

226.翻转二叉树

https://leetcode.cn/problems/invert-binary-tree/
只要把每一个节点的左右孩子翻转一下，就可以达到整体翻转的效果
这道题目使用前序遍历和后序遍历都可以，唯独中序遍历不方便，因为中序遍历会把某些节点的左右孩子翻转了两次

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

101. 对称二叉树

https://leetcode.cn/problems/symmetric-tree/
对于二叉树是否对称，要比较的是根节点的左子树与右子树是不是相互翻转的，理解这一点就知道了其实我们要比较的是两个树（这两个树是根节点的左右子树），所以在递归遍历的过程中，也是要同时遍历两棵树。
本题遍历只能是“后序遍历”，因为我们要通过递归函数的返回值来判断两个子树的内侧节点和外侧节点是否相等。
正是因为要遍历两棵树而且要比较内侧和外侧节点，所以准确的来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中。

class Solution {
public:
    bool cmp(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;
        else{
            bool out = cmp(left->left, right->right);
            bool in = cmp(left->right, right->left);
            bool isSame = out && in;
            return isSame;
        }
    }
    bool isSymmetric(TreeNode* root) {
        if(root == NULL) return true;
        return cmp(root->left, root->right);
    }
};