代码随想录算法训练营day15 | ● 层序遍历 10 ● 226.翻转二叉树 ● 101.对称二叉树 2

合集 - 代码随想录(16)
1.代码随想录算法训练营第二天| 977.有序数组的平方，209.长度最小的子数列，59.螺旋矩阵Ⅱ2.代码随想录算法训练营第一天| 704. 二分查找、27. 移除元素3.代码随想录算法训练营第三天| 203.移除链表元素 707.设计链表 206.反转链表4.代码随想录算法训练营第四天| 24. 两两交换链表中的节点, 19.删除链表的倒数第N个结点，面试题02.07.链表相交，142.环形链表Ⅱ5.代码随想录算法训练营第六天| 242.有效的字母异位词，349.两个数组的交集，202.快乐数，1.两数之和6.代码随想录算法训练营第7天| ● 454.四数相加II ● 383. 赎金信 ● 15. 三数之和 ● 18. 四数之和7.代码随想录算法训练营第8天| ● 344.反转字符串 ● 541. 反转字符串II ● 剑指Offer 05.替换空格 ● 151.翻转字符串里的单词 ● 剑指Offer58-II.左旋转字符串8.代码随想录算法训练营第9天| ●28. 实现 strStr() ●459.重复的子字符串 ●字符串总结 ●双指针回顾 9.代码随想录算法训练营第10天| 232.用栈实现队列 ● 225. 用队列实现栈10.代码随想录算法训练营day13| ● 239. 滑动窗口最大值 ● 347.前 K 个高频元素 ● 总结11.代码随想录算法训练营day11| ● 20. 有效的括号 ● 1047. 删除字符串中的所有相邻重复项 ● 150. 逆波兰表达式求值12.代码随想录算法训练营day14| ● 二叉树理论基础 ● 递归遍历 ● 迭代遍历 ● 统一迭代
13.代码随想录算法训练营day15 | ● 层序遍历 10 ● 226.翻转二叉树 ● 101.对称二叉树 2
14.代码随想录算法训练营day16 | ● 104.二叉树的最大深度 559.n叉树的最大深度 ● 111.二叉树的最小深度 ● 222.完全二叉树的节点个数15.代码随想录算法训练营day17 | ● 110.平衡二叉树 ● 257. 二叉树的所有路径 ● 404.左叶子之和 16.代码随想录day21 | ● 530.二叉搜索树的最小绝对差 ● 501.二叉搜索树中的众数 ● 236. 二叉树的最近公共祖先
收起

层序遍历

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()){
            int size = que.size();  //对当前que.size()做一个快照
            vector<int> vec;
            while(size--){  //别用que.size(), 因为 que.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);
            }
            result.push_back(vec);
        }
        return result;
    }
};

107.二叉树的层序遍历 Ⅱ

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
    //正常走一遍层序遍历然后reverse一下
    vector<vector<int>> result;
    queue<TreeNode*> que;
    //que.push(root);
    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);
        }
        result.push_back(vec);
    }
    reverse(result.begin(), result.end());
    return result;
    }
};

What if we replace the if(root != NULL) que.push(root); with just que.push(root); ?

Then, when the root is NULL, this line vec.push_back(node->val); will throw an error:

runtime error: member access within null pointer of type 'TreeNode' (solution.cpp)

Now, let's debug:

I've written these codes in vscode as you can see below:

#include<iostream>
#include<queue>
using namespace std;
struct TreeNode{
    int val;
    TreeNode* left;
    TreeNode* right;  
    TreeNode() : val(0), left(NULL), right(NULL){}
};

int main(){
    queue<TreeNode*> que;
    cout << "before, the que's size is:" << que.size() << endl;
    que.push(NULL);
    cout << "after, the que's size is:" << que.size() << endl;
}

and run it, I got:

[Running] cd "d:\Operating System\" && g++ queue.cpp -o queue && "d:\Operating System\"queue
before, the que's size is:0
after, the que's size is:1

[Done] exited with code=0 in 1.802 seconds

absolutely, the NULL pointer will also be counted as 1 element in queue.

That's why we need to add an if sentence if(root != NULL) before que.push(root);

199.二叉树的右视图

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

note that my original code is:

		while(!que.empty()){
            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);
            }
            result.push_back(node->val);	
        }

then I would get the next error:

this is the error: 不注意变量作用域。

花括号 { } 表示代码块，在其中定义的变量只在其中有效

See the debug code:

#include<iostream>
using namespace std;
int main(){
    int size = 3;
    while(size--){
        int x = 0;
    }
    cout << x << endl;
}

then I got an error:

loop.cpp:8:13: error: 'x' was not declared in this scope

cout << x << endl;

So is the same with result.push_back(node->val);

647.二叉树的层平均值

class Solution {
public:
    double sum(vector<double> vec){
        double sum = 0;
        for (double i : vec){
            sum += i; 
        }
        return sum;
    }

