【剑指 Offer 28】对称的二叉树

对称的二叉树

二叉树

题目

请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。

例如，二叉树 [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




示例 1：

输入：root = [1,2,2,3,4,4,3]
输出：true
示例 2：

输入：root = [1,2,2,null,3,null,3]
输出：false
限制：

0 <= 节点个数 <= 1000

注意：本题与主站 101 题相同：https://leetcode-cn.com/problems/symmetric-tree/

Related Topics
树
深度优先搜索
广度优先搜索
二叉树

👍 455
👎 0


/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
        
    }
}

思路

1. 把树的每一层用数组存储起来
2. 对每个数组进行前面的序号i和后面的序号len-i-1判断是否对称相等
3. 第一层不用判断

实现

class Solution {
    public boolean isSymmetric(TreeNode root) {
        Map<Integer, List<Integer>> map = new HashMap<>();
        method(root,1,map);
        for (int i=1;i<=map.size();i++){
            List<Integer> list = map.get(i);
            if (i!=1&&list.size()%2!=0) return false;
            for (int j=0;j<list.size()/2;j++){
                if (list.get(j)!=list.get(list.size()-j-1)){
                    return false;
                }
            }
        }
        return true;
    }

    private void method(TreeNode node, int level, Map<Integer,List<Integer>> map){
        if (map.containsKey(level)){
            List<Integer> list = map.get(level);
            list.add(node==null?null:node.val);
        }
        else {
            List<Integer> list = new ArrayList<>();
            list.add(node==null?null:node.val);
            map.put(level,list);
        }
        if (node==null) return;
        method(node.left,level+1,map);
        method(node.right,level+1,map);

    }
}

结果

解答成功:
	执行耗时:2 ms,击败了1.02% 的Java用户
	内存消耗:39.8 MB,击败了12.64% 的Java用户

思路

1. 左边按左、中、右的顺序遍历
2. 右边按右、中、左的顺序遍历
3. 比较两次遍历结果是否相等

优化1

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if (root==null)return true;
        StringBuilder leftSB = new StringBuilder();
        StringBuilder rightSB = new StringBuilder();
        leftMethod(root.left,leftSB);
        rightMethod(root.right,rightSB);
        return leftSB.toString().equals(rightSB.toString());
    }

    private void leftMethod(TreeNode node, StringBuilder sb){
        sb.append(node==null?null:node.val);
        if (node==null)return;
        leftMethod(node.left,sb);
        leftMethod(node.right,sb);
    }
    private void rightMethod(TreeNode node,StringBuilder sb){
        sb.append(node==null?null:node.val);
        if (node==null)return;
        rightMethod(node.right,sb);
        rightMethod(node.left,sb);
    }
}

结果

解答成功:
	执行耗时:1 ms,击败了9.15% 的Java用户
	内存消耗:39.7 MB,击败了21.64% 的Java用户

思路

1. 把StringBuilder使用Stack替代
2. 左边入栈
3. 右边出栈

栈

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if (root==null)return true;
        Stack<Integer> stack = new Stack<>();
        leftMethod(root.left,stack);
        System.out.println();
        if (!rightMethod(root.right,stack)) return false;
        System.out.println();
        return stack.empty();
    }

    private void leftMethod(TreeNode node, Stack<Integer> stack){
        if (node==null){
            System.out.print((String) null);
            stack.push(null);
            return;
        }
        leftMethod(node.left,stack);
        leftMethod(node.right,stack);
        System.out.print(node.val);
        stack.push(node.val);
    }
    private boolean rightMethod(TreeNode node,Stack<Integer> stack){
        if (stack.empty()) return false;
        if (node==null){
            System.out.print((String) null);
            if (stack.peek() == null){
                stack.pop();
                return true;
            }
            return false;
        }
        System.out.print(node.val);
        if (stack.peek()==null ||stack.pop() != node.val){
            stack.pop();
        }
        if (!rightMethod(node.left,stack)) return false;
        if (!rightMethod(node.right,stack)) return false;
        return true;
    }
}

结果

解答成功:
	执行耗时:14 ms,击败了0.60% 的Java用户
	内存消耗:39.8 MB,击败了12.15% 的Java用户

分析

1. 看了解析后，递归可以用另一种方式实现
2. 比较左边和右边
3. 比较里面

实现

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if (root==null)return true;
        return method(root.left,root.right);
    }

    private boolean method(TreeNode left, TreeNode right){
        if (left==null&&right==null)return true;
        if (left==null||right==null)return false;
        if (left.val!=right.val) return false;
        boolean flag1= method(left.left,right.right);
        boolean flag2= method(left.right,right.left);
        return flag1&&flag2;
    }
}

结果

解答成功:
	执行耗时:0 ms,击败了100.00% 的Java用户
	内存消耗:39.2 MB,击败了95.40% 的Java用户