树状数组

  在写程序时突然发现别人有用到树形数组这样一个数据结构，目前具体应用场景不详，只知道可以很快的求出一个数组中下标i到下标j的和。

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

这里有一个有趣的性质：
  设节点编号为x，那么这个节点管辖的区间为2^k（其中k为x二进制末尾0的个数）个元素。因为这个区间最后一个元素必然为Ax，所以很明显：Cn = A(n – 2^k + 1) + … + An

求x二进制末尾0的个数的方法：

int lowBit(int x) {
    return x&(x^(x-1));
}

也可以利用补码特性：

int lowBit(int x){
    return x&-x;
}

当想要查询一个SUM(n)(求a[n]的和），可以依据如下算法即可：

step1:　令sum = 0，转第二步；
step2:　假如n <= 0，算法结束，返回sum值，否则sum = sum + Cn，转第三步；
step3: 令n = n – lowbit(n)，转第二步。

  可以看出，这个算法就是将这一个个区间的和全部加起来，为什么是效率是log(n)的呢？以下给出证明：
  n = n – lowbit(n)这一步实际上等价于将n的二进制的最后一个1减去。而n的二进制里最多有log(n)个1，所以查询效率是log(n)的。
  那么修改呢，修改一个节点，必须修改其所有祖先，最坏情况下为修改第一个元素，最多有log(n)的祖先。
所以修改算法如下（给某个结点i加上x）：

step1: 当i > n时，算法结束，否则转第二步；
step2: Ci = Ci + x， i = i + lowbit(i)转第一步。

i = i +lowbit(i)这个过程实际上也只是一个把末尾1补为0的过程。
对于数组求和来说树状数组简直太快了!

---

Java实现树状数组

public class BinTree {
    private ArrayList<Integer> list = new ArrayList<Integer>();
    public BinTree(int[] array) {
        for (int i = 0; i < array.length; i++) {
            int sum = 0;
            int begin = i+1 - lowBit(i+1);
            for (int j = begin; j <= i; j++) {
                sum += array[j];
            }
            list.add(sum);
        }
    }
    // 求数组下标0到下标k之间的总和，时间复杂度lg(n)
    public int sum(int k) {
//      if (k < 0) {
//          return 0;
//      }
//      else {
//          // list.get(k)为， array[k+1-lowBit(k+1)] + ... + array[k]的值，设为Ck；
//          // k = k-lowBit(k+1),此时的k为上一个区间外紧靠左边界的数组的下标
//          return list.get(k) + sum(k-lowBit(k+1));
//      }
        return k>=0?sum(k-lowBit(k+1))+list.get(k):0;
    }
    // 给数组下标为k的元素加上w
    // 显然在Cn中，只要包含a[k]的Ci都要加上w
    // 第一个包含a[k]的肯定是Ck
    // 因为lowBit(k+1)为Ck所管辖区间的大小，
    // k+lowBit(k+1)为下一个包含ak的Ci(这里我也不是很懂，希望大牛指出)
    // 我的理解是按照规律，第一个包含的是Ck，下一个C管辖的范围是上一个的两倍，因为n为上一个区间的最后一个元素的下标
    // 所以下一个C的下标为n+lowBit(n)
    public void add(int k, int w) {
        if (k < list.size()) {
            list.set(k, list.get(k)+w);
            add(k + lowBit(k+1), w);
        }
    }
    private int lowBit(int x) {
        return x&-x;
    }
    public static void main(String[] args) {
        BinTree a = new BinTree(new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12});
        BinTree b = new BinTree(new int[]{2, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12});
        ArrayList<Integer> list = b.list;
        a.add(0, 1);
        for (int i = 0; i < 12; i++) {
            System.out.println(a.list.get(i) + " " + b.list.get(i));
        }

    }
}