LeetCode104 | 二叉樹的最大深度

讀前福利：幾百本互聯網技術書籍送給你們

天天分享一個LeetCode題目

天天 5 分鐘，一塊兒進步

LeetCode104 二叉樹的最大深度，地址: leetcode-cn.com/problems/ma…

樹結點定義

class TreeNode(object):
    def __init__(self, val, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
複製代碼

遞歸方式

遞歸方式比較簡單，就是一個後續遍歷，而後在遍歷到根結點的時候進行左右比較，選擇大的孩子

def maxDepth_dfs(self, root):
    if not root:
        return 0
    else:
        max_left = self.maxDepth_dfs(root.left)
        max_right = self.maxDepth_dfs(root.right)
        return max(max_left, max_right) + 1
複製代碼

看，是否是一個很簡單的後續遍歷，就是最後選擇大的分支

可是非遞歸的方式對於不少從上到下的遍歷也很適用，並且簡單

非遞歸方式

和

【此處是層次遍歷的連接】

的思路一致，就是一個層序遍歷的過程

初始化一個 node_depth = 0，而後遍歷到每一層的時候進行 node_depth + 1，最後返回 node_depth

看代碼

def maxDepth_bfs(self, root):
    if not root:
        return 0
    queue = collections.deque()
    # 初始化深度爲 0
    node_depth = 0
    # 初始化隊列中的結點元素 root
    queue.appendleft(root)
    while queue:
        # 每一層的遍歷，深度 +1
        node_depth += 1
        # 記錄每一層的結點集合
        tmp_queue = []
        for node in queue:
            if node.left:
                tmp_queue.append(node.left)
            if node.right:
                tmp_queue.append(node.right)
        queue = tmp_queue

    return node_depth
複製代碼

尤爲是不少地方都會使用像這種 BFS 的方式進行遍歷訪問，並且主要適用於一些從頂向下的題目

所有代碼

# -*- coding:utf-8 -*-
# !/usr/bin/env python

import collections

# 樹結點類
class TreeNode(object):
    def __init__(self, val, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right


class Solution(object):
    def maxDepth_dfs(self, root):
        if not root:
            return 0
        else:
            max_left = self.maxDepth_dfs(root.left)
            max_right = self.maxDepth_dfs(root.right)
            return max(max_left, max_right) + 1

    def maxDepth_bfs(self, root):
        if not root:
            return 0
        queue = collections.deque()
        # 初始化深度爲 0
        node_depth = 0
        # 初始化隊列中的結點元素 root
        queue.appendleft(root)
        while queue:
            # 每一層的遍歷，深度 +1
            node_depth += 1
            # 記錄每一層的結點集合
            tmp_queue = []
            for node in queue:
                if node.left:
                    tmp_queue.append(node.left)
                if node.right:
                    tmp_queue.append(node.right)
            queue = tmp_queue

        return node_depth


if __name__ == "__main__":
    # 新建節點
    root = TreeNode('A')
    node_B = TreeNode('B')
    node_C = TreeNode('C')
    node_D = TreeNode('D')
    node_E = TreeNode('E')
    node_F = TreeNode('F')
    node_G = TreeNode('G')
    node_H = TreeNode('H')
    node_I = TreeNode('I')
    node_J = TreeNode('J')
    # 構建二叉樹
    # A
    # / \
    # B C
    # / \ / \
    # D E F G
    # / \
    # H I
    # \
    # J
    root.left, root.right = node_B, node_C
    node_B.left, node_B.right = node_D, node_E
    node_C.left, node_C.right = node_F, node_G
    node_D.left, node_D.right = node_H, node_I
    node_I.right = node_J

    s = Solution()
    print(s.maxDepth_dfs(root))
    print(s.maxDepth_bfs(root))
複製代碼

Github

github.com/xiaozhutec/…