树状数组（Fenwick tree，又名binary indexed tree），是一种很实用的数据结构。它通过用节点i，记录数组下标在[ i –2^k + 1, i]这段区间的所有数的信息（其中，k为i的二进制表示中末尾0的个数，设lowbit(i) = 2^k），实现在O(lg n) 时间内对数组数据的查找和更新。
树状数组的传统解释图，不能很直观的看出其所能进行的更新和查询操作。其最主要的操作函数lowbit(k)与数的二进制表示相关，本质上仍是一种二分。因而可以通过二叉树，对其进行分析。事实上，从二叉树图，我们对它所能进行的操作和不能进行的操作一目了然。
和前面提到的点树类似，先画一棵二叉树，然后对节点中序遍历（点树是采用广度优先），每个节点仍然只记录左子树信息，见图：
由于采用的是中序遍历，从节点1到节点k时，刚好有k个叶子被统计。
可以证明：
叶子k，一定在节点k的左子树下。
以节点k为根的树，其左子树共有叶子lowbit(k)
节点k的父节点是：k + lowbit(k) 或 k - lowbit(k)
节点k + lowbit(k) 是节点k的最近父节点，且节点k在它的左子树下。
节点k - lowbit(k) 是节点k的最近父节点，且节点k在它的右子树下。
节点k，统计的叶子范围为：(k - lowbit(k), k]。
节点k的左孩子是：k - lowbit(k) / 2
下面分析树状数组两面主要应用：
1 更新数据x，进行区间查询。
2 更新区间，查询某个数。
由于，树状数组只统计了左子树的信息，因而只能查询更新区间[1, x]。只在在满足[x,y]的信息可以由[1,x-1]和[1,y]的信息推导出时，才能进行区间[x,y]的查询更新。这也是树状数组不能用于任意区间求最值的根本原因。
先定义两个集合：
up_right(k) ： 节点k所有的父节点，且节点k在它们的左子树下。
up_left(k) ： 节点k所有的父节点，且节点k在它们的右子树下。
1 更新数据x，查询区间[1,y]。
显然，更新叶子x，要找出叶子x在哪些节点的左子树下。因而节点k、所有的up_right(k)
都要更新。
查询[1, y]，实际上就是把该区间拆分成一系列小区间，并找出统计这些区间的节点。可以通过找出y在哪些节点的右子树下，这些节点恰好不重复的统计了区间[1, y-1]。因而要访问节点y、所有的up_left(y)。
2 更新区间[1,y]，查询数据x
这和前面的操作恰好相反。与前面的最大不同之处在于：节点保存的不再是其叶子总个数这些信息，而是该区间的所有叶子都改变了多少。也就是说：每个叶子的信息，分散到了所有对它统计的节点上。因此操作和前面相似：
更新[1,y]时，更新节点y、所有up_left(y)。
查询x时， 访问x、所有up_right(x)。
前面的树状数组，只对左子树信息进行统计，如果从后往前读数据初始化树状数组，则变成只对右子树信息进行统计，这时更新和查询操作，刚好和前面的相反。
一般情况下，树状数组比点树省空间，对区间[1, M]只要M+1空间，查询更新时定位节点比较快，定位父节点和左右孩子相对麻烦点（不过，一般也不用到。从上往下查找，可参考下面代码中的erease_nth函数（删除第n小的数））。
下面是使用树状数组的实现代码（求逆序数和模拟约瑟夫环问题）：
树状数组
#include < cstdio >
#include < cstring >
#include < cassert >
template < int N > struct Round2k
{ enum { down = Round2k < N / 2u > ::down * 2 }; };
template <> struct Round2k < 1 > { enum { down = 1 }; };
template < int Total, typename T = int > // 区间[1, Total]
class BIT {
enum { Min2k = Round2k < Total > ::down};
T info[Total + 1 ];
T sz; // 可以用info[0]储存总大小
public :
BIT() { clear(); }
void clear() { memset( this , 0 , sizeof ( * this ));}
int size() { return sz; }
int lowbit( int idx) { return idx & - idx;}
// 寻找最近的父节点，left_up/right_up 分别使得idx在其右/左子树下
void left_up( int & idx) { idx -= lowbit(idx); }
void right_up( int & idx) { idx += lowbit(idx); }
void update( int idx , const int val = 1 ) { // 叶子idx 改变val个
assert(idx > 0 );
sz += val;
for (; idx <= Total; right_up(idx)) info[idx] += val;
}
void init( int arr[], int n) { // arr[i]为叶子i+1的个数
assert(n <= Total);
sz = n;
// for (int i = 0; i < n; ) {
// info[i + 1] = arr[i];
// if (++i >= n) break;
// info[i + 1] = arr[i];
// ++i;
// for (int j = 1; j < lowbit(i); j *= 2u) info[i] += info[i - j];
// }
for ( int i = 0 ; i < n; ) {
info[i + 1 ] = arr[i];
if ( ++ i >= n) break ;
int sum = arr[i];
int pr = ++ i;
left_up(pr);
for ( int j = i - 1 ; j > pr; left_up(j)) sum += info[j];
info[i] = sum;
}
}
int count( int idx) { // [1,idx] - [1, idx-1]
assert(idx > 0 );
int sum = info[idx];
// int pr = idx; // int pr = idx - lowbit(idx);
// left_up(pr);
// for (--idx; idx > pr; left_up(idx)) sum -= info[idx]; //
// return sum;
for ( int j = 1 ; j < lowbit(idx); j *= 2u ) sum -= info[idx - j];
return sum;
}
int lteq( int idx) { // 小等于
assert(idx >= 1 && idx <= Total);
int sum = 0 ;
for (; idx > 0 ; left_up(idx)) sum += info[idx];
return sum;
}
int gt( int idx) { return sz - lteq(idx); } // 大于
int operator []( int n) { return erase_nth(n, 0 ); } // 第n小
int erase_nth( int n, const bool erase_flag = true ) // 删除第n小的数
{
assert(n >= 1 && n <= sz);
sz -= erase_flag;
int idx = Min2k; // 从上往下搜索，先定位根节点
for ( int k = idx / 2u ; k > 0 ; k /= 2u ) {
int t = info[idx];
if (n <= info[idx]) { info[idx] -= erase_flag; idx -= k;} // 进入左子树
else {
n -= t;
if (Total != Min2k && Total != Min2k - 1 ) // 若不是完全二叉树
while (idx + k > Total) k /= 2u ; // 则必须计算右孩子的编号
idx += k; // 进入右子树
}
}
assert(idx % 2u ); // 最底层节点m一定是奇数，有两个叶子m，m+1
if (n > info[idx]) return idx + 1 ; // 节点m+1前面已经更新过
info[idx] -= erase_flag;
return idx;
}
void show()
{
for ( int i = 1 ; i <= Total; ++ i)
if (count(i)) printf( " %2d " , i);
printf( " \n " );
}
};
void ring() // 约瑟夫环
{
const int N = 17 ; // N个人编号：1,2, ... N
const int M = 7 ; // 报数：1到M，报到M的出列
printf( " N: %d M: %d\n " , N, M);
BIT < N > pt;
// for (int i = 0; i < N; ++i) pt.update(i + 1);
int arr[N];
for ( int i = 0 ; i < N; ++ i) arr[i] = 1 ;
pt.init(arr, N);
for ( int j = N, k = 0 ; j >= 1 ; -- j) {
k = (k + M - 1 ) % j;
int t = pt.erase_nth(k + 1 );
printf( " turn: %2d out: %2d rest: " , N - j, t);
pt.show();
}
printf( " \n\n " );
}
int ra( int arr[], int len) // 求逆序数-直接搜索
{
int sum = 0 ;
for ( int i = 0 ; i < len - 1 ; ++ i)
for ( int j = i + 1 ; j < len; ++ j)
if (arr[i] > arr[j]) ++ sum;
return sum;
}
template < int N >
int rb( int arr[], int len) // 求逆序数-使用树状数组
{
BIT < N > pt;
int sum = 0 ;
for ( int i = 0 ; i < len; ++ i) {
pt.update(arr[i] + 1 );
sum += pt.gt(arr[i] + 1 );
}
return sum;
}
int main()
{
int arr[] = { 4 , 3 , 2 , 1 , 0 , 5 , 1 , 3 , 0 , 2 };
const int N = sizeof (arr) / sizeof (arr[ 0 ]);
printf( " %d %d\n\n " , ra(arr, N), rb < 6 > (arr, N));
ring();
}
400
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
