多种方法求二叉树的最大深度

方法一：

from  queue import deque
class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if root is None:
            return 0
        q = deque()
        q.append(root)
        height = 0
        counter = 0  # 用来计数每一层遍历过的结点数目
        layerLength = 1  # 计数每一层的宽度，第一层的宽度为1
        while q:
            temp = q.popleft()
            counter += 1
            if temp.left is not None:
                q.append(temp.left)
            if temp.right is not None:
                q.append(temp.right)
            if counter == layerLength:
                layerLength = len(q)
                height += 1
                counter = 0
        return height

结果：

方法二（递归实现）：

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if root == None:
            return 0
        else:
            return max(self.maxDepth(root.left),
             self.maxDepth(root.right)) + 1

方法三：

class Solution:
    # dfs
    def maxDepth(self, root: TreeNode) -> int:
        stack = []
        maxd = 0
        d = 0
        while root or stack:
        	# 一直到最左边
            while root:
                d += 1
                # 将部分层的左边结点和层序数组成的元组存入stack
                stack.append((d, root))
                root = root.left
            d, root = stack.pop()
            if d > maxd:
                maxd = d
            root = root.right
        return maxd

这种方法有部分结点的遍历次数不止一次，而且内存花销大
方法四：

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if root == None:
            return 0
        queue = [root]
        depth = 1
        while(1):
            next_queue = []
            for node in queue:
                if(node.left):
                    next_queue.append(node.left)
                if(node.right):
                    next_queue.append(node.right)
            if (next_queue):
                depth += 1
                queue = next_queue
            else:
                return depth

这种方法类似第一种方法，都是在层序遍历的基础上变化
方法五：

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        depth = 0
        if root == None:
            return depth
        if root.left == None and root.right == None:
            return 1
        
        nodes = [root]
        while len(nodes) > 0:
            depth = depth + 1

            temp_nodes = []
            for node in nodes:
                if node.right != None:
                    temp_nodes.append(node.right)
                if node.left != None:
                    temp_nodes.append(node.left)
                
            nodes = temp_nodes

        return depth

和上一种方法类似，在层序遍历的基础上做变化。