DAY15 二叉树层序遍历 翻转二叉树 对称二叉树

102.二叉树的层序遍历

昨天白天有事，没学，今天补昨天的打卡

 用队列做，就很简单，每次探出相应数量的元素，并加入这个元素的左右子树即可，如下图所示：

手搓，代码较繁琐：

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
              queue<TreeNode*> qu;
              int size1=0;
              vector<vector<int>> res;
              vector<int> res_temp;
              if(root==NULL)
              return {};
              qu.push(root);
              size1++;
              while(!qu.empty())
              {   int temp=0;
                  res_temp={};
                  while(size1--)
                  {   
                      auto tempnode=qu.front();
                      if(tempnode->left)
                      {qu.push(tempnode->left);
                       temp++;
                       }
                       if(tempnode->right)
                       {qu.push(tempnode->right);
                       temp++;
                       }
                       res_temp.push_back(qu.front()->val);
                       qu.pop();
                  }
                  size1=temp;
                  res.push_back(res_temp);
              }
              return res;
    

 这是简化的：

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
              queue<TreeNode*> qu;
              int size1=0;
              vector<vector<int>> res;
              if(root!=NULL)qu.push(root);
             while(!qu.empty())
              {   size1=qu.size();
                  vector<int> res_temp;
                  while(size1--)
                  {   
                      auto tempnode=qu.front();
                       qu.pop();
                       res_temp.push_back(tempnode->val);
                      if(tempnode->left)qu.push(tempnode->left);
                      if(tempnode->right)qu.push(tempnode->right);    
                  }
                  res.push_back(res_temp);
              }
              return res;
    }
};

有了层序遍历，今年顺便把这十题也做了，确实好用

226.翻转二叉树

翻转一棵二叉树。

这个拿层序遍历能做，每次遍历父节点的时候顺便把下面左子右子交换即可，代码如下：

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
         queue<TreeNode*> qu;
         int size=0;
         if(root!=NULL)qu.push(root);
         while(!qu.empty())
         {
             size=qu.size();
             while(size--)
             {
                 auto tempnode=qu.front();
                 qu.pop();
                 swap(tempnode->left,tempnode->right);
                 if(tempnode->left)qu.push(tempnode->left);
                 if(tempnode->right)qu.push(tempnode->right);
             }
         }
         return root;
    }
};

当然，这题也可以用递归来做：

后序：

class Solution {
public:
       TreeNode* reversal(TreeNode * root)
       {   if(root==NULL)return root;
           reversal(root->left);
           reversal(root->right);
           swap(root->left,root->right);
           return root;
       }

    TreeNode* invertTree(TreeNode* root) {
         root=reversal(root);
         return root;
    }
};

前序：

class Solution {
public:
       TreeNode* reversal(TreeNode * root)
       {   if(root==NULL)return root;
          swap(root->left,root->right);
           reversal(root->left);
           reversal(root->right);
           return root;
       }

    TreeNode* invertTree(TreeNode* root) {
         root=reversal(root);
         return root;
    }
};

101. 对称二叉树

给定一个二叉树，检查它是否是镜像对称的。

我一开始想的比较复杂，直接先层序遍历，然后翻转，然后再遍历看得到的数组是否一致：

class Solution {
public:
       vector<int> traversal(TreeNode* root,vector<int> & res)
       {
           if(root==NULL)
           {  res.push_back(INT32_MIN);
               return res;}
           res.push_back(root->val);
           traversal(root->left,res);
           traversal(root->right,res);
           return res;
       }
       TreeNode* change(TreeNode* root)
       {
           if(root==NULL)return root;
           swap(root->left,root->right);
           change(root->left);
           change(root->right);
           return root;
       }
    bool isSymmetric(TreeNode* root) {
          vector<int> res1;
          traversal(root,res1);
          change(root);
          vector<int> res2;
          traversal(root,res2);
          for(int i=0;i<res1.size();i++)
          {
              if(res1[i]!=res2[i])return 0;
          }
          return 1;
    }
};

递归做法，非常简洁，直接同时从左右子树开始：

 新学期要从学习二叉树开始！ | LeetCode：101. 对称二叉树_哔哩哔哩_bilibili

class Solution {
public:
      bool Symmertic(TreeNode* left,TreeNode* right)
      {    if(left==NULL&&right!=NULL)return 0;
           else if(left!=NULL&&right==NULL)return 0;
           else if(left==NULL&&right==NULL)return 1;
           else if(left->val!=right->val)return 0;
           bool outside=Symmertic(left->left,right->right);
           bool inside=Symmertic(left->right,right->left);
           return inside&&outside;
      }
    bool isSymmetric(TreeNode* root) {
         if(root==NULL)return 1;
          return Symmertic(root->left,root->right);
    }
};

 结束！