LeetCode11--相同的树和镜像树

1.相同的树

//给定两个二叉树，编写一个函数来检验它们是否相同。 
//
// 如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。 
//
// 示例 1: 
//
// 输入:       1         1
//          / \       / \
//         2   3     2   3
//
//        [1,2,3],   [1,2,3]
//
//输出: true 
//
// 示例 2: 
//
// 输入:      1          1
//          /           \
//         2             2
//
//        [1,2],     [1,null,2]
//
//输出: false
// 
//
// 示例 3: 
//
// 输入:       1         1
//          / \       / \
//         2   1     1   2
//
//        [1,2,1],   [1,1,2]
//
//输出: false
// 
// Related Topics 树 深度优先搜索

 第一次接触树相关的内容，一般有两种方法，那就是迭代法和递归法，递归法采用的是深度优先遍历的方式，先对每一个节点的左节点进行遍历比较，然后再对右节点进行遍历比较：

public boolean isSameTree(TreeNode p, TreeNode q) {
		if (p == null && q == null) {
			return true;
		} else if (p == null || q == null) {
			return false;
		} else if (p.val != q.val) {
			return false;
		} else {
			return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
		}
	}

而递归法采用的是广度优先遍历的方式，就是先比较同一级的节点，然后再往下，是采用队列进行节点的存储的，先进先出。

public boolean isSameTree(TreeNode p, TreeNode q) {
        if (p == null && q == null) {
            return true;
        } else if (p == null || q == null) {
            return false;
        }
        Queue<TreeNode> queue1 = new LinkedList<TreeNode>();
        Queue<TreeNode> queue2 = new LinkedList<TreeNode>();
        queue1.offer(p);
        queue2.offer(q);
        while (!queue1.isEmpty() && !queue2.isEmpty()) {
            TreeNode node1 = queue1.poll();
            TreeNode node2 = queue2.poll();
            if (node1.val != node2.val) {
                return false;
            }
            TreeNode left1 = node1.left, right1 = node1.right, left2 = node2.left, right2 = node2.right;
            if (left1 == null ^ left2 == null) {
                return false;
            }
            if (right1 == null ^ right2 == null) {
                return false;
            }
            if (left1 != null) {
                queue1.offer(left1);
            }
            if (right1 != null) {
                queue1.offer(right1);
            }
            if (left2 != null) {
                queue2.offer(left2);
            }
            if (right2 != null) {
                queue2.offer(right2);
            }
        }
        return queue1.isEmpty() && queue2.isEmpty();
    }

2.镜像树

//给定一个二叉树，检查它是否是镜像对称的。 
//
// 
//
// 例如，二叉树 [1,2,2,3,4,4,3] 是对称的。 
//
//     1
//   / \
//  2   2
// / \ / \
//3  4 4  3
// 
//
// 
//
// 但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的: 
//
//     1
//   / \
//  2   2
//   \   \
//   3    3
// 
//
// 
//
// 进阶： 
//
// 你可以运用递归和迭代两种方法解决这个问题吗？ 
// Related Topics 树 深度优先搜索 广度优先搜索

依然是两种方式，一种是深度优先，一种是广度优先。这里就放一种深度优先的。

public boolean isSymmetric(TreeNode root) {
        return check(root, root);
    }
	public boolean check(TreeNode p, TreeNode q){
		if(p == null && q == null){
			return true;
		}else if(p == null || q == null){
			return false;
		}else {
			return p.val == q.val && check(p.right, q.left) && check(p.left, q.right);
		}
	}

至于广度优先，官方给出的代码是有一定问题的，仔细调试代码发现它会把后面支路上的比较两次，所以我们不能直接把两个根节点作为函数的实参传进去，应该先判断根节点是否为空，如果为空那么直接返回true，否则就将root的做节点和右节点传入函数。最后代码是这样的：

public boolean isSymmetric(TreeNode root) {
    	if(root == null){
    		return true;
		}
    	return check(root.left, root.right);
    }
public boolean check(TreeNode u, TreeNode v) {
		Queue<TreeNode> q = new LinkedList<TreeNode>();
		q.offer(u);
		q.offer(v);
		while (!q.isEmpty()) {
			u = q.poll();
			v = q.poll();
			if (u == null && v == null) {
				continue;
			}
			if ((u == null || v == null) || (u.val != v.val)) {
				return false;
			}

			q.offer(u.left);
			q.offer(v.right);

			q.offer(u.right);
			q.offer(v.left);
		}
		return true;
	}