广度优先之求每一层的平均值

最新推荐文章于 2025-11-29 17:10:21 发布
原创 最新推荐文章于 2025-11-29 17:10:21 发布 · 265 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#宽度优先 #算法

思路：这里运用递归只需要在每一次迭代时修改一下内容就可以

也就是每一次小递归中给当前深度加上cur->val

当递归结束后，每一层深度都代表这这层深度的和

然后在加数时，顺便给count数组也加一个数

最后循环就好了

说不清楚看代码吧

class Solution {

public:

    vector<int> count;

    void order(TreeNode* cur,vector<double>& result,int depth)

    {

        if(cur == nullptr)return;

        if(result.size() == depth)

        {

            result.push_back(cur->val);

            count.push_back(1);

        }

        else

        {

            result[depth] += cur->val;

            count[depth]++;

        }

        order(cur->left,result,depth + 1);

        order(cur->right,result,depth + 1);

    }

    vector<double> averageOfLevels(TreeNode* root)

    {

        vector<double>result;

        order(root,result,0);

        int j = 0;

        for(int i : count)

        {

            result[j] /= i;

            j++;

        }

        return result;

    }

};

JINbigXIA
关注
5.1广度优先遍历的递归与迭代实现；
chumingqian的博客
05-02 1635
队列先进先出的性质， 符合 广度优先遍历时， 一层一层的遍历逻辑； lc102 1. 迭代实现： 新建节点型 队列， 使用容器适配器queue； 如果根节点不为空， 将根节点入队； 新建二维向量容器 result， 用于层序的存放节点中元素； 条件循环， 当队列不为空： 记录当前 队列的大小为 len1; 新建一个 一维向量容器 res; 循环遍历， 当前队列; 当前节点 等于 取出队列的第一个元素，头节点的引用； 删除队列的第一个节点； 一维向量容器中， 添加当前节点中的数值； 当前节点的左子树.
【c++】广度优先搜索详解
2401_88851881的博客
11-13 2085
BFS 全称是 Breadth First Search，中文名是宽度优先搜索，也叫广度优先搜索。是图上最基础、最重要的搜索算法之一。所谓宽度优先。就是每次都尝试访问同一层的节点。如果同一层都访问完了，再访问下一层。这样做的结果是，BFS 算法找到的路径是从起点开始的合法路径。换言之，这条路径所包含的边数最小。在 BFS 结束时，每个节点都是通过从起点到该点的最短路径访问的。算法过程可以看做是图上火苗传播的过程：最开始只有起点着火了，在每一时刻，有火的节点都向它相邻的所有节点传播火苗。
leetcode637. 二叉树的层平均值，广度优先搜索BFS
热爱C++和golang的学生
08-31 1337
leetcode637. 二叉树的层平均值，广度优先搜索BFS
leetCode题解之求二叉树每层的平均值
weixin_30549657的博客
04-01 251
1、题目描述 Given a non-empty binary tree, return the average value of the nodes on each level in the form of an array. 计算二叉树每一层的节点的数据域的平均值。 2、题目分析 使用广度优先遍历方法，逐层对二叉树进行访问，求均值。使用一个队列数据结构完成对二叉树的访问，队列...
Leetcode 637. 二叉树的层平均值
weixin_44852067的博客
09-01 554
Leetcode 637. 二叉树的层平均值
Python每日一练：二叉树的层平均值（LeetCode）
weixin_72845410的博客
07-18 338
给定一个非空二叉树的根节点root, 以数组的形式返回每一层节点的平均值。与实际答案相差10-5以内的答案可以被接受。二叉树、队列、深度优先搜索和广度优先搜索
二叉树的层平均值（深度优选搜索 && 广度优先搜索）
weixin_48557384的博客
11-16 382
二叉树的层平均值（深度优选搜索 && 广度优先搜索） 含图示（java）
[二叉数]二叉树的层平均值
weixin_42415173的博客
04-14 742
637. 二叉树的层平均值、queue、linkedlist、队列、二叉数的层次遍历，广度优先遍历
637. 二叉树的层平均值
org_hjh的博客
09-12 525
637. 二叉树的层平均值 给定一个非空二叉树, 返回一个由每层节点平均值组成的数组。 示例 1： 输入： 3 / \ 9 20 / \ 15 7 输出：[3, 14.5, 11] 解释： 第 0 层的平均值是 3 , 第1层是 14.5 , 第2层是 11 。因此返回 [3, 14.5, 11] 。 提示： 节点值的范围在32位有符号整数范围内。 方法1：深度优先搜索 算法思路： 使用深度优先搜索计算二叉树的层平均值，需要维护两个数组，counts 用于存储二叉
解析：深度优先搜索、广度优先搜索和回溯搜索
m0_53605808的博客
04-18 1352
系统地构造解空间树，试探每一个可能的解分支，一旦发现某一路径不可能通向可行解（违反约束或已达死胡同），便“回溯”撤销最近那一步，尝试其他可能。：从起始节点出发，顺着一条路径不断深入，直到到达目标或无路可走，然后回溯到最近的分支点，继续探索其他分支。递归栈／显式栈最坏深度为 O(h)，h 为搜索深度（在图上为 O(|V|)），加上标记数组 O(|V|)。：组合优化（八皇后、子集和、图着色）、约束满足问题（CSP）、数独、排列生成等。队列在最宽层级可能存放 O(w) 个节点，w 最坏可至 O(|V|)。
Java实现 LeetCode 637 二叉树的层平均值（遍历树）
12-21
在LeetCode的第637题“二叉树的层平均值”中，目标是给定一棵非空二叉树，计算每一层节点的平均值，并将这些平均值放入一个数组返回。这个问题主要考察了对二叉树的层次遍历（Level Order Traversal）的理解与实现。...
二叉树的层平均值（queue层序遍历）1
08-03
接下来，我们创建一个名为 `Solution` 的类，其中有一个公共成员函数 `averageOfLevels`，该函数接受一个 `TreeNode` 指针 `root` 作为输入，返回一个包含每层平均值的双精度浮点数向量。 在 `averageOfLevels` ...
【多源01BFS】Codeforce：Three States
2301_80361697的博客
04-24 1332
表示荒地（可以修建道路）。：表示岩石（不可通行）。数字 1、2、3：分别表示三个国家的位置。目标：将最少数量的荒地（.）改造成道路，使得三个国家之间互相连通（即任意两国之间存在一条路径）。如果无法实现，输出 -1。数据范围：1 ≤ n, m ≤ 1000（即网格最大为 1000×1000）。
Gemini永久会员 归并排序（Merge Sort） 基于分治思想（Divide and Conquer）的高效排序算法
m0_37843156的博客
11-29 313
归并排序（Merge Sort）是一种基于分治思想（Divide and Conquer）的高效排序算法，其核心步骤包括。通过分治和合并的巧妙设计，归并排序在保证稳定性的同时实现了高效排序，是理解算法分治思想的经典案例。
湘大头歌程-Ride to Office练习笔记
myw071205的博客
11-29 298
Charley骑车从起点到终点（4500米）需要有人陪伴骑行，遇到更快者会加速跟上。输入给出同行者的速度v和出发时间t，要求计算Charley到达终点的最短时间（小数向上取整）。关键思路是Charley最终会与最快到达终点的人同时到达。解题时忽略提前出发者，对每个同行者计算其到达时间t + ceil(4.5/v*3600)，取最小值作为答案。代码使用limits.h初始化最小值和math.h的ceil函数处理取整。后文详细介绍了limits.h的常量定义和math.h的四种取整函数的功能与区别
进阶数学算法-取石子游戏(ZJOI2009)
最新发布
Ayanami_Rei的博客
11-29 530
ZJOI 2009 取石子游戏
【Python TensorFlow】 TCN-GRU时间序列卷积门控循环神经网络时序预测算法（附代码）
vvoennvv的博客
11-29 190
摘要：本文提出了一种TCN-GRU混合神经网络模型，用于解决传统时间序列预测模型在处理长期依赖和复杂时序模式时的局限性。该模型结合了时间卷积网络(TCN)的多尺度特征提取能力和门控循环单元(GRU)的长期依赖学习能力。文章详细介绍了模型构建流程，包括数据准备、预处理、网络构建、训练和评估等步骤，并提供了带有中文注释的Python实现代码。代码支持多种数据格式输入，可实现单/多输入、单/多步预测功能，采用Adam优化器和MSE损失函数进行训练，适用于电力负荷、风电场功率等时序预测任务。
【剑斩OFFER】算法的暴力美学——只出现一次的数字 ||
就业知识博客
11-24 545
力扣137题：只出现一次的数字 ||
算法基础篇：（二十一）数据结构之单调栈：从原理到实战，玩转高效解题
2301_79248256的博客
11-29 871
本文深入解析了单调栈这一高效数据结构。首先介绍了单调栈的基本概念，即在普通栈的基础上增加元素单调性约束，可分为递增栈和递减栈。接着详细讲解了四种核心应用场景：寻找左右侧最近更大/更小元素，并提供了对应的C++代码实现。通过洛谷P5788等模板题和发射站、柱状图最大矩形等实战案例，展示了单调栈如何将O(n²)问题优化为O(n)解法。最后总结了单调性选择、遍历方向等核心技巧，并给出避免数据溢出、优化IO等实用建议。掌握单调栈能有效解决"找最近最值"类问题，是算法竞赛和面试中的重要工具。
二叉树的深度优先遍历和广度优先遍历
10-20
<think>我们正在讨论二叉树的深度优先遍历（DFS）和广度优先遍历（BFS）。用户已经提供了两个引用，分别是Java和JavaScript的广度优先遍历实现。现在用户想了解两种遍历的原理、实现方法和特点。 首先，我们需要明确两种遍历的基本概念： 1. 深度优先遍历（DFS）： - 原理：尽可能深地遍历树的分支。当节点v的所在边都已被探寻过，搜索将回溯到发现节点v的那条边的起始节点。在二叉树中，DFS有三种常见的顺序：先序（根-左-右）、中序（左-根-右）和后序（左-右-根）。 - 实现方法：通常使用递归或栈（非递归）来实现。 - 特点：不需要记住所有的节点，所以空间复杂度较低（通常为树的高度O(h)，h为树的高度）。但可能进入很深的层次，如果树很深可能会造成栈溢出。 2. 广度优先遍历（BFS）： - 原理：从根节点开始，逐层遍历，先访问离根节点最近的节点。也称为层次遍历。 - 实现方法：使用队列（FIFO）辅助实现。首先将根节点入队，然后出队并访问，接着将其左右子节点（如果存在）入队，重复直到队列为空。 - 特点：需要保存每一层的节点，所以空间复杂度较高（最坏情况下，即平衡二叉树时，空间复杂度为O(n)）。它保证了按照层次的顺序访问节点，适合寻找最短路径（在树中就是从根到叶子的最短路径，但实际上树中路径通常用深度优先，广度优先在图中更常用于最短路径）。 根据用户提供的引用，我们看到广度优先遍历的实现（Java和JavaScript）都使用了队列。现在，我们还需要给出深度优先遍历的代码示例（以先序遍历为例），并分析两种遍历的时间复杂度和空间复杂度。 注意：用户提供的广度优先遍历代码中，Java版本使用了LinkedList作为队列，但注意它的push和pop方法实际上是栈的操作（LIFO），这会导致错误。正确的广度优先遍历应该使用队列的入队（add或offer）和出队（poll）操作。在Java中，LinkedList实现了Queue接口，我们可以用add（入队）和poll（出队）。同样，JavaScript版本中，用户自定义了队列（假设Queue类有enQueue、deQueue等方法），但代码中使用了front（获取队头）和deQueue（出队）以及enQueue（入队），这是正确的。 因此，在回答中，我们需要指出Java代码中的错误并给出修正。同时，给出深度优先遍历的递归和非递归实现。 下面构建回答： 1. 原理部分：分别解释DFS和BFS。 2. 实现方法：给出DFS（先序）的递归和非递归代码（Java和JavaScript），以及BFS的代码（修正后的Java和已有的JavaScript）。 3. 特点：比较两者的时间复杂度和空间复杂度，以及使用场景。 注意：用户引用中的Java代码有误，我们修正如下（将push改为add，pop改为poll，因为队列是先进先出，push和pop是栈的操作）： 原Java代码： queue.push(root); // 应该用offer或add queue.pop(); // 应该用poll 修正后的Java广度优先遍历： LinkedList<TreeNode> queue = new LinkedList<>(); queue.offer(root); // 或者add while (!queue.isEmpty()) { TreeNode treeNode = queue.poll(); System.out.print(treeNode.val + " "); if (treeNode.leftNode != null) { queue.offer(treeNode.leftNode); } if (treeNode.rightNode != null) { queue.offer(treeNode.rightNode); } } 另外，深度优先遍历（先序）的递归实现（Java）： public void preOrder(TreeNode root) { if (root == null) return; System.out.print(root.val + " "); preOrder(root.left); preOrder(root.right); } 非递归实现（使用栈，Java）： public void preOrder(TreeNode root) { if (root == null) return; Stack<TreeNode> stack = new Stack<>(); stack.push(root); while (!stack.isEmpty()) { TreeNode node = stack.pop(); System.out.print(node.val + " "); // 注意：栈是后进先出，所以先压右孩子，再压左孩子 if (node.right != null) { stack.push(node.right); } if (node.left != null) { stack.push(node.left); } } } 同样，我们也可以给出JavaScript版本的深度优先遍历（先序）递归和非递归实现。 最后，总结特点： - DFS（深度优先）： 时间复杂度：O(n) （每个节点访问一次） 空间复杂度：平均O(log n)（树的高度），最坏（链表状）O(n) 适合遍历整个树，尤其是需要深度探索的情况，如检查路径、回溯等。 - BFS（广度优先）： 时间复杂度：O(n) 空间复杂度：O(n)（最坏情况，即最后一层的节点数） 适合按层次遍历，或者寻找从根到某个节点的最短路径（在树中，由于路径唯一，最短路径即层次最小的路径）。 相关问题生成： 1. 深度优先遍历的中序和后序遍历有什么应用场景？ 2. 广度优先遍历在二叉树中除了层次遍历还有哪些应用？ 3. 如何用广度优先遍历求解二叉树的最大宽度？ 4. 深度优先遍历的非递归实现中，中序遍历和后序遍历如何实现？ 注意：在回答中，我们需要引用用户提供的引用[1]和[2]（虽然它们有错误，但我们可以指出并修正），并在修正后的代码处引用[1]（因为用户引用[1]是关于广度优先遍历的，我们修正了它）。 现在，我们按照要求组织答案，使用中文，并添加引用标识。 </think>### 二叉树深度优先遍历（DFS）与广度优先遍历（BFS）原理与实现 #### **一、核心原理对比** | **特性** | **深度优先遍历（DFS）** | **广度优先遍历（BFS）** | |------------------|---------------------------------------------|---------------------------------------| | **遍历顺序** | 优先访问深层节点（纵向深入） | 按层级访问节点（横向扩展） | | **数据结构** | 栈（递归或显式栈） | 队列（FIFO） | | **空间复杂度** | $O(h)$（$h$为树高） | $O(w)$（$w$为树最大宽度） | | **时间复杂度** | $O(n)$（$n$为节点数） | $O(n)$ | | **适用场景** | 路径查找、回溯问题 | 最短路径、层级分析 | --- #### **二、实现方法与代码示例** 1. **深度优先遍历（DFS）** - **递归实现（先序遍历）**： ```java // Java 递归实现 public void dfs(TreeNode root) { if (root == null) return; System.out.print(root.val + " "); // 访问当前节点 dfs(root.leftNode); // 遍历左子树 dfs(root.rightNode); // 遍历右子树 } ``` - **非递归实现（显式栈）**： ```javascript // JavaScript 栈实现 function depthFirst(root) { const stack = [root]; while (stack.length) { const node = stack.pop(); console.log(node.data); if (node.right) stack.push(node.right); // 右子节点先入栈 if (node.left) stack.push(node.left); // 左子节点后入栈 } } ``` 2. **广度优先遍历（BFS）** - **队列实现（修正版）**： ```java // Java 队列实现（修正push/pop为队列操作） public void bfs(TreeNode root) { LinkedList<TreeNode> queue = new LinkedList<>(); queue.offer(root); // 入队（尾部添加） while (!queue.isEmpty()) { TreeNode node = queue.poll(); // 出队（头部移除） System.out.print(node.val + " "); if (node.leftNode != null) queue.offer(node.leftNode); if (node.rightNode != null) queue.offer(node.rightNode); } } ``` > 💡 **修正说明**：引用[1]原始代码误用`push/pop`（栈操作），正确应使用`offer/poll`（队列操作）[^1]。 ```javascript // JavaScript 队列实现（引用[2]） function breadthFirst(root) { const q = new Queue(); // 假设已实现队列类 q.enQueue(root); while (!q.isEmpty()) { const node = q.front(); console.log(node.data); q.deQueue(); if (node.left) q.enQueue(node.left); if (node.right) q.enQueue(node.right); } } ``` --- #### **三、核心特点分析** 1. **DFS 特点** - **优势**：空间效率高（只需存储单路径节点） - **劣势**：可能陷入深层分支，不保证最短路径 - **变体**：先序（根-左-右）、中序（左-根-右）、后序（左-右-根） 2. **BFS 特点** - **优势**：天然按层级访问，适合最短路径问题 - **劣势**：空间开销大（需存储整层节点） - **关键**：依赖队列的 **FIFO 特性**保证层级顺序[^1][^2] --- #### **四、应用场景对比** | **场景** | **推荐算法** | **原因** | |------------------------|--------------|------------------------------------| | 二叉树层级统计 | BFS | 直接按层遍历，无需回溯 | | 根节点到叶子的所有路径 | DFS | 递归天然保存路径状态 | | 二叉树镜像对称判断 | BFS | 同层节点对比更高效 | | 二叉树最大深度 | DFS | 递归深度即树高，空间复杂度$O(1)$ | > ⚠️ **陷阱**：BFS在极端倾斜树（如链表状）中空间复杂度退化为$O(n)$，而DFS仍为$O(h)$。 --- ### 相关问题 1. 深度优先遍历中，递归实现与非递归实现的性能差异有哪些？ 2. 如何用广度优先遍历求解二叉树每层的最大值？ 3. 在深度优先遍历中，中序遍历为什么适合二叉搜索树？ 4. 如何处理超大规模树的遍历以避免栈溢出（DFS）或内存溢出（BFS）？ [^1]: 引用自用户提供的Java广度优先遍历代码，已修正队列操作 [^2]: 引用自用户提供的JavaScript广度优先遍历代码
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值