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

层序遍历

题目链接/文章讲解/视频讲解：代码随想录

解题思路

用队列模拟，从第一层放节点进去，并记录size（代表这一层的节点个数，方便我们知道是哪一层），弹出节点后，size--并将左右孩子加入队列，终止条件为队列没有元素

 

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
         vector<vector<int>> result;
         queue<TreeNode*> que;
         if(root!=nullptr) 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);
         }
         return result;
    }
};

 226.翻转二叉树 

题目链接/文章讲解/视频讲解：代码随想录

 解题思路（优先掌握递归）

递归的前序和后序比较方便，而中序很麻烦

前序和后序时，只需要节点为空时停止遍历，不为空则交换左右孩子，随后按照中左右或者左右中的循序递归即可

中序时，左中右时，要都处理左子树，因为处理左子树后，他就变成了右子树，而这时又处理了左子树，因此都要处理左子树

 层序遍历

层序遍历也是可以的，我们只需要在层数遍历pop后，将他的左右孩子swap一下，即可，更加直观

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
            if(root==nullptr) return root;
            swap(root->left,root->right);   //中
            invertTree(root->left);         //左
            invertTree(root->right);        //右
            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. 对称二叉树

 题目链接/文章讲解/视频讲解：代码随想录

 解题思路（优先递归）

这里只能后序，因为我们要收集底层孩子的信息给上层节点，最后判断是否可以翻转

 

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==nullptr) return true;
              return compare(root->left,root->right);
    }

};