代码随想录算法训练营第15天

这个天数有点乱了但是没简短了，从今天开始按照这个来吧不管了

二叉树的层序遍历

层序遍历一个刷十道题是真的有点爽，只要题目有明显的用到二叉树“层”的特性来提问或处理，这个时候这个框架真的是屡试不爽。

重点在于搞清楚两个点：

1、递归利用队列来分别一层一层的处理，从根节点开始，先保存该层的个数q.size()，然后这个size就可以用来当遍历完每一层的判断标志了

2、利用队列先进先出的特性，每弹出一个节点，就将它的左右子节点入队，这样遍历完该层也就把下一层的节点入队完成，实现了闭环。

当然也有其他的注意点，例如变量类型还有空节点不可以入队。

以下代码框架来自与代码随想录代码随想录

/**
 * 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>> result;
        //层次遍历
        //每一次记录每一层的数量size，每一次弹出该层的数量
        //因为弹出的时候会把该节点的左右孩子入队，所以需要在遍历该层之前把数量标记起来

        queue<TreeNode*> q;
    //记得要过滤如果根节点为空不可以入队
    if(root != NULL)
        q.push(root);
    while(!q.empty()){

            int size = q.size();
            vector<int>v;

            while(size--){
                TreeNode* node = q.front();
                q.pop();
                v.push_back(node->val);

                if(node->left != NULL) q.push(node->left);
                if(node->right != NULL) q.push(node->right);
            }

            result.push_back(v);



        }
        return result;

    }
};

226.翻转二叉树

就是用前序遍历的过程中，当中左右遍历到中的时候把中的左右指向交换了，最后实现整个二叉树的翻转。

class Solution {
public:

    //使用递归遍历中的前序遍历 中左右
    //后序遍历也可以 但是中序遍历需要绕弯所以不适合做

    void traversal(TreeNode* node){
        if(node == NULL) return;

        swap(node->left,node->right);
        traversal(node->left);
        traversal(node->right);
    }
    TreeNode* invertTree(TreeNode* root) {

        traversal(root);
        return root;

    }
};

代码随想录

226. 对称二叉树 （优先掌握递归

https://leetcode.cn/problems/symmetric-tree/submissions/

代码随想录

      /*
        //根据代码随想录的思路做做笔记
        //根节点的左右子树是否轴对称也就是做根节点的左右子树是否可以互相翻转
        以下四种情况都是递归的出口
        //左        右                  返回值
          空        不为空              false
          不为空     空              false
          空        空              true
          不为空但左右值不相等              false
          
          第五种情况则是左右值不为空且相等，这个时候就可以继续往下递归比较

          最后将返回值用一个&操作，实现判断，只有所有值都返回true证明所有值都是堆成的 
        
        */

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

    }