数据结构与算法之二叉树: LeetCode 104. 二叉树的最大深度 (Ts, Py, Go版)

关注

原创 2024-11-07 19:40:56 689 阅读 AI 写同款· GEO 优化 ›

目标检测中回归损失函数（L1Loss,L2Loss,Smooth L1Loss,IOU,GIOU,DIOU,CIOU,EIOU,αIOU ,SIOU) 为了解决CIoU的问题，有学者在CIOU的基础上将纵横比拆开，提出了EIOU Loss，并且加入Focal聚焦优质的预测框，与CIoU相似的，EIoU是损失函数的解决方案，只用于训练。在错误率小的地方，梯度的值也应当小，反之在错误率大的地方，梯度也应当大，因为这时候我们需要对错误率小的情况进行微调，而错误率大的地方进行大刀阔斧的调整；如下图所示，三种情况IoU都相等，但看得出来他们的重合度是不一样的，左边的图回归的效果最好，右边的最差。DIoU的作者考虑到，在两个框中心点重合时，c与d的值都不变。阅读详情

二叉树的最大深度

https://leetcode.cn/problems/maximum-depth-of-binary-tree/

描述

给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。

示例

给定二叉树 [3,9,20,null,null,15,7]

返回它的最大深度 3

Typescript 算法实现

1 ）方案 1

/**
 * Definition for a binary tree node.
 * class TreeNode {
 *     val: number
 *     left: TreeNode | null
 *     right: TreeNode | null
 *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
 *         this.val = (val===undefined ? 0 : val)
 *         this.left = (left===undefined ? null : left)
 *         this.right = (right===undefined ? null : right)
 *     }
 * }
 */

function maxDepth(root: TreeNode | null): number {
    let dep = 0;
    // n是节点，l是层级
    const dfs = (n: TreeNode | null, l: number) => {
        if(!n) return;
        // console.log(n.val, l); // 访问当前节点
        (!n.left && !n.right) && (dep = Math.max(dep, l)); // 最大深度和较大层级的最大值, 当为叶子节点时，刷新最大深度
        dfs(n.left, l+1); // 访问左孩子节点
        dfs(n.right, l+1); // 访问右孩子节点
    }
    dfs(root, 1); // 执行
    return dep
};

思路
- 求树的最大深度，考虑使用深度优先遍历
- 它是按顺序访问每个节点，但是不能拿到最大深度
- 在深度优先遍历中，记录每个节点所在的层级，找出最大的层级即可
步骤
- 新建一个变量记录最大深度
- 深度优先遍历整棵树，并记录每个节点的层级，同时不断刷新最大深度这个变量
- 遍历结束返回最大深度这个变量

2 ）方案 2

/**
 * Definition for a binary tree node.
 * class TreeNode {
 *     val: number
 *     left: TreeNode | null
 *     right: TreeNode | null
 *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
 *         this.val = (val===undefined ? 0 : val)
 *         this.left = (left===undefined ? null : left)
 *         this.right = (right===undefined ? null : right)
 *     }
 * }
 */

function maxDepth(root: TreeNode | null): number {
    if (!root) return 0;
    return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
};

上述是官方示例，及其简洁
注意这个 1 表示当前节点，也是深度优先的递归实现

3 ）方案 3

/**
 * Definition for a binary tree node.
 * class TreeNode {
 *     val: number
 *     left: TreeNode | null
 *     right: TreeNode | null
 *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
 *         this.val = (val===undefined ? 0 : val)
 *         this.left = (left===undefined ? null : left)
 *         this.right = (right===undefined ? null : right)
 *     }
 * }
 */

function maxDepth(root: TreeNode | null): number {
    if (!root) return 0;
    let q = [root];
    let dep = 0
    while(q.length) {
        let len = q.length; // 当前队列长度
        while(len) {
            const n = q.shift(); // 拿到当前节点
            n.left && (q.push(n.left)) // 左节点进队
            n.right && (q.push(n.right)) // 右节点进队
            len --
        }
        dep ++
    }
    return dep;
}

这是官方的C++解题示例，我改造的TS版本
使用广度优先遍历实现
- 此时广度优先搜索的队列里存放的是「当前层的所有节点」
- 每次拓展下一层的时候，不同于广度优先搜索的每次只从队列里拿出一个节点
- 需要将队列里的所有节点都拿出来进行拓展，这样能保证每次拓展完的时候
- 队列里存放的是当前层的所有节点，即我们是一层一层地进行拓展
- 最后我们用一个变量 dep 来维护拓展的次数
- 该二叉树的最大深度即为 dep

Python3 版算法实现

1 ）方案1 递归版（DFS）

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        dep = 0

        def dfs(n: Optional[TreeNode], l: int):
            nonlocal dep
            if not n:
                return
            if not n.left and not n.right:
                dep = max(dep, l)
            dfs(n.left, l + 1)
            dfs(n.right, l + 1)

        dfs(root, 1)
        return dep

2 ）方案2 递归法（简化版）

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

class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        return 1 + max(self.maxDepth(root.left), self.maxDepth(root.right))

3 ）方案3 迭代法（BFS）

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

class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        q: Deque[TreeNode] = deque([root])
        dep = 0

        while q:
            len_q = len(q)
            for _ in range(len_q):
                n = q.popleft()
                if n.left:
                    q.append(n.left)
                if n.right:
                    q.append(n.right)
            dep += 1

        return dep

Golang 版算法实现

1 ）方案1 递归法（DFS）

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */

func maxDepth(root *TreeNode) int {
	var dep int
	dfs(root, 1, &dep)
	return dep
}

func dfs(n *TreeNode, l int, dep *int) {
	if n == nil {
		return
	}
	if n.Left == nil && n.Right == nil {
		*dep = max(*dep, l)
	}
	dfs(n.Left, l+1, dep)
	dfs(n.Right, l+1, dep)
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

2 ）方案2 递归版（简化版）

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */

func maxDepth(root *TreeNode) int {
	if root == nil {
		return 0
	}
	return 1 + max(maxDepth(root.Left), maxDepth(root.Right))
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

3 ）方案3 迭代版（BFS）

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */

func maxDepth(root *TreeNode) int {
	if root == nil {
		return 0
	}
	q := []*TreeNode{root}
	dep := 0

	for len(q) > 0 {
		len := len(q)
		for len > 0 {
			n := q[0]
			q = q[1:]
			if n.Left != nil {
				q = append(q, n.Left)
			}
			if n.Right != nil {
				q = append(q, n.Right)
			}
			len--
		}
		dep++
	}

	return dep
}