Symmetric Tree

最新推荐文章于 2020-06-29 10:00:06 发布

巴韩

最新推荐文章于 2020-06-29 10:00:06 发布

阅读量193

点赞数

分类专栏： leetcode

本文链接：https://blog.csdn.net/fsarfRe/article/details/42277003

版权

leetcode 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

每日一题；

今天的题目是判断二叉树是不是对称的。先看题目

Given a binary tree, check whether it is a mirror of itself (ie, symmetric around its center).

For example, this binary tree is symmetric:

But the following is not:

Note:
Bonus points if you could solve it both recursively and iteratively.

本来自己想的时候思路是：一层节点一层节点来处理，如果当前层的数据是对称的，结果整棵树就是对称的。

解题过程如下：

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
     public boolean isSymmetric(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        Queue queue = new LinkedList();
        if(root == null) return true;
        TreeNode temp;
        queue.offer(root);
        queue.offer(0);
        try{
        while (queue.size()>0){
            if(queue.peek() == null){
                queue.poll();
                list.add(null);
                list.add(null);
                continue;
            }
            if(queue.peek().getClass() == Integer.class){
                queue.poll();
                for(int i = 0,j = list.size()-1;i<j;i++,j--){
                    if(list.get(i) != list.get(j)){
                        return false;
                    }
                }
                list.clear();
                if(queue.size()>0)
                    queue.offer(0);
                else
                    break;
            }else {
                temp = (TreeNode)queue.poll();
                if(temp.left == null){
                    list.add(null);
                    queue.offer(null);
                }else {
                    list.add(temp.left.val);
                    queue.offer(temp.left);
                }
                if(temp.right == null){
                    list.add(null);
                    queue.offer(null);
                }else {
                    list.add(temp.right.val);
                    queue.offer(temp.right);
                }
            }
        }
        }catch (Exception ee){
            System.out.println(ee);
        }
        return true;
    }
}

看了网上大家的讨论用的是递归，究其原理是从两侧开始判断，然后判断中间的，解题代码如下:

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
     public boolean isSymmetric(TreeNode root) {
        if(root == null){
            return true;
        }
        return isSame(root.left,root.right);
    }
    private boolean isSame(TreeNode left,TreeNode right){

        if(left == null || right == null){
            return  left == right;
        }
        if(left.val!= right.val){
            return false;
        }
        return isSame(left.left, right.right) && isSame(left.right, right.left);
    }
}