一维与二维树状数组

昨天学了一下树状数组，随笔都写了一大半，结果一个不小心就把他给删了，哎。。。。。。今天就当是复习吧！再写一次。

如果给定一个数组，要你求里面所有数的和，一般都会想到累加。但是当那个数组很大的时候，累加就显得太耗时了，时间复杂度为O(n)，并且采用累加的方法还有一个局限，那就是，当修改掉数组中的元素后，仍然要你求数组中某段元素的和，就显得麻烦了。所以我们就要用到树状数组，他的时间复杂度为O（lgn），相比之下就快得多。下面就讲一下什么是树状数组：

一般讲到树状数组都会少不了下面这个图：

下面来分析一下上面那个图看能得出什么规律：

据图可知：c1=a1，c2=a1+a2，c3=a3，c4=a1+a2+a3+a4，c5=a5，c6=a5+a6，c7=a7，c8=a1+a2+a3+a4+a5+a6+a7+a8，c9=a9，c10=a9+a10，

c11=a11........c16=a1+a2+a3+a4+a5+.......+a16。

分析上面的几组式子可知，当i 为奇数时，ci=ai ；当i 为偶数时，就要看i 的因子中最多有二的多少次幂，例如，6 的因子中有2 的一次幂，等于 2 ，所以c6=a5+a6（由六向前数两个数的和），4 的因子中有 2 的两次幂，等于4 ，所以c4=a1+a2+a3+a4（由四向前数四个数的和）。

（一）有公式：cn=a(n-a^k+1)+.........+an（其中k 为n 的二进制表示中从右往左数的0 的个数）。

那么，如何求a^k 呢？求法如下：

lowbit（）的返回值就是2^k 次方的值。

求出来2^k 之后，数组c 的值就都出来了，接下来我们要求数组中所有元素的和。

（二）求数组的和的算法如下：

（1）首先，令sum=0，转向第二步；

（2）接下来判断，如果n>0 的话，就令sum=sum+cn转向第三步，否则的话，终止算法，返回sum 的值；

（3）n=n - lowbit（n）（将n的二进制表示的最后一个零删掉），回第二步。

代码实现：

（三）当数组中的元素有变更时，树状数组就发挥它的优势了，算法如下（修改为给某个节点i 加上x ）：

（1）当i<=n 时，执行下一步；否则的话，算法结束;

（2）ci=ci+x ，i=i+lowbit（i）（在i 的二进制表示的最后加零），返回第一步。

代码实现：

树状数组是对一个数组改变某个元素和求和比较实用的数据结构。两中操作都是O(logn)。

在解题过程中，我们有时需要维护一个数组的前缀和S[i]=A[1]+A[2]+...+A[i]。

但是不难发现，如果我们修改了任意一个A[i],S[i]、S[i+1]...S[n]都会发生变化。

可以说，每次修改A[i]后，调整前缀和S[]在最坏情况下会需要O(n)的时间。

当n非常大时，程序会运行得非常缓慢。

因此，这里我们引入“树状数组”，它的修改与求和都是O(logn)的，效率非常高。

【理论】

为了对树状数组有个形象的认识，我们先看下面这张图。

如图所示，红色矩形表示的数组C[]就是树状数组。

这里，C[i]表示A[i-2^k+1]到A[i]的和，而k则是i在二进制时末尾0的个数，

或者说是i用2的幂方和表示时的最小指数。

（当然，利用位运算，我们可以直接计算出2^k=i&(i^(i-1)) ）

同时，我们也不难发现，这个k就是该节点在树中的高度，因而这个树的高度不会超过logn。

所以,当我们修改A[i]的值时，可以从C[i]往根节点一路上溯，调整这条路上的所有C[]即可，

这个操作的复杂度在最坏情况下就是树的高度即O(logn)。

另外，对于求数列的前

n项和，只需找到n以前的所

有最大子树，把其根节点的C

加起来即可。

不难发现，这些子树的

数目是n在二进制时1的个

数，或者说是把n展开成2的

幂方和时的项数,

因此，求和操作的复杂

度也是O(logn)。

接着，我们考察这两种操作下标变化的规律：

首先看修改操作：

已知下标i，求其父节点的下标。

我们可以考虑对树从逻辑上转化：

如图，我们将子树向右对称翻折，虚拟出一些空白结点（图中白色），将原树转化成完全二叉树。

有图可知，对于节点i，其父节点的下标与翻折出的空白节点下标相同。

因而父节点下标p=i+2^k (2^k是i用2的幂方和展开式中的最小幂，即i为根节点子树的规模)

即p = i + i&(i^(i-1)) 。

接着对于求和操作：

因为每棵子树覆盖的范围都是2的幂，所以我们要求子树i的前一棵树，只需让i减去2的最小幂即可。

即p = i - i&(i^(i-1)) 。

