力扣589、590、102、107、429、199、637、515、116、117、104、111、226、101-Java刷题笔记

一、589. N 叉树的前序遍历 - 力扣（LeetCode）

1.1题目

给定一个 n 叉树的根节点 root ，返回其节点值的 前序遍历 。

n 叉树在输入中按层序遍历进行序列化表示，每组子节点由空值 null 分隔（请参见示例）。

示例 1：

输入：root = [1,null,3,2,4,null,5,6]
输出：[1,3,5,6,2,4]

示例 2：

输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：[1,2,3,6,7,11,14,4,8,12,5,9,13,10]

1.2思路分析

方法一递归

方法二迭代

1.3代码实现

方法一递归

/*
// Definition for a Node.
class Node {public int val;public List<Node> children;public Node() {}public Node(int _val) {val = _val;}public Node(int _val, List<Node> _children) {val = _val;children = _children;}
};
*/
// 递归遍历
class Solution {public List<Integer> preorder(Node root) {List<Integer> res = new ArrayList<>();pre(root,res);return res;}public void pre (Node root ,List<Integer> res){if(root == null) return;// 将根节点的值放入到数组中res.add(root.val);// 循环遍历孩子for(Node ch : root.children){pre(ch,res);} }}

方法二迭代

/*
// Definition for a Node.
class Node {public int val;public List<Node> children;public Node() {}public Node(int _val) {val = _val;}public Node(int _val, List<Node> _children) {val = _val;children = _children;}
};
*/class Solution {public List<Integer> preorder(Node root) {if(root == null) return Collections.emptyList();// 先将根节点放置到栈中；然后依次遍历根节点的所有孩子Stack<Node> stack = new Stack<>();List<Integer> res = new ArrayList<>();stack.push(root);while(!stack.isEmpty()){// 弹出根节点// 并将根节点的值添加到结果数组中Node temp = stack.pop();res.add(temp.val);// 获得该根节点的所有孩子节点并放入到数组中List<Node> children = temp.children;// 将孩子节点依次遍历到栈中 因为入栈顺序是由右向左所以i从children.size()-1开始遍历for(int i = children.size()-1 ; i>=0 ;i--){// 依次遍历孩子节点stack.push(children.get(i));}}return res;}
}

二、590. N 叉树的后序遍历 - 力扣（LeetCode）

2.1题目

给定一个 n 叉树的根节点 root ，返回其节点值的 后序遍历 。

n 叉树在输入中按层序遍历进行序列化表示，每组子节点由空值 null 分隔（请参见示例）。

示例 1：

输入：root = [1,null,3,2,4,null,5,6]
输出：[5,6,3,2,4,1]

示例 2：

输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：[2,6,14,11,7,3,12,8,4,13,9,10,5,1]

提示：

节点总数在范围 [0, 104] 内
0 <= Node.val <= 104
n 叉树的高度小于或等于 1000

2.2思路分析

方法一递归

方法二迭代

2.3代码实现

方法一递归

/*
// Definition for a Node.
class Node {public int val;public List<Node> children;public Node() {}public Node(int _val) {val = _val;}public Node(int _val, List<Node> _children) {val = _val;children = _children;}
};
*/class Solution {public List<Integer> postorder(Node root) {List<Integer> res = new ArrayList<>();pre(root,res);return res;}public void pre(Node node,List<Integer> res){if(node == null) return;for(Node ch : node.children){pre(ch,res);}// 先便孩子，最终使得每个孩子成为根节点，然后再将根节点添加到结果数组中res.add(node.val);}
}

方法二迭代

/*
// Definition for a Node.
class Node {public int val;public List<Node> children;public Node() {}public Node(int _val) {val = _val;}public Node(int _val, List<Node> _children) {val = _val;children = _children;}
};
*/class Solution {public List<Integer> postorder(Node root) {if(root == null) return Collections.emptyList();// 定义栈存放遍历的节点Stack<Node> stack = new Stack<>();List<Integer> res = new ArrayList<>();stack.push(root);while(!stack.isEmpty()){Node temp = stack.pop();res.add(temp.val);List<Node> children = temp.children;// 从左向右遍历for(int i = 0 ;i<children.size(); i++){stack.push(children.get(i));}}Collections.reverse(res);return res;}
}

三、102. 二叉树的层序遍历 - 力扣（LeetCode）

3.1题目

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。（即逐层地，从左到右访问所有节点）。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

3.2思路分析

利用队列先入先出的特性存放每层的节点并依次遍历，先根，然后存放根的左孩子与右孩子，依次类推。

3.3代码实现

/*** Definition for a binary tree node.* public class TreeNode {*     int val;*     TreeNode left;*     TreeNode right;*     TreeNode() {}*     TreeNode(int val) { this.val = val; }*     TreeNode(int val, TreeNode left, TreeNode right) {*         this.val = val;*         this.left = left;*         this.right = right;*     }* }*/
class Solution {// 定义一个结果数组List<List<Integer>> resultList = new ArrayList<List<Integer>>();public List<List<Integer>> levelOrder(TreeNode root) {if(root == null) return resultList;fun(root,0);return resultList;}public void  fun(TreeNode root ,int deep){// 定义一个队列存放节点Queue <TreeNode> queue = new LinkedList<>();// 定义个临时节点存放结果TreeNode temp;// 将根节点放入到队列中queue.offer(root);while(!queue.isEmpty()){// 定义放在循环里面保证每次生成一个新的结果数组List <Integer> result = new ArrayList<>();// 每层循环遍历完更新deepdeep = queue.size();// 将每层的节点依次放入到结果队列中while(deep >0 ){temp = queue.poll();result.add(temp.val);// 将左孩子与右孩子依次放入到队列中if(temp.left != null) queue.offer(temp.left);if(temp.right != null) queue.offer(temp.right);deep--;}resultList.add(result);}}
}

四、107. 二叉树的层序遍历 II - 力扣（LeetCode）

4.1题目

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。（即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[15,7],[9,20],[3]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

4.2思路分析

先层序遍历再反转

4.3代码实现

/*** Definition for a binary tree node.* public class TreeNode {*     int val;*     TreeNode left;*     TreeNode right;*     TreeNode() {}*     TreeNode(int val) { this.val = val; }*     TreeNode(int val, TreeNode left, TreeNode right) {*         this.val = val;*         this.left = left;*         this.right = right;*     }* }*/// 先层序遍历再反转
class Solution {// 定义一个结果数组放置结果List<List<Integer>> resultList = new ArrayList<List<Integer>>();public List<List<Integer>> levelOrderBottom(TreeNode root) {if(root == null) return resultList;fun(root,0);// Collections.reverse()没有返回值Collections.reverse(resultList);return resultList;}public void fun(TreeNode node, int deep){//定义队列放置结果Queue <TreeNode> queue = new LinkedList<>();TreeNode temp;queue.offer(node);while(!queue.isEmpty()){deep = queue.size();List<Integer> result = new ArrayList<>();while(deep>0){temp = queue.poll();result.add(temp.val);if(temp.left != null ) queue.offer(temp.left);if(temp.right!=null) queue.offer(temp.right);deep--;}resultList.add(result);}}
}

五、429. N 叉树的层序遍历 - 力扣（LeetCode）

5.1题目

给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。

树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。

示例 1：

输入：root = [1,null,3,2,4,null,5,6]
输出：[[1],[3,2,4],[5,6]]

示例 2：

输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]

5.2思路分析

定义队列对n叉树进行依次遍历，根据队列的大小控制队列每层需要出的根节点数量，弹出后，再将根节点的所有孩子加入到队列中，并跟新队列的大小。

5.3代码实现

/*
// Definition for a Node.
class Node {public int val;public List<Node> children;public Node() {}public Node(int _val) {val = _val;}public Node(int _val, List<Node> _children) {val = _val;children = _children;}
};
*/class Solution {List<List<Integer>> result = new ArrayList<List<Integer>>();public List<List<Integer>> levelOrder(Node root) {if(root == null) return result;fun(root,0);return result;}public void fun(Node root, int deep){Queue <Node> queue = new LinkedList<>();queue.offer(root);while(!queue.isEmpty()){List<Integer> res = new ArrayList<>();deep = queue.size();while(deep>0){Node temp = queue.poll();res.add(temp.val);List<Node> children =temp.children;for(Node ch:children){queue.offer(ch);}deep--;}result.add(res);}}}

六、199. 二叉树的右视图 - 力扣（LeetCode）

6.1题目

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例 1:

输入: [1,2,3,null,5,null,4]
输出: [1,3,4]

示例 2:

输入: [1,null,3]
输出: [1,3]

示例 3:

输入: []
输出: []

6.2思路分析

二叉树的右视图其实就是当前层的最后一个节点的值

6.3代码实现

/*** Definition for a binary tree node.* public class TreeNode {*     int val;*     TreeNode left;*     TreeNode right;*     TreeNode() {}*     TreeNode(int val) { this.val = val; }*     TreeNode(int val, TreeNode left, TreeNode right) {*         this.val = val;*         this.left = left;*         this.right = right;*     }* }*/
class Solution {List<Integer> result = new ArrayList<>();public List<Integer> rightSideView(TreeNode root) {if (root == null) return result;fun(root,0);return result;}public void fun(TreeNode root,int deep){Queue <TreeNode> queue = new LinkedList<>();queue.offer(root);while(!queue.isEmpty()){deep = queue.size();for(int i = 0; i<deep;i++){TreeNode temp = queue.poll();if(temp.left!=null) queue.offer(temp.left);if(temp.right!= null) queue.offer(temp.right);// 右视图的结果其实就是当前层的最后一个节点if(i == deep - 1) result.add(temp.val);}  }}
}

七、637. 二叉树的层平均值 - 力扣（LeetCode）

7.1题目

给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[3.00000,14.50000,11.00000]
解释：第 0 层的平均值为 3,第 1 层的平均值为 14.5,第 2 层的平均值为 11 。
因此返回 [3, 14.5, 11] 。

示例 2:

输入：root = [3,9,20,15,7]
输出：[3.00000,14.50000,11.00000]

7.2思路分析

对每层的节点求和取平均。

7.3代码实现

/*** Definition for a binary tree node.* public class TreeNode {*     int val;*     TreeNode left;*     TreeNode right;*     TreeNode() {}*     TreeNode(int val) { this.val = val; }*     TreeNode(int val, TreeNode left, TreeNode right) {*         this.val = val;*         this.left = left;*         this.right = right;*     }* }*/
class Solution {List<Double> res = new ArrayList<>();public List<Double> averageOfLevels(TreeNode root) {fun(root,0);return res;}public void fun(TreeNode root,int deep){if(root == null) return ;Queue<TreeNode> queue  = new LinkedList<>();TreeNode temp;queue.offer(root);while(!queue.isEmpty()){Double sum = 0D ;deep = queue.size();int cur = deep;while(deep>0){temp = queue.poll();sum += temp.val;if(temp.left!=null) queue.offer(temp.left);if(temp.right!=null) queue.offer(temp.right);deep--;}res.add(sum/cur);}}
}

八、515. 在每个树行中找最大值 - 力扣（LeetCode）

8.1题目

给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。

示例1：

输入: root = [1,3,2,5,3,null,9]
输出: [1,3,9]

示例2：

输入: root = [1,2,3]
输出: [1,3]

8.2思路分析

初始化最大值时需要考虑负数情况，因此需要将其初始化为最小的整数

8.3代码实现

/*** Definition for a binary tree node.* public class TreeNode {*     int val;*     TreeNode left;*     TreeNode right;*     TreeNode() {}*     TreeNode(int val) { this.val = val; }*     TreeNode(int val, TreeNode left, TreeNode right) {*         this.val = val;*         this.left = left;*         this.right = right;*     }* }*/
class Solution {List<Integer> result = new ArrayList<>();public List<Integer> largestValues(TreeNode root) {fun(root,0);return result;}public void fun(TreeNode node ,int deep){if(node == null) return;Queue <TreeNode> queue = new LinkedList<>();queue.offer(node);while(!queue.isEmpty()){deep = queue.size();int maxTemp = Integer.MIN_VALUE;while(deep>0){TreeNode temp = queue.poll();maxTemp = temp.val > maxTemp ? temp.val:maxTemp;if(temp.left != null) queue.offer(temp.left);if(temp.right != null) queue.offer(temp.right);deep--;}result.add(maxTemp);}}
}

九、116. 填充每个节点的下一个右侧节点指针 - 力扣（LeetCode）

9.1题目

给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {int val;Node *left;Node *right;Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

示例 1：

输入：root = [1,2,3,4,5,6,7]
输出：[1,#,2,3,#,4,5,6,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，'#' 标志着每一层的结束。

示例 2:

输入：root = []
输出：[]

9.2思路分析

每个node左子树的next就是node的右子树，每个node右子树的next就是node.next的左子树

9.3代码实现

/*
// Definition for a Node.
class Node {public int val;public Node left;public Node right;public Node next;public Node() {}public Node(int _val) {val = _val;}public Node(int _val, Node _left, Node _right, Node _next) {val = _val;left = _left;right = _right;next = _next;}
};
*/class Solution {public Node connect(Node root) {dfs(root, null);return root;}public void dfs(Node node ,Node next){if(node != null){node.next = next;dfs(node.left,node.right);dfs(node.right, node.next  != null ? node.next.left : null );}}
}

十、117. 填充每个节点的下一个右侧节点指针 II - 力扣（LeetCode）

10.1题目

给定一个二叉树：

struct Node {int val;Node *left;Node *right;Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL 。

初始状态下，所有 next 指针都被设置为 NULL 。

示例 1：

输入：root = [1,2,3,4,5,null,7]
输出：[1,#,2,3,#,4,5,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化输出按层序遍历顺序（由 next 指针连接），'#' 表示每层的末尾。

示例 2：

输入：root = []
输出：[]

10.2思路分析

先进行层次遍历，然后将每层的头节点连起来，每层的末尾节点使其指向空

10.3代码实现

/*
// Definition for a Node.
class Node {public int val;public Node left;public Node right;public Node next;public Node() {}public Node(int _val) {val = _val;}public Node(int _val, Node _left, Node _right, Node _next) {val = _val;left = _left;right = _right;next = _next;}
};
*/
// 层序遍历，并将每次的头节点用链表连接起来
class Solution {public Node connect(Node root) {// 定义一个节点放置头指针Node ans = root;if(root == null) return ans;Queue <Node> queue = new LinkedList<>();queue.offer(root);while(!queue.isEmpty()){int size = queue.size();while(size-->0){Node temp = queue.poll();// 当size为0时temp.next指向空指针if(size!=0)temp.next = queue.peek();if(temp.left!=null) queue.offer(temp.left);if(temp.right != null) queue.offer(temp.right);// size--;}}return ans;}
}

十一、104. 二叉树的最大深度 - 力扣（LeetCode）

11.1题目

给定一个二叉树 root ，返回其最大深度。

二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：3

示例 2：

输入：root = [1,null,2]
输出：2

11.2思路分析

定义一个变量用来统计层深

11.3代码实现

/*** Definition for a binary tree node.* public class TreeNode {*     int val;*     TreeNode left;*     TreeNode right;*     TreeNode() {}*     TreeNode(int val) { this.val = val; }*     TreeNode(int val, TreeNode left, TreeNode right) {*         this.val = val;*         this.left = left;*         this.right = right;*     }* }*/
class Solution {public int maxDepth(TreeNode root) {int deep = 0;if(root == null) return deep;Queue <TreeNode> queue = new LinkedList<>();queue.offer(root);while(!queue.isEmpty()){int size = queue.size();while(size>0){TreeNode temp = queue.poll();if(temp.left!=null) queue.offer(temp.left);if(temp.right!=null) queue.offer(temp.right);size--;}deep++;}return deep; }
}

十二、111. 二叉树的最小深度 - 力扣（LeetCode）

12.1题目

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明：叶子节点是指没有子节点的节点。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：2

示例 2：

输入：root = [2,null,3,null,4,null,5,null,6]
输出：5

12.2思路分析

当左节点与右节点同时为空时，此时为最短的路径

12.3代码实现

/*** Definition for a binary tree node.* public class TreeNode {*     int val;*     TreeNode left;*     TreeNode right;*     TreeNode() {}*     TreeNode(int val) { this.val = val; }*     TreeNode(int val, TreeNode left, TreeNode right) {*         this.val = val;*         this.left = left;*         this.right = right;*     }* }*/
class Solution {public int minDepth(TreeNode root) {int deep = 1;Queue<TreeNode> queue = new LinkedList<>();queue.offer(root);while(!queue.isEmpty()){int size = queue.size();while(size>0){TreeNode temp = queue.poll();if(temp == null) return 0;if(temp.left == null && temp.right == null){return deep;}if(temp.left!=null) queue.offer(temp.left);if(temp.right!= null) queue.offer(temp.right);size--;}deep++;}return deep;}
}

十三、226. 翻转二叉树 - 力扣（LeetCode）

13.1题目

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

示例 1：

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

示例 2：

输入：root = [2,1,3]
输出：[2,3,1]

示例 3：

输入：root = []
输出：[]

13.2思路分析

方法一递归

方法二迭代

13.3代码实现

方法一递归

前序

/*** Definition for a binary tree node.* public class TreeNode {*     int val;*     TreeNode left;*     TreeNode right;*     TreeNode() {}*     TreeNode(int val) { this.val = val; }*     TreeNode(int val, TreeNode left, TreeNode right) {*         this.val = val;*         this.left = left;*         this.right = right;*     }* }*/
class Solution {public TreeNode invertTree(TreeNode root) {if(root == null) return root;// 采用前序遍历// 交换左右孩子TreeNode temp = root.left;root.left = root.right;root.right = temp;// 对坐孩子进行遍历invertTree(root.left);invertTree(root.right);return root;}}

后序

/*** Definition for a binary tree node.* public class TreeNode {*     int val;*     TreeNode left;*     TreeNode right;*     TreeNode() {}*     TreeNode(int val) { this.val = val; }*     TreeNode(int val, TreeNode left, TreeNode right) {*         this.val = val;*         this.left = left;*         this.right = right;*     }* }*/
class Solution {public TreeNode invertTree(TreeNode root) {if(root == null) return root;// 采用后序遍历// 先对孩子进行遍历invertTree(root.left);invertTree(root.right);// 交换左右孩子TreeNode temp = root.left;root.left = root.right;root.right = temp;return root;}}

方法二迭代

前序

/*** Definition for a binary tree node.* public class TreeNode {*     int val;*     TreeNode left;*     TreeNode right;*     TreeNode() {}*     TreeNode(int val) { this.val = val; }*     TreeNode(int val, TreeNode left, TreeNode right) {*         this.val = val;*         this.left = left;*         this.right = right;*     }* }*/
class Solution {public TreeNode invertTree(TreeNode root) {if(root == null) return root;Stack<TreeNode> stack = new Stack<>();stack.push(root);while(!stack.isEmpty()){int size = stack.size();TreeNode temp = stack.pop();TreeNode temp1 = temp.left;temp.left = temp.right;temp.right = temp1;if(temp.right != null) stack.push(temp.right);if(temp.left!= null) stack.push(temp.left);}return root;}}

后续

/*** Definition for a binary tree node.* public class TreeNode {*     int val;*     TreeNode left;*     TreeNode right;*     TreeNode() {}*     TreeNode(int val) { this.val = val; }*     TreeNode(int val, TreeNode left, TreeNode right) {*         this.val = val;*         this.left = left;*         this.right = right;*     }* }*/
class Solution {public TreeNode invertTree(TreeNode root) {if(root == null) return root;Stack<TreeNode> stack = new Stack<>();stack.push(root);while(!stack.isEmpty()){int size = stack.size();TreeNode temp = stack.pop();if(temp.right != null) stack.push(temp.right);if(temp.left!= null) stack.push(temp.left);TreeNode temp1 = temp.left;temp.left = temp.right;temp.right = temp1;}return root;}}

层序

/*** Definition for a binary tree node.* public class TreeNode {*     int val;*     TreeNode left;*     TreeNode right;*     TreeNode() {}*     TreeNode(int val) { this.val = val; }*     TreeNode(int val, TreeNode left, TreeNode right) {*         this.val = val;*         this.left = left;*         this.right = right;*     }* }*/
class Solution {public TreeNode invertTree(TreeNode root) {if(root == null) return root;Queue<TreeNode> queue = new LinkedList<>();TreeNode node,temp;queue.offer(root);while(!queue.isEmpty()){int size = queue.size();while(size>0){temp = queue.poll();// 交换节点的左右子节点node = temp.left;temp.left = temp.right;temp.right = node; if(temp.left!= null) queue.offer(temp.left);if(temp.right!=null) queue.offer(temp.right);size--;}}return root;}
}

十四、101. 对称二叉树 - 力扣（LeetCode）

14.1题目

给你一个二叉树的根节点 root ，检查它是否轴对称。

示例 1：

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

示例 2：

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

14.2思路分析

方法一递归

方法二迭代

首先要比较的顺序，有叶子节点向根节点比较，同时叶子节点再比较时，应该分为外侧的两个节点进行比较与内侧两个节点比较，如果两次比较的结果完全相同才是完全相同的。

比较的几个规则：

左侧不为空且右侧为空时，不对称；

左侧为空且右侧不为空时，不对称；

左侧和右侧都为空时，需要进一步判断下一个节点；

左侧右侧都不为空，且左侧的值与右侧的值不相等时，不对称。

14.4代码实现

方法一递归

/*** Definition for a binary tree node.* public class TreeNode {*     int val;*     TreeNode left;*     TreeNode right;*     TreeNode() {}*     TreeNode(int val) { this.val = val; }*     TreeNode(int val, TreeNode left, TreeNode right) {*         this.val = val;*         this.left = left;*         this.right = right;*     }* }*/
class Solution {public boolean isSymmetric(TreeNode root) {return compare(root.left,root.right);}public boolean compare(TreeNode left,TreeNode right){if(left == null && right != null) return false;if(left != null && right == null) return false;if(left == null && right == null) return true;if(left.val != right.val) return false;boolean outside = compare(left.left,right.right);boolean inseide = compare(left.right,right.left);return outside && inseide;}
}

方法二迭代

/*** Definition for a binary tree node.* public class TreeNode {*     int val;*     TreeNode left;*     TreeNode right;*     TreeNode() {}*     TreeNode(int val) { this.val = val; }*     TreeNode(int val, TreeNode left, TreeNode right) {*         this.val = val;*         this.left = left;*         this.right = right;*     }* }*/
class Solution {public boolean isSymmetric(TreeNode root) {Stack<TreeNode> stack= new Stack<>();// 将左节点与右节点分辨传入到栈中stack.push(root.left);stack.push(root.right);while(!stack.isEmpty()){TreeNode right = stack.pop();TreeNode left = stack.pop();if(right != null && left == null) return false;if(right == null && left != null) return false;if(right == null && left == null) continue;if(right.val != left.val) return false;// 因为栈是先入后出// 所以先比较将内侧放入栈中，这样再比较时就是先比较外侧stack.push(left.right);stack.push(right.left);// 进一步比较外侧stack.push(left.left);stack.push(right.right);}return true;}
}