二叉树的最小深度

题目

题解

深度优先

递归算法：

class Solution {

    public int minDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        if (root.right == null && root.left == null) {
            return 1;
        }
        if (root.right != null && root.left != null) {
            return Math.min(minDepth(root.right), minDepth(root.left));
        }
        if (root.right == null) {
            return minDepth(root.left) + 1;
        }
        return minDepth(root.right) + 1;
    }
}

广度优先

指针轮换:

一层一队列

class Solution {
    public int minDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        Queue<TreeNode> queue1 = new LinkedList<>();
        Queue<TreeNode> queue2 = new LinkedList<>();
        Queue<TreeNode> temp;
        queue1.add(root);
        int depth = 1;
        while (!queue1.isEmpty()) {
            TreeNode node = queue1.poll();

            if (node.right != null) {
                queue2.add(node.right);
            }
            if (node.left != null) {
                queue2.add(node.left);
            }
            if (node.left == null && node.right == null) {
                break;
            }
            if (queue1.isEmpty() && !queue2.isEmpty()) {
                depth++;
                temp = queue1;
                queue1 = queue2;
                queue2 = temp;
            }
        }
        return depth;
        }
}

内部类包装：

class Solution {
    class QueueNode {
        TreeNode node;
        int depth;

        public QueueNode(TreeNode node, int depth) {
            this.node = node;
            this.depth = depth;
        }
    }

    public int minDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }

        Queue<QueueNode> queue = new LinkedList<QueueNode>();
        queue.offer(new QueueNode(root, 1));
        while (!queue.isEmpty()) {
            QueueNode nodeDepth = queue.poll();
            TreeNode node = nodeDepth.node;
            int depth = nodeDepth.depth;
            if (node.left == null && node.right == null) {
                return depth;
            }
            if (node.left != null) {
                queue.offer(new QueueNode(node.left, depth + 1));
            }
            if (node.right != null) {
                queue.offer(new QueueNode(node.right, depth + 1));
            }
        }

        return 0;
    }
}

层循环：

class Solution {
    public int minDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        int depth = 1;
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                if (node.right != null) {
                    queue.add(node.right);
                }
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.left == null && node.right == null) {
                    return depth;
                }
            }
            depth++;
        }
        return depth;
    }
}