LeetCode104二叉树的最大深度

题目描述

  给定一个二叉树 root ，返回其最大深度。二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

解析

  DFS的同时记录当前节点的最大层数就行了，找最大的左右子树层级再加一即可。

public static int maxDepth(TreeNode root) {
        return DFS(root);
    }

    public static int DFS(TreeNode node){
        if (node == null) {
            return 0;
        }
        int leftDepth = DFS(node.left);
        int rightDepth = DFS(node.right);
        return Math.max(leftDepth, rightDepth) + 1;
    }

  同时也给出树的定义及构建输入，方便调试。

public class Tree {
    public static class TreeNode {
        public int val;
        public TreeNode left;
        public TreeNode right;
        public TreeNode() {}
        public TreeNode(int val) { this.val = val; }
        public TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }

        public void printPreOrder(){
            preOrder(this);
        }

        public void printInOrder(){
            inOrder(this);;
        }

        public void printPostOrder(){
            postOrder(this);
        }

    }

    public static void preOrder(TreeNode node) {
        if (node == null) {
            return;
        }
        System.out.print(node.val + " ");
        preOrder(node.left); 
        preOrder(node.right);
    }

    public static void inOrder(TreeNode node) {
        if (node == null) {
            return;
        }
        inOrder(node.left); 
        System.out.print(node.val + " ");
        inOrder(node.right); 
    }

    public static void postOrder(TreeNode node) {
        if (node == null) {
            return;
        }
        postOrder(node.left); 
        postOrder(node.right); 
        System.out.print(node.val + " "); 
    }

    public static TreeNode createInput(Integer[] nums) {
        if (nums.length == 0) {
            return null;
        }

        TreeNode[] nodes = new TreeNode[nums.length];
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] != null) {
                nodes[i] = new TreeNode(nums[i]);
            } else {
                nodes[i] = null;
            }
        }

        for (int i = 0; i < nums.length / 2; i++) {
            if (nodes[i] != null) {
                if (i * 2 + 1 < nums.length) {
                    nodes[i].left = nodes[i * 2 + 1];
                }
                if (i * 2 + 2 < nums.length) {
                    nodes[i].right = nodes[i * 2 + 2];
                }
            }
        }

        return nodes[0];
    }
}