LeetCode—二叉树最短路径

题目：

leetcode-Minimum Depth of Binary Tree

Given a binary tree, find its minimum depth.The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.

输入一个二叉树，求根节点到叶子节点的最短路径的节点个数。

思路

1、递归解法，分别求左右子树深度，左右子树深度的较小值加1即为最终深度。需要注意左节点/右节点为空时，需要返回根节点到右节点/左节点的深度。
2、非递归解法，从根节点开始按层遍历，叠加level直到叶子节点。

Java 实现

/**
*先定义树节点
*/ 
public class TreeNode {
    private int value;

    private TreeNode left;

    private TreeNode right;

    public TreeNode(int value) {
        this.value = value;
    }

    public TreeNode getLeft() {
        return left;
    }

    public void setLeft(TreeNode left) {
        this.left = left;
    }

    public TreeNode getRight() {
        return right;
    }

    public void setRight(TreeNode right) {
        this.right = right;
    }
}


/**
*算法实现类
*/
public class MinDepthOfTree {
    /**
     * 递归法
     * @return
     */
    public static int getDepthRecursion(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int left = getDepthRecursion(root.getLeft());
        int right = getDepthRecursion(root.getRight());

        //需要注意左节点/右节点为空时，需要返回根节点到右节点/左节点的深度
        if (left == 0 || right == 0) {
            return 1 + left + right;
        }
        return left < right ? left + 1 : right + 1;
    }

    /**
     * 思路：
     * 非递归
     * 1、从根节点开始按层遍历二叉树.
     * 2、遍历到该层时，判断当前节点是否为叶子节点，是叶子节点则找到了最小深度并返回，否则添加子节点到队列中.
     * @return
     */
    public static int getDepthNoRecursive(TreeNode root) {
        if (root == null) {
            return 0;
        }
        Queue<TreeNode> nodeQueue = new LinkedList<TreeNode>();
        nodeQueue.offer(root);
        int level = 0;

        while (!nodeQueue.isEmpty()) {
            level ++ ;
            int size = nodeQueue.size();
            for (int i = 0; i< size; i++) {
                TreeNode node = nodeQueue.poll();
                if (node.getLeft() == null && node.getRight() == null) {
                    return level;
                }
                if (node.getLeft() != null) {
                    nodeQueue.offer(node.getLeft());
                }
                if (node.getRight() != null) {
                    nodeQueue.offer(node.getRight());
                }
            }
        }
        return level;
    }
}