101. Symmetric Tree

题目描述（简单难度）

判断一个二叉树是否关于中心轴对称。

解法一

和上一题判断两个二叉树是否相等其实是一样的思路，都是用某种遍历方法来同时遍历两个树，然后看是否对应相等。

这里的需要遍历的两个树就是左子树和右子树了。

这里的对应相等的话，因为判断左子树 A 和右子树 B 是否对称，需要判断两点。

• A 的根节点和 B 的根节点是否相等。
• A 的左子树和 B 的右子树是否相等，同时 A 的右子树和左子树是否相等。

上边两点都满足，就表示是对称的。所以代码就出来了。

class TreeNode{
	int val;
	TreeNode left;
	TreeNode right;
	TreeNode(int x){val=x;}
	
}

public class Symmetric_Tree1 {
	
	public static boolean isSymetrics(TreeNode root) {
		if(root==null) return true;
		
		return isSymmetricHelper(root.left,root.right);
	}

	private static boolean isSymmetricHelper(TreeNode left, TreeNode right) {
		
		// 有且仅有一个为null，直接返回false
		if(left==null && right!=null || left!=null && right==null) return false;
		
		if(left!=null && right!=null) {
			// A的根节点和B的根节点是否相同
			if(left.val!=right.val) {
				return false;
			}
			// A的左子树和B的右子树是否相同，同时A的右子树和左子树是否相同
			return isSymmetricHelper(left.left,right.right)&& isSymmetricHelper(left.right,right.left);
		}
		return true;
	}
	public static void main(String args[]) {
	TreeNode[] node=new TreeNode[7];
    	node[0]=new TreeNode(1);
    	node[1]=new TreeNode(2);
    	node[2]=new TreeNode(2);
    	node[3]=new TreeNode(3);
    	node[4]=new TreeNode(4);
    	node[5]=new TreeNode(4);
    	node[6]=new TreeNode(3);
    	node[0].left=node[1];
    	node[0].right=node[2];
    	node[1].left=node[3];
    	node[1].right=node[4];
    	node[2].left=node[5];
    	node[2].right=node[6];
    	
    	boolean ans=isSymetrics(node[0]);
    	System.out.println(ans);
	}
}

解法二 DFS 栈

解法一其实就是类似于 DFS 的先序遍历。不同之处是对于 left 子树是正常的先序遍历 根节点 -> 左子树 -> 右子树 的顺序，对于 right 子树的话是 根节点 -> 右子树 -> 左子树 的顺序。

所以我们可以用栈，把递归改写为迭代的形式。

import java.util.Stack;

public class Symmetric_Tree2 {
	
	public static boolean isSymmetric(TreeNode root) {
		if(root==null) return true;
			
		Stack<TreeNode>stackleft=new Stack<>();
		Stack<TreeNode>stackright=new Stack<>();
		TreeNode curleft=root.left;
		TreeNode curright=root.right;
		
		while(curleft!=null || !stackleft.isEmpty()||curright!=null || !stackright.isEmpty()) {
			
			while(curleft!=null) {
				stackleft.push(curleft);
				curleft=curleft.left;
			}
			while(curright!=null) {
				stackright.push(curright);
				curright=curright.right;
			}
			
			if(stackleft.size()!=stackright.size()) {
				return false;
			}
			
			curleft=stackleft.pop();
			curright=stackright.pop();
			
			if(curleft.val!=curright.val) {
				return false;
			}
			
			curleft=curleft.right;
			curright=curright.left;
		}
		return true;
	}
	public static void main(String args[]) {
		TreeNode[] node=new TreeNode[7];
	    	node[0]=new TreeNode(1);
	    	node[1]=new TreeNode(2);
	    	node[2]=new TreeNode(2);
	    	node[3]=new TreeNode(3);
	    	node[4]=new TreeNode(4);
	    	node[5]=new TreeNode(4);
	    	node[6]=new TreeNode(3);
	    	node[0].left=node[1];
	    	node[0].right=node[2];
	    	node[1].left=node[3];
	    	node[1].right=node[4];
	    	node[2].left=node[5];
	    	node[2].right=node[6];
	    	
	    	boolean ans=isSymmetric(node[0]);
	    	System.out.println(ans);
		}
}

当然我们也可以使用中序遍历或者后序遍历，是一样的道理。

解法三 BFS 队列

DFS 考虑完了，当然还有 BFS，一层一层的遍历两个树，然后判断对应的节点是否相等即可。

利用两个队列来保存下一次遍历的节点即可。

import java.util.LinkedList;
import java.util.Queue;

public class Symmetric_Tree3 {
	
	public boolean isSymmetric6(TreeNode root) {
	    if (root == null) {
	        return true;
	    }
	    Queue<TreeNode> leftTree = new LinkedList<>();
	    Queue<TreeNode> rightTree = new LinkedList<>();
	    //两个树的根节点分别加入
	    leftTree.offer(root.left);
	    rightTree.offer(root.right);
	    while (!leftTree.isEmpty() && !rightTree.isEmpty()) {
	        TreeNode curLeft = leftTree.poll();
	        TreeNode curRight = rightTree.poll();
	        if (curLeft == null && curRight != null || curLeft != null && curRight == null) {
	            return false;
	        }
	        if (curLeft != null && curRight != null) {
	            if (curLeft.val != curRight.val) {
	                return false;
	            }
	            //先加入左子树后加入右子树
	            leftTree.offer(curLeft.left);
	            leftTree.offer(curLeft.right);

	            //先加入右子树后加入左子树
	            rightTree.offer(curRight.right);
	            rightTree.offer(curRight.left);
	        }

	    }
	    if (!leftTree.isEmpty() || !rightTree.isEmpty()) {
	        return false;
	    }
	    return true;
	}
}

总结

基础题，采用递归、栈和队列来解答。