LeetCode-探索-初级算法-树-3. 对称二叉树(个人做题记录，不是习题讲解)

LeetCode-探索-初级算法-树-3. 对称二叉树(个人做题记录，不是习题讲解)

LeetCode探索-初级算法：https://leetcode-cn.com/explore/interview/card/top-interview-questions-easy/

3. 对称二叉树

• 语言：java

• 思路：尝试写了一个非递归的，但应该中间判断有问题，一直是错的，花费时间过多，得不偿失，就放弃了。

• 参考代码1(1ms)：

  https://blog.csdn.net/qq_39313597/article/details/89135625

  class Solution {
      public boolean isSymmetric(TreeNode root) {
          if(root == null){
              return true;
          }
          
          return isSymmetric(root.left,root.right);
      }
      
      public boolean isSymmetric(TreeNode n1,TreeNode n2) {
          if(n1 == null || n2 == null){
              return n1 == n2;
          }
          
          if(n1.val != n2.val){
              return false;
          }
          
          return isSymmetric(n1.left,n2.right) && isSymmetric(n1.right,n2.left);
      }
  }
  

• 参考代码2(1ms)：发现和上面博主代码基本没差。思路即通过调用另一个回调函数判断当前树的左右子树是否相同。判断相同的方式即左子树左节点要和右子树右节点相同，左子树右节点要和右子树左节点相同。

  class Solution {
      
      public boolean isSymmetric(TreeNode root) {
          if (root == null) {
              return true;
          }
          return isSymmetric(root.left, root.right);
      }
      
      private boolean isSymmetric(TreeNode left, TreeNode right) {
          if (left == null && right == null) {
              return true;
          }
          if (left == null || right == null) {
              return false;
          }
          if (left.val != right.val) {
              return false;
          }
          return isSymmetric(left.left, right.right) && isSymmetric(left.right, right.left);
      }
  }
  

• 参考代码3(0ms)：和参考代码2其实差不多，只不过把对头节点的判断也归类到递归函数中罢了

  class Solution {
      public boolean isSymmetric(TreeNode root) {
          return isMirror(root,root);
      }
      public static boolean isMirror(TreeNode left,TreeNode right){
          if(left == null && right == null){
              return true;
          }
          if(left == null || right == null){
              return false;
          }
          if(left.val != right.val){
              return false;
          }
          return isMirror(left.left,right.right) && isMirror(left.right, right.left);
      }
  }
  

• 参考代码4非递归(3ms)：利用bfs常用的queue来对比两个树是否对称。即左子树每次存入左和右，右子树每次存入右和左，然后进行比较

  class Solution {
      public boolean isSymmetric(TreeNode root) {
          if (root == null) return true;
          Queue<TreeNode> q1 = new LinkedList<>();
          Queue<TreeNode> q2 = new LinkedList<>();
          q1.add(root);
          q2.add(root);
          while (!q1.isEmpty() && !q2.isEmpty()) {
              TreeNode left = q1.poll();
              TreeNode right = q2.poll();
              if (left == null && right == null) continue;
              if (left == null || right == null) return false;
              if (left.val != right.val) return false;
              q1.add(left.left);
              q1.add(left.right);
              q2.add(right.right);
              q2.add(right.left);
          }
          return q1.isEmpty() && q2.isEmpty();
      }
  }
  

• 参考后重写-递归(1ms):莫名就比参考的满了0ms

  /**
   * Definition for a binary tree node.
   * public class TreeNode {
   *     int val;
   *     TreeNode left;
   *     TreeNode right;
   *     TreeNode(int x) { val = x; }
   * }
   */
  class Solution {
      public boolean isSymmetric(TreeNode root) {
          return isSymmetric(root,root);
      }
      public boolean isSymmetric(TreeNode left,TreeNode right){
          if(left==null&&right==null)
              return true;
          if(left==null||right==null)
              return false;
          if(left.val!=right.val)
              return false;
          return isSymmetric(left.left,right.right)&&isSymmetric(left.right,right.left);
      }
  }
  

• 参考后重写-非递归(2ms):莫名比参考的快了1ms。

  /**
   * Definition for a binary tree node.
   * public class TreeNode {
   *     int val;
   *     TreeNode left;
   *     TreeNode right;
   *     TreeNode(int x) { val = x; }
   * }
   */
  class Solution {
      public boolean isSymmetric(TreeNode root) {
          Queue<TreeNode> left = new LinkedList();
          Queue<TreeNode> right = new LinkedList();
          TreeNode l,r;
          left.offer(root);
          right.offer(root);
          while(!left.isEmpty()&&!right.isEmpty()){
              l = left.poll();
              r = right.poll();
              if(l==null&&r==null)
                  continue;
              if(l==null||r==null)
                  return false;
              if(l.val!=r.val)
                  return false;
              left.offer(l.left);
              left.offer(l.right);
              right.offer(r.right);
              right.offer(r.left);
          }
          return left.isEmpty()&&right.isEmpty();
      }
  }