非科班菜鸡算法学习记录 | 代码随想录算法训练营第15天||102.二叉树的层序遍历， 226.翻转二叉树，101. 对称二叉树

10个层序遍历

• 102.二叉树的层序遍历   (最重要，给出代码了)
• 107.二叉树的层次遍历II （题目要求从下往上输出层序，就是在102基础上把最后的res翻转）
• 199.二叉树的右视图 (题：输出每层最后一个数 答：层序遍历时加判断，size为0时加res数组)
• 637.二叉树的层平均值(题：求每层平均 答：层序遍历时加判断，size为0时求平均加res数组)
• 429.N叉树的层序遍历(题：有多个孩子节点 答：层序遍历时用for把所有的孩子入队列）
• 515.在每个树行中找最大值(题：求每层最大 答：层序遍历加判断，size为0求最大（用max))
• 116.填充每个节点的下一个右侧节点指针 (题：完美二叉，每个节点指向右侧节点 答：记录一下本层的头部节点，然后在遍历的时候让前一个节点指向本节点)
• 117.填充每个节点的下一个右侧节点指针II (题：二叉，每个节点指向右侧节点 答：代码同上)
• 104.二叉树的最大深度 (答：就是层数，这题用递归代码更简洁)
• 111.二叉树的最小深度 (求最近的叶子节点深度 答：左右孩子都为空时返回depth)

102. 二叉树的层序遍历

知识点：二叉树（用队列辅助） 状态：看答案学习，自己写代码

思路：用一个队列来存二叉树，并用size记录每层的节点数，每次只出队列size个

/**
 * 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<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();   // 记录每层size 
            vector<int> res1;      //每层的数值
            while ( size--) {      //每此只出 size 个节点
                TreeNode* temp = que.front();
                que.pop();
                res1.push_back(temp->val);
                if (temp->left) { que.push(temp->left);}    //加入左右孩子节点
                if (temp->right) { que.push(temp->right);}
            }
            res.push_back(res1);
        }
        return res;
    }
};

 
226. 翻转二叉树

知识点：二叉树（递归/迭代） 状态：递归ok

/**
 * 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:
    TreeNode* invertTree(TreeNode* root) 
    {
        if ( root ==nullptr )
        {return nullptr;}
        else
        {
            TreeNode *l = invertTree(root->left);
            TreeNode*r = invertTree(root->right);
            root->left=r;
            root->right=l;
        }
        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) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return root;
    }
};

101. 对称二叉树

知识点：二叉树（迭代） 状态：递归ok迭代不行

/**
 * 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:
     bool check(TreeNode* p, TreeNode* q)
     {
         if ( !p &&!q )
         {
             return true;
         }
        else if (!p||!q)
         {
             return false;
         }
         return check(p->left,q->right)&&check(p->right,q->left)&& p->val==q->val;
     }


    bool isSymmetric(TreeNode* root) 
    {
        return check(root,root);

    }
};