常考数据结构与算法:判断二叉树是否对称(迭代法,递归法)

给定一棵二叉树，判断琪是否是自身的镜像（即：是否对称）
例如：下面这棵二叉树是对称的
     1
    /  \
  2    2
 / \    / \
3 4  4  3
下面这棵二叉树不对称。
    1
    / \
  2   2
    \    \
    3    3

思路：要判断一颗二叉树是否对称，要判断一下几点，可以用递归来实现：

• 判断一颗二叉树是不是对称的，等价于判断其左右子树是不是镜像对称的
• 判断镜对称像即判断对称的位置上的元素是不是相等
• 两个节点A和B对称等价于: 
  • 这两个节点上存储的值相等
  • 节点A的左子树节点和节点B的右子树上的节点是对称的
  • 节点A的右子树节点和节点A的左子树上的节点是对称的

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

public class TestTreeSymmertic {
    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        TreeNode rleft = new TreeNode(2);
        TreeNode rleftleft = new TreeNode(3);
        TreeNode rleftright = new TreeNode(4);

        TreeNode rright = new TreeNode(2);
        TreeNode rrightleft = new TreeNode(4);
        TreeNode rrightright = new TreeNode(3);

        root.left = rleft;
        root.right = rright;

        rleft.left = rleftleft;
        rleft.right = rleftright;

        rright.left = rrightleft;
        rright.right = rrightright;

        TestTreeSymmertic t = new TestTreeSymmertic();
        System.out.println(t.isSymmetricIter(root));
    }

    /*
     *   迭代方式
     *   使用队列， 这是把递归程序改写成迭代程序的常用方法，常常利用while循环
     
     while(!queue.isEmpty()){
      // 判断逻辑
     }
     return true;
    */
    public boolean isSymmetricIter(TreeNode root) {

        if(null == root){
            return true;
        }

        Queue<TreeNode> treeNodeQueue = new LinkedList<TreeNode>();
        treeNodeQueue.offer(root.left);
        treeNodeQueue.offer(root.right);

        while(!treeNodeQueue.isEmpty()){
            TreeNode node1 = treeNodeQueue.poll();
            TreeNode node2 = treeNodeQueue.poll();

            if(node1 == null && node2 == null){
                continue;
            }

            if(node1 == null || node2 == null || node1.val != node2.val){
                return false;
            }

            treeNodeQueue.offer(node1.left);
            treeNodeQueue.offer(node2.right);

            treeNodeQueue.offer(node1.right);
            treeNodeQueue.offer(node2.left);
        }
        return true;
    }

    /**
     * 递归的方式
     * @param root TreeNode类
     * @return bool布尔型
     */
    public boolean isSymmetric (TreeNode root) {
        // write code here

        if(null == root ) {
            return true;
        }

        return isTreeSymmertic(root.left, root.right);
    }

    boolean isTreeSymmertic(TreeNode pHead1,TreeNode pHead2){

        // 如果左右节点都为空，表示对称
        if(pHead1== null && pHead2==null){
            return true;
        }

        //  其中一个节点为空，不对称
        if(pHead1==null){
            return false;
        }

        //  其中一个节点为空，不对称
        if(pHead2==null){
            return false;
        }

        //1.判断当前值左右是否相等，2.判断左子树的左节点和右子树的右节点，3.判断左子树的右节点和右子树的左节点是否相等，三者缺一不可，一直递归
        return (pHead1.val==pHead2.val && isTreeSymmertic(pHead1.left,pHead2.right) && isTreeSymmertic(pHead1.right,pHead2.left));
    }


}