剑指offer-26.对称的二叉树(159)

26.对称的二叉树(159)

• 题目描述：请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。

• 思路：

  • 方法一：递归
  • 方法二：利用栈，将对称结点连续进栈，然后出栈判断是否对称。
  • 方法三：利用队，将对称结点连续入队，然后出队判断是否对称。

• 代码：

  package _26.对称的二叉树;
  
  import java.util.LinkedList;
  import java.util.Queue;
  import java.util.Stack;
  
  /**
   * 题目描述：请实现一个函数，用来判断一颗二叉树是不是对称的。 注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。
   * 
   * @author Administrator
   *
   */
  public class SymmetricalBinaryTree {
  	/**
  	 * 方法一：递归
  	 * @param pRoot
  	 * @return
  	 */
  	static boolean isSymmetrical(TreeNode pRoot) {
  		if (pRoot == null)
  			return true;
  		return isSymmetrical(pRoot.left, pRoot.right);
  	}
  
  	static boolean isSymmetrical(TreeNode root1, TreeNode root2) {
  		// 结点已经比较完
  		if (root1 == null && root2 == null)
  			return true;
  		// 结点数不一致
  		if (root1 == null || root2 == null)
  			return false;
  		// 结点值不一致
  		if (root1.val != root2.val)
  			return false;
  		// 结点值相等，继续比较
  		return isSymmetrical(root1.left, root2.right) && isSymmetrical(root1.right, root2.left);
  	}
  	
  	/**
  	 * 方法二：利用栈 将对称的结点入栈，然后比较两个结点是否一致
  	 * @param pRoot
  	 * @return
  	 */
  	static boolean isSymmetrical1(TreeNode pRoot) {
  		if (pRoot == null)
  			return true;
  		
  		Stack<TreeNode> stack = new Stack<>();
  		TreeNode left = pRoot.left;
  		TreeNode right = pRoot.right;
  		stack.push(right);
  		stack.push(left);
  		while(!stack.isEmpty()){
  			left = stack.pop();
  			right = stack.pop();
  			//比较对称结点的值
  			if(left == null && right == null)
  				continue;
  			if(left == null || right == null)
  				return false;
  			if(left.val != right.val) 
  				return false;
  			stack.push(left.left);
  			stack.push(right.right);
  			stack.push(left.right);
  			stack.push(right.left);
  		}
  		return true;
  	}
  	
  	/**
  	 * 方法三：利用队列 将对称的结点入栈，然后比较两个结点是否一致
  	 * @param pRoot
  	 * @return
  	 */
  	static boolean isSymmetrical2(TreeNode pRoot) {
  		if(pRoot == null) return true;
  		
  		Queue<TreeNode> queue = new LinkedList<>();
  		
  		TreeNode left = pRoot.left;
  		TreeNode right = pRoot.right;
  		
  		queue.add(left);
  		queue.add(right);
  		while(!queue.isEmpty()){
  			left = queue.remove();
  			right = queue.remove();
  			if(left == null && right == null) 
  				continue;
  			if(left == null || right == null)
  				return false;
  			if(left.val != right.val)
  				return false;
  			queue.add(left.left);
  			queue.add(right.right);
  			queue.add(left.right);
  			queue.add(right.left);
  		}
  		return true;
  	}
  	
  
  	public static void main(String[] args) {
  		TreeNode root = new TreeNode(8);
  		root.left = new TreeNode(6);
  		root.right = new TreeNode(6);
  		root.left.left = new TreeNode(5);
  		root.left.right = new TreeNode(7);
  		root.right.left = new TreeNode(7);
  		root.right.right = new TreeNode(5);
  		System.out.println(isSymmetrical2(root));
  		// System.out.println(isSymmetrical2(root));
  	}
  }
  
  class TreeNode {
  	int val = 0;
  	TreeNode left = null;
  	TreeNode right = null;
  
  	public TreeNode(int val) {
  		this.val = val;
  
  	}
  }