从混乱到有序：我用“逐层扫描”法优雅搞定公司组织架构图（515. 在每个树行中找最大值）

从混乱到有序：我用"逐层扫描"法优雅搞定公司组织架构图 😎

嘿，各位代码爱好者们！今天想跟大家聊一个我在实际项目中遇到的"小"难题，以及我是如何用一个经典的算法思想，把它变成了一个展示技术实力的"闪光点"✨。相信我，这趟旅程绝对干货满满！

我遇到了什么问题？

最近，我接手了一个内部OA（办公自动化）系统的升级任务。其中一个核心需求是：开发一个动态、可交互的公司组织架构图。

想象一下，一家大公司，成千上万的员工，层层汇报关系就像一棵巨大的树。CEO是树根，往下是各个副总裁、总监、经理、员工...

这个功能上线后，CEO提了一个新需求："我希望一目了然地看到每一个职级里，工龄最长的员工是谁，这样我们开表彰大会的时候能快速找到各级别的'老黄牛'。"

这个需求翻译成技术语言就是：给定一个代表公司层级关系的二叉树，找出每一层的最大值（这里我们用"工龄"作为节点的值）。这不就和 LeetCode 515. 在每个树行中找最大值这道题撞上了吗？

一开始，我的大脑一片混乱。这么多员工，这么多层级，难道要写一堆复杂的if-else来判断员工在哪一层？感觉要"码"上起飞，也"码"上崩溃了。😵

我是如何用"广度优先搜索"解决的

首次尝试与"踩坑"经历 🧗

我最初的想法是，用递归（也就是深度优先搜索，我们待会也会讲）来做。我写了个函数，一路"深挖"到最底层的员工，再一层层返回。但很快我就发现，代码逻辑变得异常绕。我需要传来传去好几个参数，比如当前深度、一个巨大的Map来存每一层的最大值...代码可读性极差，感觉自己给自己挖了个大坑。

"恍然大悟"的瞬间 ✨

就在我对着屏幕抓耳挠腮时，我突然想，CEO的需求不是"深入"挖掘，而是"横向"比较啊！他关心的是同一层的员工。

"一层一层地看..." 这句话像闪电一样击中了我！这不就是**广度优先搜索（BFS）**的核心思想吗？就像我们在现实生活中，把一栋楼的每一层都走遍，再上到下一层一样。

这个想法让我豁然开朗！我只需要一个工具，能帮我保存好"当前层的所有办公室（节点）"，处理完这一层后，再把他们下属的办公室（子节点）放进去，准备处理下一层。这个完美的工具就是------队列（Queue）。

"逐层扫描"法实战 (BFS)

这个方法的核心就是模拟我们一层一层检查的过程。

思路:

准备一个队列，先把CEO（根节点）请进去。
只要队列里还有人，就说明还有职级层需要检查。
在每一轮循环里，我们只处理当前这一层 的所有人。怎么做到呢？关键一步：在开始处理前，记下当前队列里的人数levelSize。
然后，我们进行levelSize次操作：把一个人请出队列，拿他的工龄和我们记录的"本层最长工龄"levelMax比较一下，更新最大值。同时，把他的直属下级（左、右子节点）都请入队列的末尾，让他们等待下一轮的检阅。
当这levelSize个人都处理完，我们就找到了这一层的"老黄牛"，把他记录下来。然后继续下一轮循环。

代码实现:

java 复制代码

/* 思路：广度优先搜索(BFS)，也叫层序遍历 */
public List<Integer> largestValues(TreeNode root) {
    if (root == null) return new ArrayList<>();

    List<Integer> result = new ArrayList<>();
    // 为何用 Queue? 因为它的"先进先出"(FIFO)特性完美契合了层序遍历的需求。
    // 我们把第 N 层的节点放进去，处理完后，队列里剩下的正好是第 N+1 层的所有节点。
    // LinkedList 是 Queue 接口的一个常见实现，提供了高效的 offer (入队) 和 poll (出队) 操作。
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);

    while (!queue.isEmpty()) {
        // ✨ 这是BFS分层的核心技巧！✨
        // 在开始处理新层之前，锁定当前层的节点数量。
        int levelSize = queue.size(); 
        int levelMax = Integer.MIN_VALUE; // 用整型最小值初始化，确保任何工龄都能比它大

        for (int i = 0; i < levelSize; i++) {
            TreeNode currentNode = queue.poll();
            levelMax = Math.max(levelMax, currentNode.val);

            if (currentNode.left != null) queue.offer(currentNode.left);
            if (currentNode.right != null) queue.offer(currentNode.right);
        }
        result.add(levelMax); // 将这一层的最长工龄记录下来
    }
    return result;
}

