代码随想录算法训练营第十三天 | 层序遍历； 226.翻转二叉树；101.对称二叉树

a729053228

已于 2023-09-07 18:01:18 修改

阅读量48

点赞数

文章标签：算法数据结构

于 2023-09-07 17:36:36 首次发布

本文链接：https://blog.csdn.net/a729053228/article/details/132724921

版权

102. 二叉树的层序遍历

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

头节点入队，循环；出队；如果左节点不空左节点入队，如果右节点不空右节点入队；

107. 二叉树的层序遍历 II

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

记住是while里面套了一个for循环；

199. 二叉树的右视图

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

跟层序遍历的基本思路还是一样，只是再push_back的时候，加入判断i==size-1，判断是否最右边的结点；

637. 二叉树的层平均值

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

注意每个for循环是循环一层，里面的结点就是一层的结点，数量为size是动态变化的，只是加一个sum作用统计和，最后计算一下平均值即可；

429. N 叉树的层序遍历

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* cur = que.front();
                que.pop();
                vec.push_back(cur->val);
                for(int i =0;i<cur->children.size();i++){
                    if(cur->children[i]!=NULL){
                        que.push(cur->children[i]);
                    }
                }
            }
            result.push_back(vec);
        }
        return result;
    }
};

模板还是层序遍历的模板，但是注意孩子结点加入队列的时候的写法，i<cur->children.size()，如果孩子节点不空，将其加入队列；

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

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

注意最大值初始化时需要赋值为INT_MIN，不能为0否则不对；

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

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if(root!=NULL) que.push(root);
        while(!que.empty()){
            int size = que.size();
            Node* prenode;
            Node* node;
            for(int i = 0;i<size;i++){
                if(i==0){
                    prenode = que.front();
                    que.pop();
                    node = prenode;
                }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;
    }
};

这个也是层序遍历，不过稍微有些难度，思路就是定义一个nodepre记录之前的结点，每次for循环时让其指向node结点即可；

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

跟上一题一模一样的代码；

104. 二叉树的最大深度

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

比较简单；

111. 二叉树的最小深度

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

加了一下判断，当左右子树都为空时，为最小的深度的结点；

226. 翻转二叉树

递归法：

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) {
        stack<TreeNode*> stk;
        if(root!=NULL) stk.push(root);
        while(!stk.empty()){
            TreeNode* cur = stk.top();
            stk.pop();
            swap(cur->left,cur->right);
            if(cur->right) stk.push(cur->right);
            if(cur->left) stk.push(cur->left);
        }
        return root;
    }
};

101. 对称二叉树

递归法：

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 result = outside && inside;
        return result;
    }
    bool isSymmetric(TreeNode* root) {
        if(root==NULL) return true;
        return compare(root->left,root->right);
    }
};

层序遍历迭代法；

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        queue<TreeNode*> que;
        if(root==NULL) return true;
        que.push(root->left);
        que.push(root->right);
        while(!que.empty()){
            TreeNode* leftnode = que.front(); que.pop();
            TreeNode* rightnode = que.front(); que.pop();
            if(leftnode==NULL&&rightnode==NULL){
                continue;
            }
            if ((!leftnode || !rightnode || (leftnode->val != rightnode->val))) {
                return false;
            }
            que.push(leftnode->left);
            que.push(rightnode->right);
            que.push(leftnode->right);
            que.push(rightnode->left);
        }
        return true;
    }
};

入队顺序：左的左，右的右；

a729053228

关注

0
点赞
踩
0

收藏

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

模板还是层序遍历的模板，但是注意孩子结点加入队列的时候的写法，ichildren.size()，如果孩子节点不空，将其加入队列；注意每个for循环是循环一层，里面的结点就是一层的结点，数量为size是动态变化的，只是加一个sum作用统计和，最后计算一下平均值即可；跟层序遍历的基本思路还是一样，只是再push_back的时候，加入判断i==size-1，判断是否最右边的结点；加了一下判断，当左右子树都为空时，为最小的深度的结点；入队顺序：左的左，右的右；跟上一题一模一样的代码；
复制链接

扫一扫