[Data Structure and Algorithm] Tree Array

Fenwick Tree

---

Binary Indexed Tree (also known as Fenwick Tree) is an array-based data structure for efficient and dynamic maintenance of prefix sums.

Tree arrays can be done in $O(\log$The single-point modificationandprefix summationwithin the time complexity of$n$$)$ is suitable for some problems that only need to maintain the prefix sum, such as interval summation, interval mean, interval median, etc.

1. Problem description

For a given array $a_1,a_2,...,a\left[n\right]$ , when you need to frequently ask a certain interval$a_i,a_{i+1},...,a[j]$ （其中 $1<=i<j<=n$ ), and there exists modification$a_i$In the case of element values, how to design an efficient query and modification algorithm?

An intuitive approach is the brute force method, which is $The\; time\; complexity\; of\; O\left(1\right)$ is modified at a single point, but in the process of query, because each element in the interval needs to be traversed, the worst case requires$O\left(n^2\right)$time (here it is assumed that the size of the operation is$O\left(n\right)$ ). In order to solve this low query efficiency, one idea is to use a tree array.

2. Solve ideas

In the tree array $In\; d$ , the value stored in each array position is not only the value of the current element, but the cumulative value of the elements in a certain interval. The specific storage rules are shown in the left diagram of the figure below.

In the diagram on the left, the matrix corresponding to the subscript of the element indicates the value stored at the location 矩阵覆盖区域对应的原数组元素之和, for example, the subscript is $1$ place stores the element value of the original array subscript 1, and the subscript 4 stores the original array subscript$1$ to$The\; sum\; of\; the\; element\; values\; of\; 4$ .

The storage rule reflected in the storage graph of the tree array is:

The number is xxThe interval governed by the nodes of$x$$2^k$ (where$k$ for$The\; number\; of\; zeros\; at\; the\; end\; of\; binary\; x$ ) elements.

For example $d[6]=a[5]+a\left[6\right]$ , because the binary number corresponding to position 6 is110, the number of zeros at the end is 1, so it needs to store$2^1=2$ elements, the same applies to others.

With the above storage rules, how to perform range query and element modification operations? In order to facilitate the description of the operation, the diagram on the left can be rotated to obtain the diagram on the right (the depth of the tree is $lo{g}_{2}n+1$ ), and use a straight line to represent the relationship between the prefix accumulation nodes. In addition, in order to facilitate the subsequent description of range query and element modification operations, lowbitthe operation

public int lowbit(int x) {
    
    
    return x & (-x);
}

The so-called lowbitoperation is to obtain the current variable $x$ The position of the last 1 in the binary. This operation can be remembered first, and the subsequent operation introduction can help further understanding.

(1) Interval query

In the tree structure shown on the right, if you query the prefix sum of a certain node, you need to find the previous node from this point to the left, and add the value of its node, so as to continuously search and accumulate the node value to the left. For example, to query the prefix sum 节点 7of , you need to 节点7start from , find 节点 6for the accumulation operation, and then find 节点 4for the accumulation operation (it can be understood in combination with the coverage area of ​​the matrix in the figure). So how is this traversal process achieved? This requires us to convert the node number into binary form first:

• 7 ---- 0111
• 6 ---- 0110
• 4 ---- 0100

A general rule can be found: the position of the next traversal $x^{\text{'}}$ is the current position$x$ erases the last 1on the binary bit$1$ . Therefore, lowbitthe operation$x^{\prime }$ 有：$x^{\prime }=x-lowbit(x)$。

(2) Element modification

Element modification can be regarded as the reverse process of interval query, that is, in the tree structure shown on the right, if one of the nodes is modified, it is necessary to find the parent node layer by layer (to the upper right, which is exactly the same as the interval query instead), and apply the same modification process to each parent node as needed. For example 节点 3, add $k$ operation, you need to traverse节点 3,节点 4,kk节点 8in the process of traversal$k$ operation. In the process of traversing the next node, you only need to use the reverse process similar to the interval query, that is, for the current$x$ position node, the next traverse node$x^{\prime }=x+lowbit(x)$。

3. Code implementation

class FenwickTree {
    
    
    private int[] tree;
    
    public FenwickTree(int n) {
    
    
        tree = new int[n+1];
    }
    
    public int lowbit(int x) {
    
    
        return x & (-x);
    }
    
    public void add(int i, int val) {
    
    
        while(i < tree.length) {
    
    
            tree[i] += val;
            i += lowbit(i);
        }
    }
    
    public int query(int i) {
    
    
        int res = 0;
        while(i > 0) {
    
    
            res += tree[i];
            i -= lowbit(i);
        }
    }
}