这应该是我碰到过的最复杂的数据结构。。完全摸不着头脑，看了这篇文章，有了一些的认识。

https://www.hackerearth.com/notes/binary-indexed-tree-made-easy-2/

看完这个后再看这篇文章：
http://www.geeksforgeeks.org/binary-indexed-tree-or-fenwick-tree-2/

segment tree: 线段树
binary index tree: 树状数组

好吧。看完binary index tree 感觉大脑已经无力了。
还记得 range sum 吗？
如果用DP来做，update的时候，复杂度是O(n)
有没有想过为什么复杂度会这么大？
因为啊，每个index，都把之前的 [0, index]都考虑进去了，
所以之前这个区间有任何元素变了，他都得跟着变。

那现在提出一种改良方法：
如果index记录的并不是[0, index]的和，而是另外一种和，这样，当update的时候，有些涉及到的需要更新，有些不涉及的就不需要更新了。这就是
binary index tree的思想。

如果没看懂我再说什么，就自己看我列举出来的第一片文章即可。
比如[1,8]
如果我们按照这样的方式来记录：
[1]: [1]
[2]: [1, 2]
[3]: [3]
[4]: [1,4]
[5]: [5]
[6]: [5,6]
[7]: [7]
[8]: [1,8]

如果index 2的值改变了，我们需要Update哪些？
[1], [2], [4], [8]
看到没？更新的次数从O(n) 变成了O(log n)

…
Fuck, 谁想出来的。。。

那么求和呢？
比如求 [2,5]
那么：
[3,5] = [1,5] – [1,2]
= [1,4] + [5] – [1,2]
= [4] + [5] – [2]

复杂度也变成了: O(log n)
空间复杂度是 O(n)

更多的细节看那篇文章吧。

最后一个问题，给你一个index，如何拆分他？
比如 5，要求 [1,5]
5 = 0101

int ans = 0;
int index = 5;
while (index > 0) {
    ans += BIT[index];
    index -= (index & -index);
}

如果index 是5的话，0101
0101 -> 0100 ans += BIT[5], index = 4
0100 -> 0000 ans += BIT[4], index = 0
end loop

so:
and = BIT[5] + BIT[4]
= [4] + [5]

sum(5) = [4] + [5]

对了，这篇文章全篇没有考虑 nums[] 到 BIT[] 映射时 +1的问题，自己意会。

如果是更新 nums[]的话,
更新BIT[index];

比如更新 BIT[5]

BIT[0] – BIT[4] 不用任何变化。

BIT[6]
BIT[8]
都需要改变

int index = 5;
int diff = value - nums[index - 1];
while (index < BIT.length) {
    BIT[index] += diff;
    index += (index & -index);
}

index = 5: 0101
0101
0101 + 0001 = 0110 BIT[6]
0110 + 0010 = 1000 BIT[8]

index & -index 这个比特操作，可以拿到 index最右边第一个是1的位。
比如index =0101
index & -index = 0001

感觉也差不多说了很多了。

自己实现了下：
My code:

public class BinaryIndexTree {
    int[] BIT;
    int[] nums;
    public void initialize(int[] nums) {
        this.nums = nums;
        BIT = new int[nums.length + 1];
        for (int i = 1; i <= nums.length; i++) {
            updateBIT(i - 1, nums[i - 1]);
        }
    }
    
    public int getSum(int qs, int qe) {
        if (qs == 0) {
            return getSum(qe);
        }
        else {
            return getSum(qe) - getSum(qs - 1);
        }
    }
    
    private int getSum(int index) {
        index = index + 1;
        int ans = 0;
        while (index != 0) {
            ans += BIT[index];
            index -= (index & -index);
        }
        return ans;
    }
    
    public void update(int index, int value) {
        int diff = value - nums[index];
        nums[index] = value;
        updateBIT(index, diff);
    }
    
    private void updateBIT(int index, int diff) {
        index = index + 1;
        while (index < BIT.length) {
            BIT[index] += diff;
            index += (index & -index);
        }
    }
    
    public static void main(String[] args) {
        BinaryIndexTree test = new BinaryIndexTree();
        int[] nums = new int[]{1,2,3,4,5};
        test.initialize(nums);
        int ret = test.getSum(1, 2);
        System.out.println(ret);
        test.update(2, 4);
        ret = test.getSum(1, 2);
        System.out.println(ret);
    }
}

Anyway, Good luck, Richardo! — 09/04/2016