至此，我们已经比较详细的分析了树状数组的复杂度和原理。

在最后，我们将给出一些树状数组的实现代码，希望读者能够仔细体会其中的细节。【代码】

求最小幂2^k:

int Lowbit(int t)

{

return t & ( t ^ ( t - 1 ) );

}

求前n项和：

int Sum(int end)

{

int sum = 0;

while(end > 0)

{

sum += in[end];

end -= Lowbit(end); }

return sum;

}

对某个元素进行加法操作：

void plus(int pos , int num) {

while(pos <= n)

{

in[pos] += num;

pos += Lowbit(pos);

}

}

当要频繁的对数组元素进行修改,同时又要频繁的查询数组内任一区间元素之和的时候

,

可以考虑使用树状数

组.

通常对一维数组最直接的算法可以在O(1)时间内完成一次修改,但是需要O(n)时间来进行一次查询.而树状数组的修改和查询均可在O(log(n))的时间内完成.

一、回顾一维树状数组

假设一维数组为A[i](i=1,2,...n),则与它对应的树状数组C[i](i=1,2,...n)是这样定义的：

C1 = A1

C2 = A1 + A2

C3 = A3

C4 = A1 + A2 + A3 + A4

C5 = A5

C6 = A5 + A6

C7 = A7

C8 = A1 + A2 + A3 + A4 + A5 + A6 + A7 + A8

……

C16 = A1 + A2 + A3 + A4 + A5 + A6 + A7 + A8 + A9 + A10 + A11 + A12 + A13 + A14 + A15 + A16 ......

(1)C[t]展开以后有多少项？由下面公式计算：

int lowbit(int t){//计算c[t]展开的项数

return t&(-t);

}

C[t]展开的项数就是lowbit(t),C[t]就是从A[t]开始往左连续求lowbit(t)个数的和.

(2)修改

比如修改了A3,必须修改C3,C4,C8,C16,C32,C64...

当我们修改A[i]的值时，可以从C[i]往根节点一路上溯，调整这条路上的所有C[]即可，对于节点i，父

节点下标p=i+lowbit(i)

//给A[i]加上x后，更新一系列C[j]

update(int i,int x){

while(i<=n){

c[i]=c[i]+x;

i=i+lowbit(i);

}

}

(3)求数列A[]的前n项和，只需找到n以前的所有最大子树，把其根节点的C加起来即可。

如：Sun(1)=C[1]=A[1];

Sun(2)=C[2]=A[1]+A[2];

Sun(3)=C[3]+C[2]=A[1]+A[2]+A[3];

Sun(4)=C[4]=A[1]+A[2]+A[3]+A[4];

Sun(5)=C[5]+C[4];

Sun(6)=C[6]+C[4];

Sun(7)=C[7]+C[6]+C[4];

Sun(8)=C[8];

,,,,,,

int Sum(int n) //求前n项的和.

{

int sum=0;

while(n>0)

{

sum+=C[n];

n=n-lowbit(n);

}

return sum;

}

lowbit(1)=1 lowbit(2)=2 lowbit(3)=1 lowbit(4)=4

lowbit(5)=1 lowbit(6)=2 lowbit(7)=1 lowbit(8)=8 lowbit(9)=1 lowbit(10)=2 lowbit(11)=1 lowbit(12)=4 lowbit(13)=1 lowbit(14)=2 lowbit(15)=1 lowbit(16)=16 lowbit(17)=1 lowbit(18)=2 lowbit(19)=1 lowbit(20)=4 lowbit(21)=1 lowbit(22)=2 lowbit(23)=1 lowbit(24)=8 lowbit(25)=1 lowbit(26)=2 lowbit(27)=1 lowbit(28)=4 lowbit(29)=1 lowbit(30)=2 lowbit(31)=1 lowbit(32)=32

lowbit(33)=1 lowbit(34)=2 lowbit(35)=1 lowbit(36)=4 lowbit(37)=1 lowbit(38)=2 lowbit(39)=1 lowbit(40)=8 lowbit(41)=1 lowbit(42)=2 lowbit(43)=1 lowbit(44)=4 lowbit(45)=1 lowbit(46)=2 lowbit(47)=1 lowbit(48)=16 lowbit(49)=1 lowbit(50)=2 lowbit(51)=1 lowbit(52)=4 lowbit(53)=1 lowbit(54)=2 lowbit(55)=1 lowbit(56)=8 lowbit(57)=1 lowbit(58)=2 lowbit(59)=1 lowbit(60)=4 lowbit(61)=1 lowbit(62)=2 lowbit(63)=1 lowbit(64)=64

二、树状数组可以扩充到二维。

问题：一个由数字构成的大矩阵，能进行两种操作

1) 对矩阵里的某个数加上一个整数（可正可负）

