求二叉树最小深度 递归
class Solution {
public int minDepth(TreeNode root) {
if(root==null) return 0;
return helper(root);
}
public int helper(TreeNode root){
if(root==null) return Integer.MAX_VALUE;//因为是最小深度 不能返回0
if(root.left==null && root.right==null) return 1;
return Math.min(helper( root.right),helper(root.left))+1;
}
}
一行代码解决:
class Solution {
public int maxDepth(TreeNode root) {
return root == null ? 0 : Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
}
}
反转二叉树
3.29自己写的
class Solution {
public TreeNode invertTree(TreeNode root) {
if(root==null) return null;
TreeNode tmp=root.left;
root.left=root.right;
root.right=tmp;
invertTree(root.left);
invertTree(root.right);
return root;
}
}
别人写的
class Solution {
public TreeNode invertTree(TreeNode root) {
if(root==null) return null;
invertTree(root.left);
invertTree(root.right);
TreeNode temp=root.left;
root.left=root.right;
root.right=temp;
return root;
}
}
另一种写法:
class Solution {
public TreeNode invertTree(TreeNode root) {
if(root==null) return null;
TreeNode left=invertTree(root.left);
TreeNode right=invertTree(root.right);
root.left=right;
root.right=left;
return root;
}
}
判断二叉树对称
自己3.29 写的
/**
* 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) {
if(root==null) return true;
return helper(root,root);
}
private boolean helper(TreeNode left,TreeNode right){
if(right==null && left==null) return true;
if(right==null || left==null) return false;
if(left.val!=right.val) return false;
return helper(left.left,right.right) && helper(left.right,right.left);
}
}
递归
要把几个情况都想出来 false 的 true 的
class Solution {
public boolean isSymmetric(TreeNode root) {
if(root==null) return true;
return helper(root,root);
}
public boolean helper(TreeNode root1,TreeNode root2){
if(root1==null && root2==null) return true;
if(root1==null || root2==null) return false;
if(root1.val!=root2.val) return false;
return helper(root1.left,root2.right) && helper(root1.right,root2.left);
}
}
时间复杂度:O(n),因为我们遍历整个输入树一次,所以总的运行时间为 O(n),其中 n是树中结点的总数。
空间复杂度:递归调用的次数受树的高度限制。在最糟糕情况下,树是线性的,其高度为 O(n)。因此,在最糟糕的情况下,由栈上的递归调用造成的空间复杂度为 O(n)。
迭代
队列中每两个连续的结点应该是相等的,而且它们的子树互为镜像。
最初,队列中包含的是 root 以及 root。
该算法的工作原理类似于 BFS,但存在一些关键差异。每次提取两个结点并比较它们的值。
然后,将两个结点的左右子结点按相反的顺序插入队列中。当队列为空时,或者我们检测到树不对称(即从队列中取出两个不相等的连续结点)时,该算法结束。
public boolean isSymmetric(TreeNode root) {
Queue<TreeNode> q = new LinkedList<>();
q.add(root);
q.add(root);
while (!q.isEmpty()) {
TreeNode t1 = q.poll();
TreeNode t2 = q.poll();
if (t1 == null && t2 == null) continue;
if (t1 == null || t2 == null) return false;
if (t1.val != t2.val) return false;
q.add(t1.left);
q.add(t2.right);
q.add(t1.right);
q.add(t2.left);
}
return true;
}
思考:先判断 ,后添加,成对成对添加
求二叉树节点个数
给出一个完全二叉树,求出该树的节点个数。
说明:
完全二叉树的定义如下:在完全二叉树中,除了最底层节点可能没填满外,其余每层节点数都达到最大值,并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层,则该层包含 1~ 2h 个节点。
示例:
输入:
1
/
2 3
/ \ /
4 5 6
普通二叉树递归求个数
class Solution {
public int countNodes(TreeNode root) {
if(root==null) return 0;
int left=countNodes(root.left);
int right=countNodes(root.right);
return 1+left+right;
}
}
以上方法容易理解但是没有利用完全二叉树的特点
巧方法(3.29再思考思考)
首先需要明确完全二叉树的定义:它是一棵空树或者它的叶子节点只出在最后两层,若最后一层不满则叶子节点只在最左侧。
再来回顾一下满二叉的节点个数怎么计算,如果满二叉树的层数为h,则总节点数为:2^h - 1.
那么我们来对root节点的左右子树进行高度统计,分别记为left和right,有以下两种结果:
- left == right。这说明,左子树一定是满二叉树,因为节点已经填充到右子树了,左子树必定已经填满了。所以左子树的节点总数我们可以直接得到,是2^left - 1,加上当前这个root节点,则正好是2^left。再对右子树进行递归统计。
- left != right。说明此时最后一层不满,但倒数第二层已经满了,可以直接得到右子树的节点个数。同理,右子树节点+root节点,总数为2^right。再对左子树进行递归查找。
关于如何计算二叉树的层数,可以利用下面的递归来算,当然对于完全二叉树,可以利用其特点,不用递归直接算,具体请参考最后的完整代码。
如何计算2^left,最快的方法是移位计算,因为运算符的优先级问题,记得加括号哦。
class Solution {
public int countNodes(TreeNode root) {
if(root==null) return 0;
int left=countLevel(root.left);
int right=countLevel(root.right);
if(left==right) {
return countNodes(root.right)+(1<<left);
}else
return countNodes(root.left)+(1<<right);
}
public int countLevel(TreeNode root){
int level=0;
while(root!=null){
level++;
root=root.left;
}
return level;
}
}
/*
判断平衡二叉树
给定一个二叉树,判断它是否是高度平衡的二叉树。
本题中,一棵高度平衡二叉树定义为:
一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。
示例 1:
给定二叉树 [3,9,20,null,null,15,7]
3
/
9 20
/
15 7
返回 true 。
递归
从底至顶(提前阻断法)
对二叉树做深度优先遍历DFS,递归过程中:
终止条件:当DFS越过叶子节点时,返回高度0;
返回值:
从底至顶,返回以每个节点root为根节点的子树最大高度(左右子树中最大的高度值加1max(left,right) + 1);
当我们发现有一例 左/右子树高度差 > 1 的情况时,代表此树不是平衡树,返回-1;
当发现不是平衡树时,后面的高度计算都没有意义了,因此一路返回-1,避免后续多余计算。
最差情况是对树做一遍完整DFS,时间复杂度为 O(N)。
class Solution {
public boolean isBalanced(TreeNode root) {
return depth(root) != -1;
}
private int depth(TreeNode root) {
if (root == null) return 0;
int left = depth(root.left);
if(left == -1) return -1;
int right = depth(root.right);
if(right == -1) return -1;
return Math.abs(left - right) < 2 ? Math.max(left, right) + 1 : -1;
}
}
class Solution {
public boolean isBalanced(TreeNode root) {
return depth(root)!=-1;
}
public int depth(TreeNode root){
if(root==null) return 0;
int left=depth(root.left);
int right=depth(root.right);
if(left==-1) return -1;
if(right==-1) return -1;
if(Math.abs(left-right)<2)
return Math.max(left,right)+1;
else
return -1;
}
}
/*