6.4 数据结构---树的深度

一、最大深度

1.二叉树的最大深度 leetcode104

给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
示例：
给定二叉树 [3,9,20,null,null,15,7]，
    3
   / 
  9  20
    /  
   15   7
返回它的最大深度 3

　　

思路1：深度优先搜索（递归）

终止条件：如果二叉树为空,则深度为0；

递归体：如果不为空,分别求左子树的深度和右子树的深度,取最大的再加1

def maxDepth(root):
    """
    :type root: TreeNode
    :rtype: int
    """
    if root == None:
        return 0
    leftDepth = maxDepth(root.left) + 1
    rightDepth = maxDepth(root.right) + 1
    return leftDepth if leftDepth > rightDepth else rightDepth

　　

思路2：把树看做是图，用dfs求最长长度的路径

from collections import defaultdict
def maxDepth2(nodes):
    #输入:nodes [3,9,20,null,null,15,7]

    #由节点列表构造图的邻接表
    def define_graph(arr):
        neig_dict = defaultdict(list)
        for i in range(len(arr)):
            if arr[i] != None:
                if (2*i+1) <= len(arr)-1 and arr[2*i+1]:#如果左节点存在
                    neig_dict[arr[i]].append(arr[2*i+1])
                if (2*i+2) <= len(arr)-1 and arr[2*i+2]:#如果右节点存在
                    neig_dict[arr[i]].append(arr[2*i+2])
                if (i-1)//2 >= 0 and arr[(i-1)//2]:#左子树的父节点
                    neig_dict[arr[i]].append(arr[(i-1)//2])
                elif (i-2)//2 >= 0 and arr[(i-2)//2]:#右子树的父节点
                    neig_dict[arr[i]].append(arr[(i-2)//2])
        return neig_dict

    #遍历邻接表,返回一次遍历的长度
    def dfs(nei_dict,i,visit):
        for j in nei_dict[i]:
            if j not in visit:
                visit.add(j)
                dfs(neig_dict,j,visit)
        return len(visit)

    neig_dict = define_graph(nodes)
    init_node = nodes[0]#图的起始点
    visit = set()
    visit.add(init_node)
    max_len = 0
    for i in neig_dict[init_node]:#遍历初始点的所有邻接点
        visit.add(i)
        max_len = max(dfs(neig_dict,i,visit),max_len)
        print('visit',visit)
        visit = set()#每遍历完一条路径之后,都要重新定义visit
        visit.add(init_node)
    return max_len

# res = maxDepth2([3,9,20,None,None,15,7])
# print("最大深度",res)

　　

思路3：层次遍历，计算有多少层，即为树的深度

def maxDepth_leverOrder(arr,arr_level):
    def levelOrder(arr,i,arr_lever):#i是当前节点是index
        #先序遍历树的每一个节点,当前节点的层数等于上一层加一
        if (i-1)//2 >= 0 and arr[(i-1)//2]:#左节点存在
            arr_lever[i] = arr_lever[(i-1)//2] + 1#等于父节点层数加一
        elif (i-1)//2 >= 0 and arr[(i-1)//2]:#右节点存在
            arr_lever[i] = arr_lever[(i-1)//2] + 1

    for i in range(1,len(arr)):#遍历除了根节点的其他节点
        if arr[i] == None:
            continue
        else:
            levelOrder(arr,i,arr_level)

    arr = [3,9,20,None,None,15,7]
    if len (arr) == 1:
        print(1)
    else:
        arr_level = defaultdict(int)
        arr_level[0] = 1  # 根节点为第一层

        print ('arr_level before',arr_level)
        maxDepth_leverOrder(arr,arr_level)
        print('arr_level after',arr_level)
        print('深度',max(arr_level.items(),key=lambda x:x[1]))#5,3==> 树在列表中的index值,对应的深度

def level_Order_init(root):
    # 层次遍历的递归写法
    def maxDepth_leverOrder_recur(level, result, node):
        if node:
            print('level=%s,result长度=%s'%(level,len(result)))
            #level<len(result)，说明有下一层,但是还没放数据
            #level=len(result)，说明有下一层且该层数据已经遍历完
            if level == len(result):
                #说明该层数据已经遍历完成,下一步要遍历下一层的数据
                result.append([])
            result[level].append(node.val)#该层
            maxDepth_leverOrder_recur(level+1,result,node.left)#左,下一层
            maxDepth_leverOrder_recur(level+1,result,node.right)#右,下一层

    level,result = 0,[]
    maxDepth_leverOrder_recur(level,result,root)
    print('深度',len(result))
    return result

L1 = TreeNode(3)
L2 = TreeNode(9)
L3 = TreeNode(20)
L4 = TreeNode(15)
L5 = TreeNode(7)

L1.left = L2
L1.right = L3
L2.left = None
L2.right = None
L3.left = L4
L3.right = L5
res = level_Order_init(L1)
print(res)

　　

2.N叉树的最大深度 leetcode559

题目：给定一个N叉树，找到其最大深度。最大深度是指从根节点到最远叶子节点的最长路径上的节点总数

思路：二叉树求最大深度一样，只是由固定的左右子节点变成了一堆子节点，方法没变

• 递归，如果node为空，直接返回
• 遍历node的所有孩子节点，取最大值+1作为最大深度

class TreeNode:
    def __init__(self, val, children):
        self.val = val
        self.children = children

def maxDepth(node):
    if node == None:
        return 0
    if not node.children:
        return 1

    #计算所有孩子节点的深度最大值
    # print('node.children',node.children)
    if len(node.children) >= 1:
        this_child_maxdpth = []
        for child in node.children:
            this_child_maxdpth.append(maxDepth(child)+1)
        return max(this_child_maxdpth)

L5 = TreeNode(5,None)
L6 = TreeNode(6,None)
L3 = TreeNode(2,None)
L4 = TreeNode(5,None)
L2 = TreeNode(3,children=(L5,L6))
L1 = TreeNode(1,children=(L2,L3,L4))
res = maxDepth(L1)
print(res)

　　

二、最小深度

1.二叉树的最小深度 leetcode111

题目：给定一个二叉树，找出其最小深度。二叉树的最小深度为根节点到最近叶子节点的距离。

思路1：计算左子树和右子树深度的时候，判断是否等于0，如果等于0，说明该子树不存在，深度赋值为最大值。

思路2：判断左子树或右子树是否为空,若左子树为空,则返回右子树的深度，反之返回左子树的深度，如果都不为空，则返回左子树和右子

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

def minDepth(root):
    """
    :type root: TreeNode
    :rtype: int
    """
    if root == None:
        return 0
    # 若左子树为空，则返回右子树的深度，反之返回左子树的深度
    if root.left == None :
        return minDepth(root.right) + 1
    if root.right == None:
        return minDepth(root.left) + 1
    #如果都不为空，则返回左子树和右子树深度的最小值
    leftDepth = minDepth(root.left) + 1
    rightDepth = minDepth(root.right) + 1
    return leftDepth if leftDepth < rightDepth else rightDepth

L1 = TreeNode(3)
L2 = TreeNode(9)
L3 = TreeNode(20)
L4 = TreeNode(15)
L5 = TreeNode(7)

L1.left = L2
L1.right = L3
L2.left = None
L2.right = None
L3.left = L4
L3.right = L5
res = minDepth(L1)
print(res)