系列文章目录

---

---

104.二叉树的最大深度

①递归法

直接法(求深度，前序遍历)

（1）直接求深度，用前序遍历从上往下遍历，子节点的深度 = 父节点的深度 + 1。

（2）递归三部曲：

1. 确定递归参数和返回值：传入当前节点和父节点的深度。由于是前序遍历，先获取的当前节点的深度，再获取左右节点的深度，此时左右节点的深度返回没有意义。因此，参数为TreeNode类的当前节点，int型的父节点深度，返回值为void。
2. 确定终止条件：当前节点为null时，表示到达了树的底部，计算深度没有意义，直接返回即可。
3. 确定单层递归逻辑：每次向下递归时，深度 deep 都会增加 1，表示遍历到了下一层。将中节点的深度与当前最大深度maxnum比较，更新最大深度。对当前节点的左右子节点进行递归调用。

//递归法(前序，直接法，求深度)
class Solution {//定义最大深度int maxnum = 0;public int maxDepth(TreeNode root) {getdepth(root, 0);return maxnum;}public void getdepth(TreeNode node, int deep) {//确定终止条件if (node == null) {return;}deep++;maxnum = maxnum < deep ? deep : maxnum;getdepth(node.left, deep);getdepth(node.right, deep);}
}

间接法（求高度，后序遍历）

（1）二叉树的最大深度 = 根节点的最大高度，父节点的最大高度 = 左右子节点高度的最大值 + 1（需要先访问左右节点，再访问中节点，所以对应的是后序遍历）
（2）递归三部曲：

1. 确定递归参数和返回值：目的是获取当前节点的高度，输入的是TreeNode类型的节点，输出int型高度。
2. 确定终止条件：如果当前节点为null，则返回高度为0（注意：叶子节点的高度为1）。
3. 确定单层递归逻辑：获取当前节点的高度，即要获取左右子节点的最大高度再+1。

class Solution {public int maxDepth(TreeNode root) {if (root == null) {return 0;}int leftDepth = maxDepth(root.left);int rightDepth = maxDepth(root.right);return Math.max(leftDepth, rightDepth) + 1;}
}

②迭代法（层序遍历中有）

