101.Symmetric Tree

时间：2017-09-16 12:38:26 阅读：185 评论：0 收藏：0 [点我收藏+]

题目链接：https://leetcode.com/problems/symmetric-tree/description/

题目大意：给出一个二叉树，判断其是否是对称的，例子如下

技术分享

法一：用常规层序遍历一直WA，代码如下（此代码依旧WA，有时间再改吧）：

 1     public static boolean isSymmetric(TreeNode root) {
 2         if(root == null) {
 3             return true;
 4         }
 5         boolean flag = true;
 6         Queue<TreeNode> queue = new LinkedList<TreeNode>();
 7         queue.offer(root);
 8         int end = 1;
 9         Queue<Integer> cnt = new LinkedList<Integer>();
10         cnt.offer(1);
11         List<TreeNode> listNode = new ArrayList<TreeNode>();
12         while(!queue.isEmpty()) {
13             TreeNode node = queue.poll();
14             Integer tmp = cnt.poll();
15             listNode.add(node);
16             if(node.left != null) {
17                 queue.offer(node.left);
18                 cnt.offer(2 * tmp);
19             }
20             if(node.right != null) {
21                 queue.offer(node.right);
22                 cnt.offer(2 * tmp + 1);
23             }
24             if(tmp == end) {
25        //         System.out.println("end:" + end);
26                 if(node.right != null) {
27                     end = 2 * tmp + 1;
28                 }
29                 else if(node.left != null) {
30                     end = 2 * tmp;
31                 }
32                 int length = listNode.size();
33                 for(int i = 0; i < length / 2; i++) {
34                     if((listNode.get(i) == null && listNode.get(length - 1 - i) != null) ||
35                         (listNode.get(i) != null && listNode.get(length - 1 - i) == null)) {
36                         flag = false;
37                         break;
38                     }
39                     else if(listNode.get(i) != null && listNode.get(length - 1 - i) != null) {
40                         if(listNode.get(i).val != listNode.get(length - 1 - i).val) {
41                             flag = false;
42                             break;
43                         }
44                     }
45                 }
46                 if(flag == false) {
47                     return flag;
48                 }
49                 listNode.clear();
50             }
51         }
52         return flag;
53     }

View Code

法二（借鉴）：看完题解后，利用层序遍历的变种，每次进队时同时压入左右孩子，注意压入的顺序，代码如下（耗时2ms）：

 1     public static boolean isSymmetric(TreeNode root) {
 2         Queue<TreeNode> queue = new LinkedList<TreeNode>();
 3         queue.offer(root);
 4         queue.offer(root);
 5         boolean flag = true;
 6         while(!queue.isEmpty()) {
 7             TreeNode nodeLeft = queue.poll();
 8             TreeNode nodeRight = queue.poll();
 9             
10             if((nodeLeft != null && nodeRight == null) || (nodeLeft == null && nodeRight != null)) {
11                 return false;
12             }
13             else if(nodeLeft != null && nodeRight != null) {
14                 if(nodeLeft.val != nodeRight.val) {
15                     return false;
16                 }
17                 else {
18                     queue.offer(nodeLeft.left);
19                     queue.offer(nodeRight.right);
20                     
21                     queue.offer(nodeLeft.right);
22                     queue.offer(nodeRight.left);
23                 }
24             }
25         }
26         return flag;
27     }

View Code

法三（借鉴）：利用双端队列来做，思想与法二类似，每次同时压入左右孩子，只是这里用到了java中的双端队列类，代码如下（耗时3ms）：

 1     public static boolean isSymmetric(TreeNode root) {
 2         Deque<TreeNode> queue = new LinkedList<TreeNode>();
 3         queue.offerFirst(root);
 4         queue.offerLast(root);
 5         boolean flag = true;
 6         while(!queue.isEmpty()) {
 7             TreeNode nodeLeft = queue.pollFirst();
 8             TreeNode nodeRight = queue.pollLast();
 9             
10             if((nodeLeft != null && nodeRight == null) || (nodeLeft == null && nodeRight != null)) {
11                 return false;
12             }
13             else if(nodeLeft != null && nodeRight != null) {
14                 if(nodeLeft.val != nodeRight.val) {
15                     return false;
16                 }
17                 else {
18                     queue.offerFirst(nodeLeft.left);
19                     queue.offerFirst(nodeLeft.right);
20                     
21                     queue.offerLast(nodeRight.right);
22                     queue.offerLast(nodeRight.left);
23                 }
24             }
25         }
26         return flag;
27     }

View Code

法四（借鉴）：这个比较难，利用递归左右子树同时判断，代码如下（耗时0ms）：

 1     public static boolean isSymmetric(TreeNode root) {
 2         if(root == null) {
 3             return true;
 4         }
 5         return isSymmetric2(root, root);
 6     }
 7     public static boolean isSymmetric2(TreeNode root1, TreeNode root2) {
 8         if(root1 == null && root2 == null) {
 9             return true;
10         }
11         else if(root1 == null || root2 == null) {
12             return false;
13         }
14         else {
15             if(root1.val != root2.val) {
16                 return false;
17             }
18             else {
19                 return isSymmetric2(root1.left, root2.right) && isSymmetric2(root1.right, root2.left);
20             }
21         }
22     }

View Code

101.Symmetric Tree

原文：http://www.cnblogs.com/cing/p/7530713.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)