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.

Note: A leaf is a node with no children.

Example:

Given binary tree [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7
return its minimum depth = 2.

总结

这题最先想到的就是使用递归的方法，类似于获取树的深度（最大深度），时间复杂度是O（N）
我的代码：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def minDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:
            return 0
        elif not root.right and not root.left:
            return 1
        elif root.left and root.right:
            return min(self.minDepth(root.left), self.minDepth(root.right)) + 1
        elif not root.left and root.right:
            return self.minDepth(root.right) + 1
        else:
            return self.minDepth(root.left) + 1

提交后发现这种解法已经排到50%后面了，看了看前面的别人用的是非递归的方法，于是重新思考怎么使用非递归实现。
思考过程：
1. 使用非递归的方式比较节点的深度，来获得深度最小的点，但是这种方法仍然需要获取到所有节点的深度，时间复杂度理论上还是O（n），并不能有效加快程序速度。
2. 想到用层次遍历的方法，因为深度是逐层增加的，只要访问到第一个叶节点，此时的深度就是最小深度，而且可以肯定这种叶节点肯定存在，可以省去很多边界判断条件

改进后的代码：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def minDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:
            return 0
        queue = [root]
        mindepth = 1
        while True:
            size = len(queue)
            for i in range(size):
                node = queue.pop(0)
                if not node.left and not node.right:
                    return mindepth
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            mindepth += 1

改进后的代码成功beat了100%，嘿嘿
这种方法理论上时间复杂度还是O（n），但是实际情况应该是要小很多的！