【学习笔记】详解树状数组

置顶 已于 2024-07-31 14:12:08 修改
阅读量1k 收藏 4
点赞数 4
分类专栏： 树 文章标签： c语言 算法 数据结构 深度优先
于 2023-02-01 16:11:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weq2011/article/details/128835460
版权
树状数组是一种数据结构，提供O(logn)时间内的单点修改和区间求和操作，比线段树有更优的常数因子。它利用二进制特性进行快速更新和查询，常见于数组操作问题。文章通过代码示例解释了树状数组的核心操作和单点修改、区间查询的实现原理。
摘要由CSDN通过智能技术生成

前言

树状数组或二叉索引树（Binary Indexed Tree），又以其发明者命名为 Fenwick 树。其初衷是解决数据压缩里的累积频率的计算问题，现多用于高效计算数列的前缀和、区间和。它可以以 O(logn) 的时间得到任意前缀和。并同时支持在 O(logn) 时间内支持动态单点值的修改。空间复杂度 O(n)。

一、树状数组概括

树状数组是一个查询和修改复杂度都为log(n)的数据结构。主要用于数组的单点修改&&区间求和，另外一个拥有类似功能的是线段树。

具体区别和联系如下：

1.两者在复杂度上同级, 但是树状数组的常数明显优于线段树, 其编程复杂度也远小于线段树.

2.树状数组的作用被线段树完全涵盖, 凡是可以使用树状数组解决的问题, 使用线段树一定可以解决, 但是线段树能够解决的问题树状数组未必能够解决.

3. 树状数组的突出特点是其编程的极端简洁性, 使用lowbit技术可以在很短的几步操作中完成树状数组的核心操作，其代码效率远高于线段树。

二、树状数组的应用

1.单点修改+区间查询

代码示例


int lowbit(int x)
{
  return x & (-x);//表示求数组下标二进制的非0最低位所表示的值
}

//查找1~x的和
int find_sum(int x)
{
  int ans = 0;
  while(x)
  {
    ans += c[x];//从右往左累加求和
    x -= lowbit(x);
  }
  return x;
}

//单点修改
void gexi(int x,int v)
{
  a[x] += v;
  while(x <= n)
  {
    c[x] += v;
    x += lowbit(x);//由叶子节点向上更新树状数组C，从左往右更新
  }
}

实现原理

模板中最常见的三个函数：

①取数组下标二进制非0最低位所表示的值；
②单点更新；
③区间查询。

树状数组，顾名思义是树状的数组，我们首先引入二叉树，叶子节点代表A[1]~A[8]。

现在变形一下：

现在定义每一列的顶端节点C数组（其实C数组就是树状数组），如图：

理解树状数组的重点

C[i]代表子树的叶子节点的权值之和，如图可以知道：

C[1]=A[1];

C[2]=A[1]+A[2];

C[3]=A[3];

C[4]=A[1]+A[2]+A[3]+A[4];

C[5]=A[5];

C[6]=A[5]+A[6];

C[7]=A[7];

C[8]=A[1]+A[2]+A[3]+A[4]+A[5]+A[6]+A[7]+A[8];

首先是区间查询（求和）：

利用C[i]数组，求A数组中前i项和，举两个栗子：

①i=7

前7项和：sum[7]=A[1]+A[2]+A[3]+A[4]+A[5]+A[6]+A[7]；

而C[4]=A[1]+A[2]+A[3]+A[4]；C[6]=A[5]+A[6]；C[7]=A[7]；

可以得到：sum[7]=C[4]+C[6]+C[7]。

数组下标写成二进制：sum[(111)]=C[(100)]+C[(110)]+C[(111)]；

②i=5

前5项和：sum[5]=A[1]+A[2]+A[3]+A[4]+A[5]；

而C[4]=A[1]+A[2]+A[3]+A[4]；C[5]=A[5]；

可以得到：sum[5]=C[4]+C[5]；

数组下标写成二进制：sum[(101)]=C[(100)]+C[(101)]；

细细观察二进制，树状数组追其根本就是二进制的应用，结合代码演示一下代码过程：


//查找1~x的和
int find_sum(int x)
{
  int ans = 0;
  while(x)
  {
    ans += c[x];
    x -= lowbit(x);
  }
  return x;
}
代码推演

对于i=7进行演示：


7(111)  ans+=C[7]