class Solution {public int maxDepth(TreeNode root) {//迭代法Queue<TreeNode> que = new LinkedList<>();if (root == null) {return 0;}que.offer(root);int deep = 0;while (!que.isEmpty()) {int len = que.size();deep++;// 记录深度while (len-- > 0) {TreeNode tempNode = que.poll();if(tempNode.left!=null)que.offer(tempNode.left);if(tempNode.right!=null)que.offer(tempNode.right);}}return deep;}
}

---

559.n叉树的最大深度

①递归法

间接法（后序遍历求高度）

确定单层逻辑时，在循环遍历该节点的子节点时获取所有子节点的高度的最大值，再在循环后+1作为当前节点的高度。

class Solution {public int maxDepth(Node root) {//递归法(后序）if (root == null) return 0;int maxnum = 0;for (Node child : root.children) {maxnum=maxnum < maxDepth(child) ? maxDepth(child) : maxnum;}return maxnum + 1;//中节点}
}

直接法（前序遍历求深度）

class Solution {int maxNum=0;public int maxDepth(Node root) {getDepth(root,0);return maxNum;}public void getDepth(Node node,int deep){if(node==null)return;deep++;maxNum=Math.max(maxNum,deep);for(Node child:node.children){getDepth(child,deep);}}
}

②迭代法（层序遍历）

注：在遍历N个子节点时注意代码的健壮性，要考虑当前节点是否有子节点链表以及链表中的子节点是否为null，不为空时才加入队列中。

List<Node> list = node.children;//代码健壮性if(!list.isEmpty()) {//子节点链表不为空for (Node child : node.children) {if(child!=null){//子节点不为空才加入队列que.offer(child);}}}

完整代码如下：

class Solution {public int maxDepth(Node root) {if (root == null) {return 0;}Queue<Node> que = new LinkedList<>();que.offer(root);int deep = 0;while (!que.isEmpty()) {int len = que.size();deep++;while (len-- > 0) {Node node = que.poll();List<Node> list = node.children;//代码健壮性if(!list.isEmpty()) {//子节点链表不为空for (Node child : node.children) {if(child!=null){//子节点不为空才加入队列que.offer(child);}}}}}return deep;}
}

111.二叉树的最小深度

①递归法

后序遍历求高度

最小深度 = 根节点的最小高度
父节点的最小高度 = 左右节点的高度最小值 + 1

class Solution {public int minDepth(TreeNode root) {if (root == null) {return 0;}int leftDepth = minDepth(root.left); // 左int rightDepth = minDepth(root.right);// 右// 中// 当一个左子树为空，右不为空，这时并不是最低点if(root.left==null&&root.right!=null){return 1+rightDepth;}// 当一个右子树为空，左不为空，这时并不是最低点if(root.left!=null&&root.right==null){return 1+leftDepth;}return Math.min(leftDepth, rightDepth) + 1;}
}

前序遍历求高深度

class Solution {int minNum=Integer.MAX_VALUE;public int minDepth(TreeNode root) {if(root==null){return 0;}getDepth(root,0);return minNum;}public void getDepth(TreeNode node,int deep){// 函数递归终止条件if(node==null)return;deep++;//中，处理逻辑：判断是不是叶子结点if(node.left==null&&node.right==null){minNum=Math.min(minNum,deep);}getDepth(node.left,deep);// 左getDepth(node.right,deep);// 右}
}

②迭代法

层序遍历

class Solution {public int minDepth(TreeNode root) {Queue<TreeNode> que = new LinkedList<>();if (root == null) {return 0;}que.offer(root);int deep = 0;while (!que.isEmpty()) {int len = que.size();deep++;while (len-- > 0) {TreeNode tempNode = que.poll();//如果当前节点的左右孩子都为空，直接返回最小深度if (tempNode.left == null && tempNode.right == null) {return deep;}if (tempNode.left != null) que.offer(tempNode.left);if (tempNode.right != null) que.offer(tempNode.right);}}return deep;}
}

222.完全二叉树的节点个数

按照普通二叉树的规则

①递归法（后序遍历）

class Solution {public int countNodes(TreeNode root) {if (root == null) return 0;int leftNum = countNodes(root.left);//左int rightNum = countNodes(root.right);//右return leftNum + rightNum + 1;//中，左子树的数量+右子树的数量+本身节点}
}

②迭代法

层序遍历

import java.util.LinkedList;
import java.util.Queue;
class Solution {public int countNodes(TreeNode root) {Queue<TreeNode> que = new LinkedList<>();if (root == null) return 0;que.offer(root);int num=0;while(!que.isEmpty()){int len = que.size();while(len-->0){TreeNode node = que.poll();num++;if(node.left!=null)que.offer(node.left);if(node.right!=null)que.offer(node.right);}}return num;}
}

后序遍历(统一迭代）

注：用LinkedList作为栈使用是，只有Deque接口有push方法，Queue接口是单端队列，无法在队列头加入元素！

import java.util.Deque;
import java.util.LinkedList;
class Solution {public int countNodes(TreeNode root) {Deque<TreeNode> que = new LinkedList<>();int num = 0;if (root == null) return num;que.push(root);while (!que.isEmpty()) {TreeNode node = que.peek();if (node != null) {que.poll();que.push(node);//中que.push(null);if (node.right != null) {que.push(node.right);//右}if (node.left != null) {que.push(node.left);//左}}else {//处理节点元素que.poll();que.poll();//再次弹出元素num++;}}return num;}
}

这几种方法都相当于把每个节点都遍历了一遍，所以时间复杂度是O(n)。

针对完全二叉树的性质

判断满二叉树的方法：向左遍历的深度 = 向右遍历的深度，则该树为满二叉树。

递归法

（1）递归三部曲：

1. 确定递归参数和返回值：当前节点root是递归参数，节点数是返回值。
2. 确定终止条件：①如果当前节点root为null，则返回0，意味着此时没有节点。②当该节点所在树为满二叉树时，则根据2^k - 1计算该节点对应子树的所有节点数并返回；
3. 单层递归的逻辑（可以看出使用后序遍历）：如果不是满二叉树，继续遍历左节点和右节点，当前节点对应子树的所有节点数 = 左右子树所有节点之和 + 1。

（2）算数运算符（-）的优先级比位运算符（<<）的大，故return (2 << leftDepth) - 1;此处需加上（）。

class Solution {public int countNodes(TreeNode root) {//确定递归参数和返回值//确定终止条件if (root == null) return 0;int leftDepth = 0;int rightDepth = 0; // 这里初始为0是有目的的，为了下面求指数方便TreeNode left = root.left;TreeNode right = root.right;while (left != null) {// 求左子树深度leftDepth++;left = left.left;}while (right != null) { // 求右子树深度rightDepth++;right = right.right;}if (leftDepth == rightDepth) {return (2 << leftDepth) - 1;// 注意(2<<1) 相当于2^2，所以leftDepth初始为0}//单层递归的逻辑（可以看出使用后序遍历）int leftCount = countNodes(root.left);int rightCount = countNodes(root.right);return leftCount + rightCount + 1;}
}