    vector<double> averageOfLevels(TreeNode* root) {
        vector<double> result;
        queue<TreeNode*> que;
        if(root != NULL)    que.push(root);
        while(!que.empty()){
            double size = que.size();  //对当前que.size()做一个快照
            vector<double> vec;
            while(size--){  //别用que.size(), 因为 que.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);
            }
            result.push_back(sum(vec) / vec.size());
        }
        return result;
    }
};

note, 强制类型转换

#include<iostream>
using namespace std;
int main(){
    
    int a = 9;
    int b = 2;
    cout << "a/b = " << a/b << endl;
    cout << "(double) a/b = "<< (double) a/b << endl;

    double c = 9;
    int d = 2;
    cout << "c/d = " << c/d << endl;
}

got

[Running] cd "d:\Operating System\" && g++ typetransfomer.cpp -o typetransfomer && "d:\Operating System\"typetransfomer
a/b = 4
(double) a/b = 4.5
c/d = 4.5

429.N叉树的层序遍历

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>> result;
        queue<Node*> que;
        if(root != NULL)    que.push(root);
        while(!que.empty()){
            int size = que.size();  //对当前que.size()做一个快照
            vector<int> vec;
            while(size--){  //别用que.size(), 因为 que.size()在实时动态变化
                Node* node = que.front();
                que.pop();
                vec.push_back(node->val);
                for(Node* cur : node->children)
                    if(cur)
                        que.push(cur);
            }
            result.push_back(vec);
        }
        return result;
    }
};

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

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        vector<int> result;
        queue<TreeNode*> que;
        if(root != NULL)    que.push(root);
        while(!que.empty()){
            int size = que.size();  //对当前que.size()做一个快照
            int maxValue = INT_MIN;
            while(size--){  //别用que.size(), 因为 que.size()在实时动态变化
                TreeNode* node = que.front();
                que.pop();
                maxValue = node->val > maxValue ? node->val : maxValue;
                if(node->left)  que.push(node->left);
                if(node->right) que.push(node->right);
            }
            result.push_back(maxValue);
        }
        return result;
    }
};

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

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if(root != NULL)    que.push(root);
        while(!que.empty()){
            int size = que.size();  //对当前que.size()做一个快照
            Node* nodePre;
            Node* node;
            for(int i = 0; i < size; i++){  //别用que.size(), 因为 que.size()在实时动态变化
                if(i == 0){
                    nodePre = que.front();
                    que.pop();
                    node = nodePre;
                }else{
                    node = que.front();
                    que.pop();
                    nodePre->next = node;   //本层前一个节点next指向结点
                    nodePre = nodePre->next;
                }
                if(node->left != NULL)  que.push(node->left);
                if(node->right != NULL) que.push(node->right);
            }
            nodePre->next = NULL;
        }
        return root; 
    }
};

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

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

104.二叉树的最大深度

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

111.二叉树的最小深度

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

226. 翻转二叉树

mydemo--（层序遍历）

class Solution {
public:
    void swap(TreeNode* node1, TreeNode* node2){
        TreeNode* tmp = node1;
        node1 = node2;
        node2 = tmp;
    }

    TreeNode* invertTree(TreeNode* root) {
        queue<TreeNode*> que;
        if(root != NULL)    que.push(root);
        while(!que.empty()){
            TreeNode* Node = que.front();
            que.pop();
            //swap(Node->left, Node->right);    //这个函数没有用，why？
            TreeNode* tmp = Node->left;
            Node->left = Node->right;
            Node->right = tmp;
            if(Node->left != NULL)  que.push(Node->left);
            if(Node->right != NULL) que.push(Node->right);            
        }
        return root;
    }
};

卡哥demo--（深度遍历）

递归法我还是看不懂啊

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.对称二叉树

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);
    }
};
posted @   zz子木zz  阅读(7)  评论(0)  编辑  收藏  举报
相关博文：
·  代码随想录算法训练营day16 | ● 104.二叉树的最大深度 559.n叉树的最大深度 ● 111.二叉树的最小深度 ● 222.完全二叉树的节点个数
·  代码随想录算法训练营day17 | ● 110.平衡二叉树 ● 257. 二叉树的所有路径 ● 404.左叶子之和
·  代码随想录算法训练营第十三天|今天量大管饱144、145、94、102、107、199、637、429、515、116、117、104、111
·  代码随想录算法训练营第十五天 | 102.二叉树的层序遍历 226.翻转二叉树 101.对称二叉树
·  代码随想录算法训练营第十四天| 226.翻转二叉树 、101. 对称二叉树、104.二叉树的最大深度 （优先掌握递归）、111.二叉树的最小深度
阅读排行：
· 25岁的心里话
· 闲置电脑爆改个人服务器（超详细） #公网映射 #Vmware虚拟网络编辑器
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· 零经验选手，Compose 一天开发一款小游戏！
· 一起来玩mcp_server_sqlite，让AI帮你做增删改查！！
点击右上角即可分享
微信分享提示