1.对称二叉树
思路:递归; 普通队列
注意:需要对false的情况进行讨论,
1.左节点为空,右节点不为空,不对称,return false
2.左不为空,右为空,不对称 return false
3.左右都为空,对称,返回true
4.左右都不为空,比较节点数值,不相同就return false
5.
比较二叉树外侧是否对称:传入的是左节点的左孩子,右节点的右孩子。
比较内侧是否对称,传入左节点的右孩子,右节点的左孩子。
如果左右都对称就返回true ,有一侧不对称就返回false 。
解法一(递归):
public boolean isSymmetric1(TreeNode root) {
return compare(root.left, root.right);
}
private boolean compare(TreeNode left, TreeNode right) {
// 均为null的情况
if (left == null && right == null)
return true;
// 1.2.4情况的汇总
else if (left == null || right == null || left.val != right.val)
return false;
// 第5种情况讨论
boolean compareOut = compare(left.left, right.right);
boolean compareIn = compare(left.right, right.left);
return compareIn && compareOut;
}
解法二(队列):
public boolean isSymmetric(TreeNode root) {
Queue<TreeNode> deque = new LinkedList<>();
deque.offer(root.left);
deque.offer(root.right);
while (!deque.isEmpty()) {
TreeNode leftNode = deque.poll();
TreeNode rightNode = deque.poll();
if (leftNode == null && rightNode == null) {
continue;
}
if (leftNode == null || rightNode == null || leftNode.val != rightNode.val) {
return false;
}
// 这里顺序需要注意,先比较外侧
deque.offer(leftNode.left);
deque.offer(rightNode.right);
deque.offer(leftNode.right);
deque.offer(rightNode.left);
}
return true;
}
2.二叉树最大深度
思路:层序遍历; 后序遍历递归
注意:这里直接套用层序遍历的模板就行
解法一(层序遍历):
public int maxDepth(TreeNode root){
if (root == null)
return 0;
// 层序遍历
Queue<TreeNode> que = new LinkedList<>();
que.offer(root);
int num = 0;
while (!que.isEmpty()) {
int len = que.size();
num++;
while (len --> 0) {
TreeNode tmpNode = que.poll();
if (tmpNode.left != null)
que.offer(tmpNode.left);
if (tmpNode.right != null)
que.offer(tmpNode.right);
}
}
return num;
}
解法二(后序遍历递归)
public int maxDepth(TreeNode root) {
if (root == null) {
return 0;
}
int leftDepth = maxDepth1(root.left);
int rightDepth = maxDepth1(root.right);
return Math.max(leftDepth, rightDepth) + 1;
}
3.二叉树最小深度
思路:依然是层序遍历;后序遍历递归
注意:
1.当层序遍历到叶结点时,直接返回num值,因为此时是第一次遍历到叶结点,必然是最小深度
2.
解法一(层序遍历):
public int minDepth(TreeNode root){
if (root == null)
return 0;
// 层序遍历
Queue<TreeNode> que = new LinkedList<>();
que.offer(root);
int num = 0;
while (!que.isEmpty()) {
int len = que.size();
num++;
while (len --> 0) {
TreeNode tmpNode = que.poll();
if (tmpNode.left == null && tmpNode.right == null)
return num;
if (tmpNode.left != null)
que.offer(tmpNode.left);
if (tmpNode.right != null)
que.offer(tmpNode.right);
}
}
return num;
}
解法二(后序遍历递归):
public int minDepth(TreeNode root) {
if (root == null)
return 0;
int leftDepth = minDepth1(root.left);
int rightDepth = minDepth1(root.right);
// 如果左子树为空,右子树不为空,说明最小深度是 1 + 右子树的深度
if (root.left == null)
return 1 + rightDepth;
if (root.right == null)
return 1 + leftDepth;
return Math.min(leftDepth , rightDepth) + 1;
}