换个角度："深度优先搜索"也能行？

当然！虽然BFS更直观，但DFS（深度优先搜索）也能解决问题，而且在某些情况下空间效率更高。我们可以把它想象成"一条路走到黑"的考察方式。

思路: 想象一下，你是一个审计员，你不会一层楼一层楼地跑，而是跟着一个副总裁的汇报线，一直查到最底层的员工，然后再回溯到副总裁，去查他的另一条汇报线。

为了知道每个员工在哪一层，我们需要在递归时传递一个depth（深度）参数。

准备一个result列表，用来存放每层的最大值。
定义一个递归函数 dfs(node, depth)。
核心技巧 ：我们怎么知道result里该更新哪个位置呢？我们利用result.size()！
- 如果depth == result.size()，说明我们是第一次 到达这个深度，比如depth=2时，result里只有第0层和第1层的结果（size=2）。这时，我们直接把当前员工的工龄add到result列表里。
- 如果depth < result.size()，说明这一层我们已经来过了，result里已经有了这一层的最大工龄记录。我们只需要把它取出来，和当前员工的工龄比较，然后用set方法更新就行了。

代码实现:

java 复制代码

/* 思路：深度优先搜索(DFS) + 记录深度 */
public List<Integer> largestValues_dfs(TreeNode root) {
    if (root == null) return new ArrayList<>();
    // 为何用 ArrayList? 因为DFS需要根据 depth 频繁地、随机地访问和更新列表中的元素。
    // ArrayList 基于数组实现，通过索引 get 和 set 都是O(1)操作，效率极高。
    // 如果用 LinkedList，get(depth)会是O(depth)操作，性能会差很多。
    List<Integer> result = new ArrayList<>();
    dfs(root, 0, result);
    return result;
}

private void dfs(TreeNode node, int depth, List<Integer> result) {
    if (node == null) return;

    if (depth == result.size()) {
        // 第一次踏足这一层，直接记录当前员工的工龄
        result.add(node.val);
    } else {
        // 这一层已经有记录了，PK一下，看谁的工龄更长
        result.set(depth, Math.max(result.get(depth), node.val));
    }

    // 继续深入考察左边和右边的下属
    dfs(node.left, depth + 1, result);
    dfs(node.right, depth + 1, result);
}

解读一下题目的"提示"

二叉树的节点个数的范围是 [0,10^4]：这个信息很重要！它告诉我，公司规模最多一万人。对于现代计算机来说，无论是BFS还是DFS，O(N)的时间复杂度（N=10000）都是小菜一碟，秒出结果。这让我可以放心地选择任何一种方案。
-2^31 <= Node.val <= 2^31 - 1：这告诉我员工的"工龄"值在Java的int范围内。所以，我用Integer.MIN_VALUE作为初始比较值是绝对安全的，不会出现某个员工的工龄比它还小的情况。

举一反三：这种思想还能用在哪？

层序遍历的思想在开发中无处不在，绝对是面试和工作中的高频技能点！

社交网络：计算你在微信/Facebook中，"好友的好友"（二度人脉）、"好友的好友的好友"（三度人脉）等各层关系中的"人脉王"（好友最多的人）。
游戏技能树：在《英雄联盟》或《魔兽世界》这类游戏中，玩家需要点技能。我们可以用层序遍历找到每一层（Tier）技能中，伤害最高或效果最强的技能，推荐给玩家。
文件系统：查找一个文件夹下，每一层子目录中最大的文件。
网络路由：在网络中，路由器寻找最短路径的算法（如Dijkstra）就用到了类似BFS的思想，逐层扩展来找到目标。

类似题目练手

想把这个技能点满？去力扣上刷刷这几道"兄弟题"吧，它们会让你对层序遍历的理解更上一层楼！

102. 二叉树的层序遍历：梦开始的地方，最基础的层序遍历。
199. 二叉树的右视图：一个非常有趣的变种，每层只看最右边的节点。
103. 二叉树的锯齿形层序遍历：给遍历增加了一点"摇摆"的难度。
637. 二叉树的层平均值：和我们今天这题很像，只是从求最大值变成了求平均值。

希望这次的分享对你有帮助！记住，很多复杂的业务需求，背后往往对应着一个简洁优美的算法模型。下次再遇到类似问题，你也能像我一样，自信地说出："没问题，看我用'逐层扫描'法把它拿下！" 😉