代码随想录第十六天|（LeetCode）104.二叉树的最大深度（LeetCode） 111.二叉树的最小深度（LeetCode）222.完全二叉树的节点个数

最新推荐文章于 2024-10-05 12:29:44 发布

要动手啊

最新推荐文章于 2024-10-05 12:29:44 发布

阅读量51

点赞数

文章标签： leetcode 算法 java

本文链接：https://blog.csdn.net/m0_64566993/article/details/132224434

版权

104.二叉树的最大深度

111.二叉树的最小深度

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

104.二叉树的最大深度

题目链接：104. 二叉树的最大深度 - 力扣（LeetCode）

代码随想录题目解析：代码随想录 (programmercarl.com)

具体代码实现：


import java.util.Deque;
import java.util.LinkedList;
import java.util.Scanner;

//给定一个二叉树 root ，返回其最大深度。二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。
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;
	}
}

//迭代法，使用层序遍历，从上到下(好理解)
class Solution1 {
	public int maxDepth(TreeNode root) {
	    if(root == null) {
	        return 0;
	    }
	    Deque<TreeNode> deque = new LinkedList<TreeNode>();
	    deque.offer(root);
	    int depth = 0;
	    while (!deque.isEmpty()) {
	        int size = deque.size();
	        depth++;                                  //每次到达新的一层就+1
	        for (int i = 0; i < size; i++) {
	            TreeNode node = deque.poll();
	            if (node.left != null) {
	                deque.offer(node.left);
	            }
	            if (node.right != null) {
	                deque.offer(node.right);
	            }
	        }
	    }
	    return depth;
	}
}

//递归法(求深度法)，前序遍历，从上到下
class Solution2 {
	//定义最大深度
	int maxnum = 0;

	public int maxDepth(TreeNode root) {
		ans(root,0);
		return maxnum;
	}
	    
	//递归求解最大深度
	void ans(TreeNode tr,int tmp){
		if(tr==null) return;
		tmp++;
		maxnum = maxnum < tmp ? tmp : maxnum; //取 maxnum和 tmp之间的最大值
		ans(tr.left,tmp);
		ans(tr.right,tmp);
		tmp--;
	}
}

//递归法(求高度法)，后序遍历，从下到上
class Solution3 {
    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;
    }
}

public class Solution_text {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入二叉树的节点值（按层序遍历顺序输入，空节点用-1表示）：");
        String[] values = scanner.nextLine().trim().split(" ");
        int index = 0;
        TreeNode root = buildTree(values, index);

        System.out.println("使用层序遍历最大深度的结果：");
        Solution1 pre1 = new Solution1();
        System.out.println(pre1.maxDepth(root));

        System.out.println("使用前序遍历最大深度的结果：");
        Solution2 pre2 = new Solution2();
        System.out.println(pre2.maxDepth(root));

        

        System.out.println("使用后序遍历最大深度的结果：");
        Solution3 pre3 = new Solution3();
        System.out.println(pre3.maxDepth(root));

        scanner.close();

    }

    private static TreeNode buildTree(String[] values, int index) {
        if (index >= values.length || values[index].equals("-1")) {
            return null;
        }

        int val = Integer.parseInt(values[index]);
        TreeNode node = new TreeNode(val , buildTree(values, 2 * index + 1) , buildTree(values, 2 * index + 2));

        return node;
    }

}

111.二叉树的最小深度

题目链接：111. 二叉树的最小深度 - 力扣（LeetCode）

代码随想录题目解析：代码随想录 (programmercarl.com)

具体代码实现：

import java.util.Deque;
import java.util.LinkedList;
import java.util.Scanner;

//给定一个二叉树，找出其最小深度。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

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;
	}
}
//迭代法，使用层序遍历，从上到下(好理解)
class Solution1 {
    public int minDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        Deque<TreeNode> deque = new LinkedList<TreeNode>();
        deque.offer(root);
        int depth = 0;
        while (!deque.isEmpty()) {
            int size = deque.size();
            depth++;
            for (int i = 0; i < size; i++) {
                TreeNode poll = deque.poll();
                if (poll.left == null && poll.right == null) {
                    // 是叶子结点，直接返回depth，因为从上往下遍历，所以该值就是最小值
                    return depth;
                }
                if (poll.left != null) {
                    deque.offer(poll.left);
                }
                if (poll.right != null) {
                    deque.offer(poll.right);
                }
            }
        }
        return depth;
    }
}

//递归法(求高度法)，后序遍历，从下到上
class Solution2 {
    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;
        }
        //左右结点都不为null或都不为null
        int result = 1 + Math.min(leftDepth, rightDepth);
        return result;
    }
}

public class Solution_text {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入二叉树的节点值（按层序遍历顺序输入，空节点用-1表示）：");
        String[] values = scanner.nextLine().trim().split(" ");
        int index = 0;
        TreeNode root = buildTree(values, index);

        System.out.println("使用层序遍历最小深度的结果：");
        Solution1 pre1 = new Solution1();
        System.out.println(pre1.minDepth(root));

        System.out.println("使用后序遍历最小深度的结果：");
        Solution2 pre2 = new Solution2();
        System.out.println(pre2.minDepth(root));

        scanner.close();

    }

    private static TreeNode buildTree(String[] values, int index) {
        if (index >= values.length || values[index].equals("-1")) {
            return null;
        }

        int val = Integer.parseInt(values[index]);
        TreeNode node = new TreeNode(val , buildTree(values, 2 * index + 1) , buildTree(values, 2 * index + 2));

        return node;
    }

}

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

题目链接：222. 完全二叉树的节点个数 - 力扣（LeetCode）

代码随想录题目解析：代码随想录 (programmercarl.com)

具体代码实现

import java.util.Scanner;


//给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。

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;
	}
}

class Solution1 {
    // 通用递归解法
    public int countNodes(TreeNode root) {
        if(root == null) {
            return 0;
        }
        return countNodes(root.left) + countNodes(root.right) + 1;
    }
}

class Solution2 {
    /**
     * 针对完全二叉树的解法
     *
     * 满二叉树的结点数为：2^depth - 1
     */
    public int countNodes(TreeNode root) {
        if (root == null) return 0;
        TreeNode left = root.left;
        TreeNode right = root.right;
        int leftDepth = 0, rightDepth = 0; // 这里初始为0是有目的的，为了下面求指数方便
        while (left != null) {  // 求左子树深度
            left = left.left;
            leftDepth++;
        }
        while (right != null) { // 求右子树深度
            right = right.right;
            rightDepth++;
        }
        if (leftDepth == rightDepth) {
            return (2 << leftDepth) - 1; // 注意(2<<1) 相当于2^2，所以leftDepth初始为0
        }
        return countNodes(root.left) + countNodes(root.right) + 1;
    }
}

public class Solution_text {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个完全二叉树的节点值（按层序遍历顺序输入，空节点用-1表示）：");
        String[] values = scanner.nextLine().trim().split(" ");
        int index = 0;
        TreeNode root = buildTree(values, index);

        System.out.println("完全二叉树的节点个数：");
        Solution1 pre1 = new Solution1();
        System.out.println(pre1.countNodes(root));

        System.out.println("完全二叉树的节点个数：");
        Solution2 pre2 = new Solution2();
        System.out.println(pre2.countNodes(root));

        scanner.close();

    }

    private static TreeNode buildTree(String[] values, int index) {
        if (index >= values.length || values[index].equals("-1")) {
            return null;
        }

        int val = Integer.parseInt(values[index]);
        TreeNode node = new TreeNode(val , buildTree(values, 2 * index + 1) , buildTree(values, 2 * index + 2));

        return node;
    }

}