2) 查询某个子矩阵里所有数字的和,要求对每次查询，输出结果。

一维树状数组很容易扩展到二维，在二维情况下:数组A[][]的树状数组定义为：

C[x][y] = ∑ a[i][j], 其中，

x-lowbit(x) + 1 <= i <= x,

y-lowbit(y) + 1 <= j <= y.

例：举个例子来看看C[][]的组成。

设原始二维数组为：

A[][]={{a11,a12,a13,a14,a15,a16,a17,a18,a19},

{a21,a22,a23,a24,a25,a26,a27,a28,a29},

{a31,a32,a33,a34,a35,a36,a37,a38,a39}，

{a41,a42,a43,a44,a45,a46,a47,a48,a49}};

那么它对应的二维树状数组C[][]呢？

记:

B[1]={a11,a11+a12,a13,a11+a12+a13+a14,a15,a15+a16,...} 这是第一行的一维树状数组

B[2]={a21,a21+a22,a23,a21+a22+a23+a24,a25,a25+a26,...} 这是第二行的一维树状数组

B[3]={a31,a31+a32,a33,a31+a32+a33+a34,a35,a35+a36,...} 这是第三行的一维树状数组

B[4]={a41,a41+a42,a43,a41+a42+a43+a44,a45,a45+a46,...} 这是第四行的一维树状数组

那么：

C[1][1]=a11,C[1][2]=a11+a12,C[1][3]=a13,C[1][4]=a11+a12+a13+a14,c[1][5]=a15,C[1][6]=a15+a1 6,...

这是A[][]第一行的一维树状数组

C[2][1]=a11+a21,C[2][2]=a11+a12+a21+a22,C[2][3]=a13+a23,C[2][4]=a11+a12+a13+a14+a21+a2 2+a23+a24,

C[2][5]=a15+a25,C[2][6]=a15+a16+a25+a26,...

这是A[][]数组第一行与第二行相加后的树状数组

C[3][1]=a31,C[3][2]=a31+a32,C[3][3]=a33,C[3][4]=a31+a32+a33+a34,C[3][5]=a35,C[3][6]=a35+a3

6,...

这是A[][]第三行的一维树状数组

C[4][1]=a11+a21+a31+a41,C[4][2]=a11+a12+a21+a22+a31+a32+a41+a42,C[4][3]=a13+a23+a33 +a43,...

这是A[][]数组第一行+第二行+第三行+第四行后的树状数组

搞清楚了二维树状数组C[][]的规律了吗？仔细研究一下,会发现:

（1）在二维情况下，如果修改了A[i][j]=delta,则对应的二维树状数组更新函数为：

private void Modify(int i, int j, int delta){

A[i][j]+=delta;

for(int x = i; x< A.length; x += lowbit(x))

for(int y = j; y

C[x][y] += delta;

}

}

（2）在二维情况下，求子矩阵元素之和∑ a[i][j](前i行和前j列)的函数为

int Sum(int i, int j){

int result = 0;

for(int x = i; x > 0; x -= lowbit(x)) {

for(int y = j; y > 0; y -= lowbit(y)) {

result += C[x][y];

}

}

return result;

}

比如：

Sun(1,1)=C[1][1]; Sun(1,2)=C[1][2]; Sun(1,3)=C[1][3]+C[1][2];... Sun(2,1)=C[2][1]; Sun(2,2)=C[2][2]; Sun(2,3)=C[2][3]+C[2][2];... Sun(3,1)=C[3][1]+C[2][1]; Sun(3,2)=C[3][2]+C[2][2];

例：测试一下：

import java.util.Arrays;

public class Test{

int[][] A;//原二维数组

int[][] C;//对应的二维树状数组

public Test(){

A=new int[5][6];

C=new int[5][6];

for(int i=1;i<5;i++)

for(int j=1;j<6;j++)

Modify(i,j,1);//给A[][]每个元素加1

for(int i=1;i<5;i++){

for(int j=1;j<6;j++)

System.out.print(A[i][j]+" ");//输出A[][] System.out.println();

}

System.out.println(Sum(3,4));//求子二维数组的和 Modify(2,3,4);//将A[2][3]加4

System.out.println(Sum(3,4));//显示修改后的和

}

private int lowbit(int t){

return t&(-t);

}

int Sum(int i, int j){

int result = 0;

for(int x = i; x > 0; x -= lowbit(x)) {

for(int y = j; y > 0; y -= lowbit(y)) {

result += C[x][y];

}

}

return result;

}

private void Modify(int i, int j, int delta){

A[i][j]+=delta;

for(int x = i; x< A.length; x += lowbit(x))

for(int y = j; y

}

}

public static void main(String args[]){ Test t=new Test();

}

}

C:\java>java Test

1 1 1 1 1

1 1 1 1 1

1 1 1 1 1

1 1 1 1 1

12

16