lowbit(7)=001 7-lowbit(7)=6(110) ans+=C[6]

lowbit(6)=010 6-lowbit(6)=4(100) ans+=C[4]

lowbit(4)=100 4-lowbit(4)=0(000) break；

对于i=5进行演示：


5(101)  ans+=C[5]

lowbit(5)=001 5-lowbit(5)=4(100) ans+=C[4]

lowbit(4)=100 4-lowbit(4)=0(000) break；

然后单点更新：

当我们修改A数组中某个值时，应当如何更新C数组呢？回想一下，区间查询的过程，再看一下上文中列出的过程。这里声明一下：单点更新实际上是不修改A数组的，而是修改树状数组C，向上更新区间长度为lowbit(i)所代表的节点的值。


//单点修改
void gexi(int x,int v)
{
  a[x] += v;
  while(x <= n)
  {
    c[x] += v;
    x += lowbit(x);
  }

如图：当在A[1]加上值val，即更新A[1]时，需要向上更新C[1],C[2],C[4],C[8]，这个时候只需将这4个节点每个节点的值加上val即可。这里为了方便大家理解，人为添加了个A数组表示每个叶子节点的值，事实上A数组并不用修改，实际运用中也可不设置A数组，单点更新只需修改树状数组C即可。下标写成二进制：C[(001)],C[(010)],C[(100)],C[(1000)]；

lowbit(1)=001 1+lowbit(1)=2(010) C[2]+=val；

lowbit(2)=010 2+lowbit(2)=4(100) C[4]+=val；

lowbit(4)=100 4+lowbit(4)=8(1000) C[8]+=val；

由于c[1] c[2] c[4] c[8] 都包含有A[1]，所以在更新A[1]时实际上就是更新每一个包含A[1]的节点。

题目

代码

#include<bits/stdc++.h>
#define int long long
using namespace std;
int n,q,a[1000001],op,t,tt,c[1000001];
int lowbit(int x)
{
  return (x & (-x));
}
void add(int p,int num)
{
  while(p <= n)
  {
    c[p] += num;
    p += lowbit(p);
  }
}
int query(int p)
{
  int tmp = 0;
  while(p)   
  {   
    tmp += c[p];      
    p -= lowbit(p);   
  }   
  return tmp;
}
signed main()
{
  cin>>n>>q;
  for(int i = 1;i <= n;i++)
  {
    scanf("%lld",&a[i]);
    add(i,a[i]);
  }
  while(q--)
  {
    cin>>op>>t>>tt;
    if(op == 1)
    {
      add(t,tt);
    }
    else
    {
      cout<<query(tt) - query(t - 1)<<endl;
    }
  }
  return 0;
}

2.区间修改+单点查询

思路

可以利用差分的思想。具体可见一维,二维差分の详解（简单易懂）_一维差分-CSDN博客

于是只需要预处理出来一个差分数组，再利用树状数组进行单点操作即可。

题目

代码

#include<bits/stdc++.h>
#define int long long
using namespace std;
int n,q,a[1000001],op,t,tt,c[1000001];
int lowbit(int x)
{
  return (x & (-x));
}
void add(int p,int num)
{
  while(p <= n)
  {
    c[p] += num;
    p += lowbit(p);
  }
}
int query(int p)
{
  int tmp = 0;
  while(p)   
  {   
    tmp += c[p];      
    p -= lowbit(p);   
  }   
  return tmp;
}
signed main()
{
  cin>>n>>q;
  for(int i = 1;i <= n;i++)
  {
    scanf("%lld",&a[i]);
    add(i,a[i]);
  }
  while(q--)
  {
    cin>>op>>t>>tt;
    if(op == 1)
    {
      add(t,tt);
    }
    else
    {
      cout<<query(tt) - query(t - 1)<<endl;
    }
  }
  return 0;
}

3.单点修改操作

思路

假如题目要求把a改成b,那么就相当于把a加上(b - a)。从而就转化成了上一道题。

题目

代码

#include<bits/stdc++.h>
#define int long long
using namespace std;
int n,q,a[1000001],l,r,x,c[1000001];
char op;
int lowbit(int x)
{
  return (x & (-x));
}
void add(int p,int num)
{
  while(p <= n)
  {
    c[p] += num;
    p += lowbit(p);
  }
}
int query(int p)
{
  int tmp = 0;
  while(p)   
  {   
    tmp += c[p];      
    p -= lowbit(p);   
  }   
  return tmp;
}
signed main()
{
  cin>>n>>q;
  for(int i = 1;i <= n;i++) scanf("%lld",&a[i]);
  while(q--)
  {
    cin>>op>>l;
    if(op == 'A')
    {
      cin>>r>>x;
      add(l,x);
      add(r + 1,-x);
    }
    if(op == 'Q')
    {
      cout<<a[l] + query(l)<<endl;
    }
    if(op == 'X')
    {
      int t = a[l] + query(l);
      add(l,1 - t);
      add(l + 1,t - 1);
    }
  }
  return 0;
}

4.区间修改+区间查询

思路

直接上图

 因此只需维护两个树状数组即可
  一个是差分数组的树状数组c[i]，还有一个是i*b[i]的树状数组d[i]

题目

代码

#include<bits/stdc++.h>
#define int long long
using namespace std;
int n,q,a[1000001],l,r,x,c[1000001],d[1000001];
char op;
int lowbit(int x)
{
  return (x & (-x));
}
void add(int o[],int p,int num)
{
  while(p <= n)
  {
    o[p] += num;
    p += lowbit(p);
  }
}
int query(int o[],int p)
{
  int tmp = 0;
  while(p)   
  {   
    tmp += o[p];    
    p -= lowbit(p);   
  }   
  return tmp;
}
int f(int x)
{
  return query(c,x) * (x + 1) - query(d,x);
}
signed main()
{
  cin>>n>>q;
  for(int i = 1;i <= n;i++) scanf("%lld",&a[i]);
  for(int i = 1;i <= n;i++)
  {
    int b = a[i] - a[i - 1];
    add(c,i,b);
    add(d,i,b * i);
  }
  while(q--)
  {
    cin>>op>>l>>r;
    if(op == 'C')
    {
      cin>>x;
      add(c,l,x);
      add(d,l,l * x);
      add(c,r + 1,-x);
      add(d,r + 1,-(r + 1) * x);
    }
    else cout<<f(r) - f(l - 1)<<endl;
  }
  return 0;
}

5.求逆序对

思路

我们先来模拟一下一种求逆序对的方法

例如：a =  {5,4,2,6,3,1}

我们先定义一个b数组，我们遍历a数组令b[a[i]] = 1,逆序对数就为(b[i + 1] + b[i + 2] + …… + b[n])的和，其实就是以a数组为下标在b数组中填1，对于a[i],如果b[i]之后已经出现1，那么后面1的下标均可与a[i]构成逆序对。

    模拟：开始b都为0

    1.b = {0，0，0，0，1，0}      sumb(6,6) = 0，后面没有一，说明还没有数与5构成逆序对

    2.b = {0，0，0，1，1，0}      sumb(5,6) = 1，4与5构成了逆序对

    3.b = {0，1，0，1，1，0}      sumb(3,6) = 2，2与4，5均构成了逆序对

    4.b = {0，1，0，1，1，1}      sumb(7,6) 不存在

    5.b = {0，1，1，1，1，1}      sumb(4,6) = 3，3与4，5，6均构成了逆序对

    6.b = {1，1，1，1，1，1}      sumb(2,6) = 5，1与其他5个数都构成了逆序对

    所以答案ans = 0 + 1 + 2 + 3 + 5 = 11

然后这一过程我们就可以用树状数组来操作，把b数组看成树状数组，令b[a[i]] = 1的过程我们就可以看成数状数组的更新操作，求sumb就可以看成区间查询操作，最后对每次区间查询求和即为逆序对的个数。

 

题目

代码

#include<bits/stdc++.h>
#define int long long
using namespace std;
int n,q,a[10000001],c[10000001],ans,maxn;
int lowbit(int x)
{
  return (x & (-x));
}
void add(int p,int num)
{
  while(p <= maxn)
  {
    c[p] += num;
    p += lowbit(p);
  }
}
int query(int p)
{
  int tmp = 0;
  while(p)   
  {   
    tmp += c[p];      
    p -= lowbit(p);   
  }   
  return tmp;
}
signed main()
{
  cin>>n;
  for(int i = 1;i <= n;i++)
  {
    scanf("%lld",&a[i]);
    maxn = max(maxn,a[i]);
  }
  for(int i = 1;i <= n;i++) add(a[i],1),ans += (query(maxn) - query(a[i]));;
  //for(int i = 1;i <= n;i++) 
  cout<<ans;
  return 0;
}

总结

树状数组的重点就是利用二进制的变化，动态地更新树状数组。

树状数组的每一个节点并不是代表原数组的值，而是包含了原数组多个节点的值。

所以在更新A[1]时需要将所有包含A[1]的C[i]都加上val这也就利用到了二进制的神奇之处。

如果是更新A[i]的值，则每一次对C[i] 中的 i 向上更新，即每次i+=lowbit(i),这样就能C[i] 以及C[i] 的所有父节点都加上val。

反之求区间和也是和更新节点值差不多，只不过每次 i-=lowbit(i)。

结语

如果这篇文章对您有帮助的话，请记得点赞收藏加关注吖(●'◡'●)

Ia_aIweq
关注
  • 4
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaScript高级程序设计 DOM学习笔记
10-28
根据给定的文件信息，以下是关于JavaScript中DOM（文档对象模型）的相关知识点详解： DOM是文档对象模型（Document Object Model）的缩写，它是一个跨平台的接口，由W3C组织制定标准，用于在HTML或XML文档中创建和...
树状数组(详细分析+应用)，看不懂打死我!
TheWayForDream
07-03 4万+
树状数组介绍 在学习一个算法之前一定要清楚它能干嘛，能解决什么样的问题，对你解题是否有帮助，然后才去学习它! 那么接下来看如下几个问题 什么是树状数组 顾名思义就是一个结构为树形结构的数组，于二叉树的结构类似但又不同，它是在二叉树的结构上删除了一些中间节点，来看两幅图就明白了. 1.这是二叉树的结构 2.这是树状数组的结构 不难发现，树状数组相比于二叉树删除了一些节点，但是为什么要删除呢？这就和树状数组的一些性质(lowbit)有关了，不懂没关系，继续往下看. 树状数组可以解决什么问题呢？ 可以解决大部
树状数组详解
萧何山的博客
07-31 1万+
文章目录前言一、树状数组概括二、树状数组的应用1.单点修改+区间查询总结 前言 树状数组或二叉索引树（Binary Indexed Tree），又以其发明者命名为 Fenwick 树。其初衷是解决数据压缩里的累积频率的计算问题，现多用于高效计算数列的前缀和、区间和。它可以以 O(logn) 的时间得到任意前缀和。并同时支持在 O(logn) 时间内支持动态单点值的修改。空间复杂度 O(n)。 一、树状数组概括 树状数组是一个查询和修改复杂度都为log(n)的数据结构。主要用于数组的单点修改&
c++/c语言之用树状数组来进行（区间修改和询问）
最新发布
LovelyCat_mm的博客
06-01 973
我们以上图为例，tree[1]=C1=A1，tree[2]=C2=C1+A2，tree[3]=C3=A3，tree[4]=C4=C2+C3+A4，tree[5]=C5=A5，tree[6]=C5+A6，tree[7]=A7，tree[8]=C4+C6+C7+A8。其实这个名字看起来还挺高级的，但相信经过我的介绍，大家可以都听得明白，嗯呐，接下来，我们先详细而系统性地介绍一下树状数组的定义，概念，以及最为重要的编码和应用。然后去掉最后的一个1，得到000，就会惊奇的发现，没有了，那就直接return。
树状数组（超详细）
Jiguoyuanyic的博客
08-24 3616
树状数组千字精华讲解
树状数组数据结构
qq_37464878的博客
02-22 2571
1.树状数组概念 树状数组简单来说就是仅通过一个数组来描述一棵树或一个森林。数组中每个元素只存储着树中对应节点存储的信息，不存储描述树的层次结构的信息。 2.普通树的存储 对于一棵普通的树，在《数据结构》严蔚敏版中提到可以使用如下方法进行存储： 2.1 父节点表示法 用一个数组中存储节点信息，节点信息包括节点存储数据和父节点编号。 struct Node { int data; // 节点存储的数据 int parent; // 节点对应的父节点的编号 } struct Tree {
树状数组简单易懂的详解
热门推荐
FlushHip
01-25 6万+
树状数组确实是个好东西啊，以前搞比赛的时候了解过它，会套用模版，但确没有深入理解这个东西，先学会用轮子，然后再学造轮子嘛，这段时间再回头研究了一下，发现二进制在算法中真的是的好东西，它可以使算法的时间复杂度降到n的二进制表示中的1相关，大家都知道，求一个二进制中的1的个数，这个时间复杂度为O(logn)" role="presentation" style="position: relative;
数据结构—树状数组
不忘初心，知行统一
11-28 1375
一，什么是树状数组。       树状数组作为线段树的一个分支，能处理一些特殊情况下的线段树问题，在数学上我们这样定义： 数据类型为 ，更新操作为将 变为 ，查询为求 。 如果 构成一个幺半群，就可以用线段树实现。 如果 并且(S, +)构成一个交换群，就可以用树状数组实现。 数据类型为 ，更新操作为对所有的 将 变为，查询为求 。 如果 构成一个幺半群， 构成
JavaScript达内学习笔记
10-03
### JavaScript达内学习笔记知识点详解 #### 一、JavaScript简介 1. **JavaScript**是由网景公司在1995年开发的一种脚本语言。它是一种轻量级的编程语言，无需编译，直接由浏览器解释执行。JavaScript的主要作用...
算法笔记-066Kruskal算法详解（Java）共10页
10-31
【Kruskal算法详解】 Kruskal算法是图论中的一种最小生成树算法，由Edsger W....同时，这本“算法笔记_066Kruskal算法详解”提供了详细的步骤和示例，对于学习者来说是一份宝贵的参考资料，可以深入学习和研究。
android学习笔记
04-03
### Android学习笔记知识点详解 #### 一、Android平台组成 1. **Linux内核**：作为Android的基础，提供了操作系统的核心功能，如硬件驱动程序、内存管理等。 2. **Android运行时**：主要包括了核心库（实现Java...
树状数组（尽量详细了）
a591027895的博客
04-04 5655
树状数组
树状数组详解(入门）
Rudy1124的博客
08-11 1192
树状数组的重点就是利用二进制的变化，动态地更新树状数组。树状数组的每一个节点并不是代表原数组的值，而是包含了原数组多个节点的值。所以在更新a[1]时需要将所有包含a[1]的c[i]都加上k这也就利用到了二进制的神奇之处。如果是更新a[i]的值，则每一次对c[i] 中的 i 向上更新，即每次i+=lowbit(i),这样就能c[i] 以及c[i] 的所有父节点都加上k。反之求区间和也是和更新节点值差不多，只不过每次 i-=lowbit(i)。本篇文章有借鉴oi.wiki和。
【数据结构】 树状数组及其应用
Hello World!
03-20 1058
树状数组的含义是将数组表示为稀疏树形结构，是一种能在 O(logn) 时间内对数组进行更新和区间维护的数据结构。其本质就是利用二进制的特性将前缀和数组维护在树上的一种数据结构，类似于线段树。树状数组与线段树功能和作用类似，在复杂度上也同级。复杂性：树状数组在时间复杂度上的常数明显优于线段树，并且更加简洁和轻量化，代码效率高。功能性：树状数组的功能比较局限，只能处理简单的具有前缀和累计特性的区间维护、修改问题。
数据结构之树状数组 ——详解
weixin_55786578的博客
04-30 1247
树状数组是一种维护前缀和、区间和的数据结构。它在原数组上添加索引，从而高效维护数据。神奇而小巧的数据结构，树状数组的下标必须从1开始！无论是他的修改还是查询，时间复杂度永远都是 logn，适合用于做区间和，前缀和，单点修改比前缀和标准做法的修改快一些。
树状数组介绍
hnjzsyjyj的专栏
09-30 1288
【知识点】 树状数组，是一种小巧优雅的数据结构，可在O(logn)的时间内计算出数列的前缀和。树状数组，又称二进制索引树。 树状数组的经典实现包含两个数组：一个是存储数列元素的数组 A[]，另一个是存储数列前缀和的数组 C[]。而树状数组名称的由来，恰是因为数组 C[] 呈现为树状结构。两个数组之间的关系为：C[i]=A[i-2^k+1]+A[i-2^k+2]+…+A[i]，其中的k 表示 i 的二进制表示末尾有k个连续的0。且由 C[] 与 A[] 的关系式易得，每个 C[i] 由数组 A[] ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值