Leetcode101. 对称二叉树

Leetcode101. 对称二叉树

题目：
给定一个二叉树，检查它是否是镜像对称的。
例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

    1
   / \
  2   2
 / \ / \
3  4 4  3

题解：

方法一：
递归
如果一个树的左子树与右子树镜像对称，那么这个树是对称的。
复杂度分析
时间复杂度：O(n)，因为我们遍历整个输入树一次，所以总的运行时间为 O(n)，其中 n 是树中结点的总数。
空间复杂度：递归调用的次数受树的高度限制。在最糟糕情况下，树是线性的，其高度为 O(n)。因此，在最糟糕的情况下，由栈上的递归调用造成的空间复杂度为 O(n)。
scala代码如下：

def isSymmetric(root: TreeNode): Boolean = {
    isMirror(root, root)

  }
def isMirror(t1: TreeNode, t2: TreeNode): Boolean = {
    if (t1 == null && t2 == null) true
    else if (t1 == null || t2 == null) false
    else
      (t1.value == t2.value) && isMirror(t1.right, t2.left) && isMirror(t1.left, t2.right)
  }

方法二：
迭代
复杂度分析
时间复杂度：O(n)，因为我们遍历整个输入树一次，所以总的运行时间为 O(n)，其中 n是树中结点的总数。
空间复杂度：搜索队列需要额外的空间。在最糟糕情况下，我们不得不向队列中插入 O(n)个结点。因此，空间复杂度为 O(n)。
scala代码如下：

def isSymmetric2(root: TreeNode): Boolean = {

    val stack = new util.Stack[TreeNode]()
    if (root != null) {
      stack.add(root.left)
      stack.add(root.right)
    }
    var s1 = true
    var result = true
    var flag = true
    while (!stack.isEmpty && s1) {
      val a = stack.pop()
      val b = stack.pop()
      if (a == null && b == null) {
        flag = false
      }
      if (flag) {
        if (a.value == b.value && a != null && b != null) {
          stack.add(a.left)
          stack.add(b.right)
          stack.add(a.right)
          stack.add(b.left)
        } else {
          s1 = false
          result = false
        }
      }
    }
    result
  }

java代码如下：

 public static boolean isSymmetric(TreeNode root) {

        if (root == null) return true;
        Stack<TreeNode> stack = new Stack<>();
        stack.add(root.left);
        stack.add(root.right);

        while (!stack.isEmpty()) {
            TreeNode a = stack.pop();
            TreeNode b = stack.pop();

            if (a == null && b == null) continue;
            if (a == null || b == null) return false;
            if (a.value != b.value) return false;
            stack.add(a.left);
            stack.add(b.right);
            stack.add(a.right);
            stack.add(b.left);
        }
        return true;
    }

public static boolean isSymmetric2(TreeNode root) {
        if (root == null) return true;
        Deque<TreeNode> queue = new LinkedList<>();
        queue.add(root.left);
        queue.add(root.right);
        while (!queue.isEmpty()) {
            TreeNode node1 = queue.poll();
            TreeNode node2 = queue.poll();
            if (node1 == null && node2 == null) continue;
            if (node1 == null || node2 == null) return false;
            if (node1.value != node2.value) return false;
            queue.add(node1.left);
            queue.add(node2.right);
            queue.add(node1.right);
            queue.add(node2.left);
        }
        return true;
    }