力扣题解-二叉树类| 二叉树求高度、深度、宽度、判断平衡性等系列问题(java实现)
1、求树的深度(最大深度)
树的深度是从根节点到最远叶子节点的最短路径上的节点数量
//(递归方式)获取以root为根节点的子树的深度:从叶子节点到达根节点的最长路径
public int getDept(TreeNode root, int dept){
if(root == null){
return dept;
}
int leftDept = getDept(root.left, dept+1);
int rightDept = getDept(root.right, dept+1);
return Math.max(leftDept, rightDept);
}
2、求树的最小深度
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
class Solution {
public int minDepth(TreeNode root) {
if(root == null) return 0;
if(root.left==null && root.right==null) return 1;
int min = Integer.MAX_VALUE;
if(root.left != null){
min = Math.min(minDepth(root.left), min);
}
if(root.right != null){
min = Math.min(minDepth(root.right), min);
}
return min+1;
}
}
//版本二
class Solution {
public int minDepth(TreeNode root) {
if(root == null) return 0;
int m1 = minDepth(root.left);
int m2 = minDepth(root.right);
//1.如果左孩子和右孩子有为空的情况时m1和m2必有一个为0，所以直接返回m1+m2+1
//2.如果都不为空，返回较小深度+1
return root.left == null || root.right == null ? m1 + m2 + 1 : Math.min(m1,m2) + 1;
}
}
3、求树的高度(最大高度)
树的高度是指从叶子节点到达根节点的最长路径
/**
* (递归方式)求树的高度:从叶子节点到达根节点的最长路径
* @param root
* @return
*/
public int getTreeHeight(TreeNode root) {
if (root == null) {
return 0;
}
int leftHeight = getTreeHeight(root.left);
int rightHeight = getTreeHeight(root.right);
return leftHeight > rightHeight? leftHeight+1 : rightHeight+1;
}
/**
* (非递归方式)求树的高度:从叶子节点到达根节点的最长路径
* @param root
* @return
*/
public int non_getTreeHeight(TreeNode root) {
if (root == null) {
return 0;
}
int height = 0, //记录树的高度
count = 0, //进行层级统计
nextCount = 1; //记录每层遍历后新增到队列中的元素数量
Queue<TreeNode> queue = new LinkedList<BinaryTree.TreeNode>();
queue.add(root);
while (!queue.isEmpty()) {
TreeNode node = queue.poll();
count++;
if (node.left!=null) {
queue.add(node.left);
}
if (node.right!=null) {
queue.add(node.right);
}
if (count == nextCount) {
//表示该层已经遍历完了
nextCount = queue.size(); //从新获取队列中保存的下一层节点个数
count = 0; //每层计算器清零
height++; //树的高度加1
}
}
return height;
}
4、求树的最小高度
public class Solution {
public int MinDepth(TreeNode root) {
if (root == null)
{
return 0;
}
int L = MinDepth(root.left);
int R = MinDepth(root.right);
return (L == 0 || R == 0) ? (L+R+1) : Math.Min(L,R) + 1;
}
}
5、根据数组构造最小高度树(平衡树)
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution{
public TreeNode sortedArrayToBST(int[] nums){
if(nums.length==0 || nums==null) return null;
TreeNode node = new TreeNode(nums[nums.length / 2]);
node.left = sortedArrayToBST(Arrays.copyOfRange(nums, 0, nums.length / 2));
ndoe.right = sortedArrayToBST(Arrays.copyOfRange((nums.length / 2)+1), nums.length);
return node;
}
}
- 高度和深度是相反的表示，深度是从上到下数的，而高度是从下往上数。
- 某节点的深度是指从根节点到该节点的最长简单路径边的条数，而高度是指从该节点到叶子节点的最长简单路径边的条数。
- 规定根节点的深度和叶子节点的高度是0；树的高度和深度是相等的。
6、检查二叉树是否平衡
class Solution{
public boolean isBanlance(TreeNode root){
if(root==null) return true;
int leftDept = getDept(root.left, 0);
int rightDept = getDept(root.right, 0);
if(Math.abs(leftDept - rightDept) > 1){
return false;
}
return isBanlance(root.left) && isBanlance(root.right);
}
public int getDept(TreeNode root, int dept){
if(root==null) return dept;
int leftDept = getDept(root.left, dept+1);
int rightDept = getDept(root.right, dept+1);
return Math.max(leftDept, rightDept);
}
}
7、求二叉树的最大宽度
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public int levelOrder(TreeNode root) {
if(root == null) return new LinkedList<List<Integer>>();
List<List<Integer>> res = new LinkedList<List<Integer>>();
Queue queue = new LinkedList<TreeNode>();
queue.offer(root);
int max = Integer.MIN_VALUE;
while(!queue.isEmpty()){
int size = queue.size();
max = Math.max(max, size );
for(int i=0;i<size;i++){
TreeNode node = (TreeNode)queue.poll();
if(node.left != null) queue.offer(node.left);
if(node.right != null) queue.offer(node.right);
}
}
return max ;
}
}
8、求二叉树的最小宽度
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public int levelOrder(TreeNode root) {
if(root == null) return new LinkedList<List<Integer>>();
List<List<Integer>> res = new LinkedList<List<Integer>>();
Queue queue = new LinkedList<TreeNode>();
queue.offer(root);
int min= Integer.MAX_VALUE;
while(!queue.isEmpty()){
int size = queue.size();
min= Math.min(min, size );
for(int i=0;i<size;i++){
TreeNode node = (TreeNode)queue.poll();
if(node.left != null) queue.offer(node.left);
if(node.right != null) queue.offer(node.right);
}
}
return min;
}
}