104.二叉树的最大深度
import java.util.ArrayDeque;
import java.util.Deque;
public class day16_104_二叉数的最大深度 {
public static 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;
}
}
public static void main(String[] args) {
}
public static int diguiti(TreeNode demo){
if (demo==null) {
return 0;
}
int leftdep=diguiti(demo.left);
int rightdep=diguiti(demo.right);
int myhigh=Math.max(leftdep, rightdep)+1;
//根节点的高度就是左右节点的最高高度然后再加上一就对了
return myhigh;
}
//层序遍历比较简单,便于理解
//尝试写递归的算法
public static int maxdep(TreeNode root){
int high=0;
Deque<TreeNode> temp=new ArrayDeque<>();
//这个是存放节点的
if (root==null) {
return high;
}
temp.offer(root);
//
while (!temp.isEmpty()) {
int len=temp.size();//
for(int i=0;i<len;i++){
TreeNode demo=temp.pollFirst();
if (demo.left!=null) {
temp.offer(demo.left);
}
if (demo.right!=null) {
temp.offer(demo.right);
}
len-=1;
}
high+=1;
}
//这里是判断如果不为空就加入
return high;
}
}
这就是两种写法,第一种就是常规的层序遍历,把一层遍历结束就加一,这是最容易理解的一种
第二种就是用递归,整体递归体的思路就是,先左右,然后是gen,跟的高度就是左右的最大值然后再加上一,这样就的到了。
n叉树的高度
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.LinkedList;
import java.util.List;
public class day16_559_n叉树的最大高度 {
public static class TreeNode {
public int val;
public List<TreeNode> children;
public TreeNode() {}
public TreeNode(int _val) {
val = _val;
}
public TreeNode(int _val, List<TreeNode> _children) {
val = _val;
children = _children;
}
public static void main(String[] args) {
}
//首先尝试一下层序的n叉树的
public static int nmaxdeep(TreeNode root){
int high=0;
if (root==null) {
return 0;
}
Deque<TreeNode> temp=new LinkedList<>();
temp.offer(root);
while (!temp.isEmpty()) {
int len=temp.size();
high+=1;
for(int i=0;i<len;i++){
TreeNode demo=temp.pollFirst();
int chisize=demo.children.size();
for(int j=0;j<chisize;j++){
if (demo.children.get(j)!=null) {
temp.offer(demo.children.get(j));
}
}
}
}
return high;
}
}
}
思路是一样的,就是入队的时候不是左右子树而是遍历子节点的列表
。
最小深度
import java.util.Deque;
import java.util.LinkedList;
public class day16_111_二叉树的最小深度 {
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;
}
}
public static void main(String[] args) {
}
public int minDepth(TreeNode root){
//这就是找最小深度,也就是遇到的第一叶子结点,叶子结点就是左右节点都是空的
Deque<TreeNode> temp=new LinkedList<>();
int high=0;
if (root==null) {
return 0;
}
temp.offer(root);
while (!temp.isEmpty()) {
high+=1;
int len=temp.size();
for(int i=0;i<len;i++){
TreeNode demo=temp.pollFirst();
//第一个弹出
if (demo.left==null&&demo.right==null) {
return high;
}
if (demo.left!=null) {
temp.offer(demo.left);
}
if (demo.right!=null) {
temp.offer(demo.right);
}
}
}
return high;
}
}
记住这个层序遍历的方法就行,遇到的第一个叶子节点,也就是没有左右字数的节点。
求完全二叉树的节点
public class day16_222_完全二叉数节点的数量 {
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;
}
}
public static void main(String[] args) {
}
public int countnode(TreeNode root){
if (root==null) {
return 0;
}
int leftcount=countnode(root.left);
int rightcount=countnode(root.right);
int sum=leftcount+rightcount+1;
return sum;
}
}
会写层序和递归就行了,利用特性没必要