树状数组【总结】+例题：一维树状数组 1 ：单点修改，区间查询【题解】

最新推荐文章于 2022-09-28 20:04:28 发布
最新推荐文章于 2022-09-28 20:04:28 发布
阅读量421 收藏 4
点赞数 3
分类专栏： 树状数组 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/cqbzybc20220707/article/details/107599802
版权

树状数组

概念

树状数组 (Binary Indexed Tree(BIT)也称作(Fenwick Tree) 是一个区间查询和单点修改复杂度都为log(n)的数据结构。主要用于查询任意两点之间的所有元素之和。

例题：一维树状数组 1 ：单点修改，区间查询

【模板】树状数组 1（洛谷）
树状数组 1 ：单点修改，区间查询（Liuser’s OJ）

题目

题目描述

如题，已知一个数列，你需要进行下面两种操作：

  1. 将某一个数加上 x
  2. 求出某区间每一个数的和
输入格式

第一行包含两个正整数 n,m ，分别表示该数列数字的个数和操作的总个数。
第二行包含 n 个用空格分隔的整数，其中第 i 个数字表示数列第 i 项的初始值。
接下来 m 行每行包含 3 个整数，表示一个操作，具体如下：

  1. 含义：将第 x 个数加上 k
1 x k
  1. 含义：输出区间 [x,y] 内每个数的和
2 x y
输出格式

输出包含若干行整数，即为所有操作 2 的结果。

样例
样例1输入
5 5
1 5 4 2 3
1 1 3
2 2 5
1 3 -1
1 4 2
2 1 4
样例1输出
14
16
数据范围

对于100%的数据，1≤n,m≤5×10^5。

分析

这道题的 常见做法：
for(long long i=x;i<=y;i++)
{
   
 ans+=a[i];
}
//用for循环从区间x到y依次求和，时间复杂度：O(n) 。

缺点：当数据规模极大的时候，将会变得效率低下，容易超时。

这时，我们想到了 前缀和：
//原数组为A[i]，再定义一个数组B[i]，i≤n+5。
B[1]=A[1
最低0.47元/天 解锁文章
树状数组：单点修改，区间查询（详解）
C202220yanglin的博客
07-26 1169
问题的提出 ： 给定一个序列 a，可以进行两种操作： 1 i x ：给定 i , x, 将 a[i] 加上 x; 2 l r ：给定 l ， r， 求 a[l] + a[l + 1] + ··· + a[r + 1] 的值 （单点修改，区间查询） 首先，我们会想到直接用一个现行的数组。那么单点修改的时间复杂度将是 O(1)O(1)O(1)，但是区间查询的时间复杂度却是 O(n)O(n)O(n)， 数据范围一大，就很有可能会超时。 那么，又有人会想到用一个前缀和数组，但是有没有想过，虽然区间查询的时间复
树状数组（单点修改+区间修改）
菜鸡成长史
07-24 3745
【引入】 树状数组(Binary Indexed Tree(B.I.T), Fenwick Tree)是一个查询和修改复杂度都为log(n)的数据结构。主要用于查询任意两位之间的所有元素之和，但是每次只能修改一个元素的值；经过简单修改可以在log(n)的复杂度下进行范围修改，但是这时只能查询其中一个数组的值(如果加入多个辅助数组则可以实现区间修改与区间查询)。 这种数据结构（算法）并没有C++...
树状数组模板1（单点修改，区间和查询）
ShineEternal的笔记小屋
07-23 208
切记树状数组不能处理为0的情况（lowbit无法计算，所以遇到这种情况别忘了+1） #include<cstdio> #include<iostream> using namespace std; int a[500005],b[500005]; int n; int lowbit(int x) { return x&(-x); } void ...
树状数组（一） 【单点修改，区间查询】
weixin_45743427的博客
07-27 497
【单点修改，区间查询】 这是树状数组的基本用法，修改和查询的复杂度都是O(logn)。 个人认为树状数组是巧妙的利用二进制实现了二分，所以他查询的时候很快。 单点修改是要把与这个点所有有关的点都进行修改，是一个从下往上的过程，通过一个点+lowbit(这个点)来更新所有管辖这个点的点，直到最上面 区间查询时就是求两个前缀和，一相减就是区间和。求前缀和的过程与单点修改的操作相反，是不断通过一个点 - lowbit(这个点) 来覆盖所有小的区间 以上是个人理解。树状数组就不放图了，关于lowbit的内容可以看一
树状数组（1.单点修改，区间查询 2.区间修改，单点查询）
weixin_53024141的博客
09-03 2590
一种较高级的数据结构——树状数组，综合降低了数组中修改和查询操作的复杂度，相比于线段树，代码实现更为简短且易理解。
树状数组（单点修改+单点查询+区间修改+区间查询）
水，全都是水
09-28 2724
树状数组（单点修改+单点查询+区间修改+区间查询）
【C++】浅析树状数组(B.I.T.)
__皮娃__的博客
12-03 794
浅析树状数组——B.I.T.beginning顺序结构 A+B高精 A+B压位高精 A+B二分A+B树状数组简介(不喜欢啰嗦的请直接跳到这里)基础概念代码实现大体结构lowbit beginning 让我们先从这道题开始:P1001 A+B Problem 说明: 我不是在搞笑 ! 我们可以探讨一下,用我们所学的知识可以如何解决这道题. 顺序结构 A+B #include&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;am
树形DP总结
算法小猪的博客
01-23 663
一、树形DP存树how to build a tree! 1.用vector,动态数组存图，储存两个节点的父子关系（接下来的代码使用这个） 2、链式前向星 3、邻接表 二、怎样动态规划 how to DP! 给定一棵有n个节点的树，我们可以任选一个点为根节点，从而 定义出每个节点的深度和每棵子树的根 在树上进行DP，一般就以节点从深到浅的顺序作为DP的“阶段”。 DP的状态表示中...
树形dp+树形结构总结
热门推荐
dcx2001的博客
10-18 3万+
总结       最近写了好多树形dp+树形结构的题目，这些题目变化多样能与多种算法结合，但还是有好多规律可以找的。 树形dp一般都是用子树更新父亲（即从下向上更新），那么首先应该考虑的是一个一个子树的更新父亲还是把所有子树都算完了在更新父亲？这就要因题而异了，一般来说有两种情况：1.需要把所有子树的信息都掌握之后再更新子树的就需要把所有子树都算完了在更新父亲。2.而像树上背包这样的问题就需要
树状数组解决区间问题：单点、区间修改，单点、区间查询
游戏码农一枚，不定时分享技术文章~
03-25 926
目录前言一. 单点修改，单点查询二. 单点修改，区间查询三. 区间修改，单点查询四. 区间修改，区间查询 前言 最近在复习算法的时候，刷到了一些针对于区间问题，所以在此记录。 注：此文章默认会使用树状数组，不会的可以参考这一篇文章：树状数组详解 一. 单点修改，单点查询 这个很简单，我们直接使用单纯的数组就可以了。 二. 单点修改，区间查询 #include <iostream> using namespace std; const int N = 1e5 + 10; int tree[N
树状数组（单点查询，单点修改，区间查询，区间修改）
correct
08-23 332
树状数组就是形如上图的一种数据结构 单点查询 lowbit运算设计的很巧妙 int lowbit(int x){ return x & -x; } 可以求出一个数的二进制表示中最低位的1和后面的0组成的数字 例如：lowbit(7)，7的二进制是111，lowbit(7)就是，最低为的1和后面的0（没有0）组成的数，二进制表示为1，即数字1 用树状数组维护的实质上是一个...
【练习-3】树状数组-模板三（区间修改，区间查询）
WtcSky的博客
01-31 1309
直接放题目，然后再解释： 树状数组： 1.单点修改，区间查询 2.区间修改，单点查询 3.区间修改，区间查询 区间修改，区间查询 Description 给定数列 a[1],a[2],…,a[n]，你需要依次进行q个操作，操作有两类： 1 l r x：给定l,r,x，对于所有的i∈[l,r]，将a[i]加上x（换言之，将a[l],a[l+1],…,a[r] 分别加上x） 2 l r：给定l,r，求∑ri=la[i]的值（换言之，求a[l]+a[l+1]+…+a[r]的值） Input 第一行包含2个正整数
[AcWing算法提高课]之 高阶数据结构 树状数组（C++题解）
lihua777的博客
05-14 698
[AcWing算法提高课]之 高阶数据结构 树状数组（C++题解）
【最详细】一文解决树状数组：详细原理、例题与C++实现
AsanoKiri的博客
07-11 378
应用场景： 单点更新以及区间求和问题，比如已知一个数列长度为n，你需要进行w次修改一个值和q次查询一个区间内的和。 修改和查询的复杂度都是O(logN)。 原理： 黑色（A）的是原数组，我们要增加一些节点用来记录一个区间的信息；这些红色节点（C）形成了层状结构，越上层的节点覆盖的区间范围越大。首先标号为i的红色节点位于第几层，是由其二进制表示的末位有几个0决定的：比如任何奇数都在第0层，而2(10)、6(110)在第1层，8(1000)在第3层。 C[1]=A[1] C[2]=C[1]+A..
【YbtOJ 树状数组 - 1】单点修改区间查询
CW.
07-08 208
单点修改区间查询 题目 输入 输出 对于每个 222 lll rrr 操作输出一行，每行有一个整数，表示所求的结果 输入样例 3 2 1 2 3 1 2 0 2 1 3 输出样例 6 解题思路 这题用的是树状数组，树状数组支持单点加操作，还支持查询前缀和，这题我们就直接可以用到 程序如下 #include<algorithm> #include<iostream> #include<cstring> #include<cstdio> us
树状数组 1 ：单点修改，区间查询
p15008340649的博客
03-13 427
这是一道模板题。 给定数列 a[1],a[2],…,a[n]，你需要依次进行 q 个操作，操作有两类： “1 i x”：给定 i,x，将 a[i] 加上 x； “2 l r”：给定 l,r，求 ∑ri=la[i] 的值（换言之，求 a[l]+a[l+1]+⋯+a[r] 的值）。 Input 第一行包含 2 个正整数 n,q，表示数列长度和询问个数。保证 1≤n,q≤106。 第二行 n 个整数 a[1],a[2],…,a[n]，表示初始数列。保证 |a[i]|≤106。 接下来 q 行，每行一个操作，为以下
树状数组 1 ：单点修改与区间查询
sjy的博客
02-17 440
Description 给定数列 a[1],a[2],…,a[n]，你需要依次进行 q个操作，操作有两类： 1 i x：给定 i,x将 a[i]加上 x； 2 l r：给定 l,r，求a[l]+a[l+1]+…+a[r] 的值）。 Input 第一行包含 2 个正整数 n,q，表示数列长度和询问个数。保证 1≤n,q≤10^6 。 第二行 n 个整数a[1],a[2],…,a[n]，表示初始数列。...
C++树状数组入门模板+例题逆序对
hrdate(菜菜菜带带带)
04-01 1382
> #include<bits/stdc++.h> using namespace std; const int MAX=50005; int a[MAX],tree[MAX],n; int lowbit(int x) //找最低位的1 { return x&-x; } void add(int i,int x)//修改数据在i加x { while(i&l...
SYZOJ - [线段树]模板题1(树状数组)
ityanger的技术栈
04-27 2888
题目链接:https://syzoj.com/problem/509 内存限制：256 MiB 时间限制：3000 ms 题目描述 这是一道模板题。 给定数列a[1],a[2],…,a[n]，你需要依次进行q个操作，操作有两类： 1 i x：给定i,x，将a[i]加上x； 2 l r：给定l,r，求的值(换言之，求a[l]+a[l+1]+⋯+a[r]的值)。 输入格...
二叉树遍历树形例题及答案
最新发布
03-30
<think>嗯，用户需要关于二叉树遍历的例题和解答。首先，我得回忆一下常见的二叉树遍历题目，比如前序、中序、后序以及层次遍历。根据引用[3]，里面提到了很多LeetCode题目，比如144、94、145分别是前序、中序、后序遍历，还有层序遍历相关的题目比如102、107。这些题目应该可以作为例题。 接下来，我需要整理每个遍历方式的基本算法，然后给出对应的例题和解答。比如前序遍历可以用递归或者迭代实现，引用[1]提到三种遍历的算法结构相似，只是访问根节点的顺序不同。所以在示例代码中，递归方法调整printf的位置即可。不过用户可能需要更具体的代码，比如Python实现。 然后，层次遍历通常用队列实现，比如题目102，可以用BFS的方法逐层处理节点。这里要确保代码正确，并且有注释说明。引用[3]里提到的层序遍历、右视图、平均值等题目都可以作为例子。 另外，用户可能还想知道如何解决这些题目的思路，比如中序遍历的迭代方法需要用到栈来模拟递归，可能需要详细解释步骤。还有后序遍历的非递归实现比较复杂，可以用反向先序遍历的方法，或者记录访问状态。 在整理答案时，要注意使用中文，数学公式用$...$，独立公式用$$...$$，并确保LaTeX语法正确。同时，每个例题后附上题解和代码，代码块用Python语法高亮。最后生成相关问题，比如不同遍历的应用、非递归实现的方法，或者特定题目的变种问题。 需要检查引用是否正确，比如引用[1]提到三种遍历的搜索路线相同，递归过程相同，这可能用来解释代码结构的相似性。引用[3]提供的题目列表可以用来举例。确保所有信息准确，并且例题解答符合题目要求。</think>### 二叉树遍历算法及典型例题解析 #### 一、二叉树遍历的核心算法 1. **前序遍历**（根左右）： **递归实现**： ```python def preorder(root): if not root: return print(root.val) # 访问根节点 preorder(root.left) # 遍历左子树 preorder(root.right) # 遍历右子树 ``` **非递归实现**（使用栈）： ```python def preorder_iterative(root): stack = [] while stack or root: while root: print(root.val) # 访问根节点 stack.append(root) root = root.left # 深入左子树 root = stack.pop() root = root.right # 转向右子树 ``` 2. **中序遍历**（左根右）： **递归实现**： ```python def inorder(root): if not root: return inorder(root.left) # 遍历左子树 print(root.val) # 访问根节点 inorder(root.right) # 遍历右子树 ``` **非递归实现**： ```python def inorder_iterative(root): stack = [] while stack or root: while root: stack.append(root) root = root.left # 深入左子树 root = stack.pop() print(root.val) # 访问根节点 root = root.right # 转向右子树 ``` 3. **后序遍历**（左右根）： **递归实现**： ```python def postorder(root): if not root: return postorder(root.left) # 遍历左子树 postorder(root.right) # 遍历右子树 print(root.val) # 访问根节点 ``` **非递归实现**（反向先序遍历+反转）： ```python def postorder_iterative(root): stack = [root] result = [] while stack: node = stack.pop() if node: result.append(node.val) stack.append(node.left) # 左子节点先入栈 stack.append(node.right) # 右子节点后入栈 return result[::-1] # 反转得到后序结果 ``` 4. **层序遍历**（广度优先）： ```python from collections import deque def level_order(root): if not root: return [] queue = deque([root]) result = [] while queue: level = [] for _ in range(len(queue)): node = queue.popleft() level.append(node.val) if node.left: queue.append(node.left) if node.right: queue.append(node.right) result.append(level) return result ``` --- #### 二、典型例题及解答 ##### 例题1：二叉树的前序遍历（LeetCode 144） **要求**：返回节点值的前序列表。 **题解**：递归或迭代实现均可。 ```python # 递归解法 class Solution: def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]: res = [] def dfs(node): if not node: return res.append(node.val) dfs(node.left) dfs(node.right) dfs(root) return res ``` ##### 例题2：二叉树的中序遍历（LeetCode 94） **要求**：返回节点值的中序列表。 **题解**： ```python # 迭代解法 class Solution: def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]: res, stack = [], [] while stack or root: while root: stack.append(root) root = root.left root = stack.pop() res.append(root.val) root = root.right return res ``` ##### 例题3：二叉树的层序遍历（LeetCode 102） **要求**：按层输出节点值的二维数组。 **题解**：使用队列实现广度优先搜索。 ```python class Solution: def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]: if not root: return [] res = [] queue = deque([root]) while queue: level = [] for _ in range(len(queue)): node = queue.popleft() level.append(node.val) if node.left: queue.append(node.left) if node.right: queue.append(node.right) res.append(level) return res ``` ##### 例题4：二叉树的右视图（LeetCode 199） **要求**：返回从右侧能看到的节点值列表。 **题解**：层序遍历时记录每层最后一个节点。 ```python class Solution: def rightSideView(self, root: Optional[TreeNode]) -> List[int]: if not root: return [] res = [] queue = deque([root]) while queue: level_size = len(queue) for i in range(level_size): node = queue.popleft() if i == level_size - 1: # 当前层最后一个节点 res.append(node.val) if node.left: queue.append(node.left) if node.right: queue.append(node.right) return res ``` --- #### 三、关键知识点总结 - **遍历差异**：三种递归遍历仅访问根节点的顺序不同，搜索路径完全一致[^1]。 - **时间复杂度**：所有遍历均为$O(n)$，空间复杂度递归为$O(h)$（h为树高），迭代为$O(n)$。 - **应用场景**： - 前序遍历：复制树结构、序列化二叉树。 - 中序遍历：二叉搜索树的有序输出。 - 后序遍历：计算子树性质（如高度）。 - 层序遍历：按层处理节点（如右视图、平均值）。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值