Binary Indexed Tree : Range Update and Range Queries - GeeksforGeeks

16 Jun, 2021
Given an array arr[0..n-1]. The following operations need to be performed. 
update(l, r, val) : Add ‘val’ to all the elements in the array from [l, r].getRangeSum(l, r) : Find sum of all elements in array from [l, r].
update(l, r, val) : Add ‘val’ to all the elements in the array from [l, r].
getRangeSum(l, r) : Find sum of all elements in array from [l, r].
Initially all the elements in the array are 0. Queries can be in any order, i.e., there can be many updates before range sum.Example:  
Input : n = 5   // {0, 0, 0, 0, 0}
Queries: update : l = 0, r = 4, val = 2
         update : l = 3, r = 4, val = 3 
         getRangeSum : l = 2, r = 4

Output: Sum of elements of range [2, 4] is 12

Explanation : Array after first update becomes
              {2, 2, 2, 2, 2}
              Array after second update becomes
              {2, 2, 2, 5, 5}
 
In the previous post, we discussed range update and point query solutions using BIT. rangeUpdate(l, r, val) : We add ‘val’ to element at index ‘l’. We subtract ‘val’ from element at index ‘r+1’. getElement(index) [or getSum()]: We return sum of elements from 0 to index which can be quickly obtained using BIT.We can compute rangeSum() using getSum() queries. rangeSum(l, r) = getSum(r) – getSum(l-1)A Simple Solution is to use solutions discussed in previous post. Range update query is same. Range sum query can be achieved by doing get query for all elements in range. An Efficient Solution is to make sure that both queries can be done in O(Log n) time. We get range sum using prefix sums. How to make sure that update is done in a way so that prefix sum can be done quickly? Consider a situation where prefix sum [0, k] (where 0 <= k < n) is needed after range update on range [l, r]. Three cases arises as k can possibly lie in 3 regions.Case 1: 0 < k < l The update query won’t affect sum query.Case 2: l <= k <= r Consider an example:  
Add 2 to range [2, 4], the resultant array would be:
0 0 2 2 2
If k = 3
Sum from [0, k] = 4
How to get this result? Simply add the val from lth index to kth index. Sum is incremented by “val*(k) – val*(l-1)” after update query. Case 3: k > r For this case, we need to add “val” from lth index to rth index. Sum is incremented by “val*r – val*(l-1)” due to update query.Observations : Case 1: is simple as sum would remain same as it was before update.Case 2: Sum was incremented by val*k – val*(l-1). We can find “val”, it is similar to finding the ith element in range update and point query article. So we maintain one BIT for Range Update and Point Queries, this BIT will be helpful in finding the value at kth index. Now val * k is computed, how to handle extra term val*(l-1)? In order to handle this extra term, we maintain another BIT (BIT2). Update val * (l-1) at lth index, so when getSum query is performed on BIT2 will give result as val*(l-1).Case 3 : The sum in case 3 was incremented by “val*r – val *(l-1)”, the value of this term can be obtained using BIT2. Instead of adding, we subtract “val*(l-1) – val*r” as we can get this value from BIT2 by adding val*(l-1) as we did in case 2 and subtracting val*r in every update operation. 
Update Query 
Update(BITree1, l, val)
Update(BITree1, r+1, -val)
UpdateBIT2(BITree2, l, val*(l-1))
UpdateBIT2(BITree2, r+1, -val*r)

Range Sum 
getSum(BITTree1, k) *k) - getSum(BITTree2, k)
Implementation of above idea  
C++
Java
Python3
C#
Javascript
// C++ program to demonstrate Range Update// and Range Queries using BIT#include <bits/stdc++.h>using namespace std; // Returns sum of arr[0..index]. This function assumes// that the array is preprocessed and partial sums of// array elements are stored in BITree[]int getSum(int BITree[], int index){    int sum = 0; // Initialize result     // index in BITree[] is 1 more than the index in arr[]    index = index + 1;     // Traverse ancestors of BITree[index]    while (index>0)    {        // Add current element of BITree to sum        sum += BITree[index];         // Move index to parent node in getSum View        index -= index & (-index);    }    return sum;} // Updates a node in Binary Index Tree (BITree) at given// index in BITree.  The given value 'val' is added to// BITree[i] and all of its ancestors in tree.void updateBIT(int BITree[], int n, int index, int val){    // index in BITree[] is 1 more than the index in arr[]    index = index + 1;     // Traverse all ancestors and add 'val'    while (index <= n)    {        // Add 'val' to current node of BI Tree        BITree[index] += val;         // Update index to that of parent in update View        index += index & (-index);    }} // Returns the sum of array from [0, x]int sum(int x, int BITTree1[], int BITTree2[]){    return (getSum(BITTree1, x) * x) - getSum(BITTree2, x);}  void updateRange(int BITTree1[], int BITTree2[], int n,                 int val, int l, int r){    // Update Both the Binary Index Trees    // As discussed in the article     // Update BIT1    updateBIT(BITTree1,n,l,val);    updateBIT(BITTree1,n,r+1,-val);     // Update BIT2    updateBIT(BITTree2,n,l,val*(l-1));    updateBIT(BITTree2,n,r+1,-val*r);} int rangeSum(int l, int r, int BITTree1[], int BITTree2[]){    // Find sum from [0,r] then subtract sum    // from [0,l-1] in order to find sum from    // [l,r]    return sum(r, BITTree1, BITTree2) -           sum(l-1, BITTree1, BITTree2);}  int *constructBITree(int n){    // Create and initialize BITree[] as 0    int *BITree = new int[n+1];    for (int i=1; i<=n; i++)        BITree[i] = 0;     return BITree;} // Driver Program to test above functionint main(){    int n = 5;     // Construct two BIT    int *BITTree1, *BITTree2;     // BIT1 to get element at any index    // in the array    BITTree1 = constructBITree(n);     // BIT 2 maintains the extra term    // which needs to be subtracted    BITTree2 = constructBITree(n);     // Add 5 to all the elements from [0,4]    int l = 0 , r = 4 , val = 5;    updateRange(BITTree1,BITTree2,n,val,l,r);     // Add 2 to all the elements from [2,4]    l = 2 , r = 4 , val = 10;    updateRange(BITTree1,BITTree2,n,val,l,r);     // Find sum of all the elements from    // [1,4]    l = 1 , r = 4;    cout << "Sum of elements from [" << l         << "," << r << "] is ";    cout << rangeSum(l,r,BITTree1,BITTree2) << "\n";     return 0;}
// Java program to demonstrate Range Update// and Range Queries using BITimport java.util.*; class GFG{ // Returns sum of arr[0..index]. This function assumes// that the array is preprocessed and partial sums of// array elements are stored in BITree[]static int getSum(int BITree[], int index){    int sum = 0; // Initialize result     // index in BITree[] is 1 more than the index in arr[]    index = index + 1;     // Traverse ancestors of BITree[index]    while (index > 0)    {        // Add current element of BITree to sum        sum += BITree[index];         // Move index to parent node in getSum View        index -= index & (-index);    }    return sum;} // Updates a node in Binary Index Tree (BITree) at given// index in BITree. The given value 'val' is added to// BITree[i] and all of its ancestors in tree.static void updateBIT(int BITree[], int n, int index, int val){    // index in BITree[] is 1 more than the index in arr[]    index = index + 1;     // Traverse all ancestors and add 'val'    while (index <= n)    {        // Add 'val' to current node of BI Tree        BITree[index] += val;         // Update index to that of parent in update View        index += index & (-index);    }} // Returns the sum of array from [0, x]static int sum(int x, int BITTree1[], int BITTree2[]){    return (getSum(BITTree1, x) * x) - getSum(BITTree2, x);}  static void updateRange(int BITTree1[], int BITTree2[], int n,                int val, int l, int r){    // Update Both the Binary Index Trees    // As discussed in the article     // Update BIT1    updateBIT(BITTree1, n, l, val);    updateBIT(BITTree1, n, r + 1, -val);     // Update BIT2    updateBIT(BITTree2, n, l, val * (l - 1));    updateBIT(BITTree2, n, r + 1, -val * r);} static int rangeSum(int l, int r, int BITTree1[], int BITTree2[]){    // Find sum from [0,r] then subtract sum    // from [0,l-1] in order to find sum from    // [l,r]    return sum(r, BITTree1, BITTree2) -        sum(l - 1, BITTree1, BITTree2);}  static int[] constructBITree(int n){    // Create and initialize BITree[] as 0    int []BITree = new int[n + 1];    for (int i = 1; i <= n; i++)        BITree[i] = 0;     return BITree;} // Driver Program to test above functionpublic static void main(String[] args){    int n = 5;     // Contwo BIT    int []BITTree1;    int []BITTree2;     // BIT1 to get element at any index    // in the array    BITTree1 = constructBITree(n);     // BIT 2 maintains the extra term    // which needs to be subtracted    BITTree2 = constructBITree(n);     // Add 5 to all the elements from [0,4]    int l = 0 , r = 4 , val = 5;    updateRange(BITTree1, BITTree2, n, val, l, r);     // Add 2 to all the elements from [2,4]    l = 2 ; r = 4 ; val = 10;    updateRange(BITTree1, BITTree2, n, val, l, r);     // Find sum of all the elements from    // [1,4]    l = 1 ; r = 4;    System.out.print("Sum of elements from [" + l        + "," + r+ "] is ");    System.out.print(rangeSum(l, r, BITTree1, BITTree2)+ "\n");}} // This code is contributed by 29AjayKumar
# Python program to demonstrate Range Update# and Range Queries using BIT # Returns sum of arr[0..index]. This function assumes# that the array is preprocessed and partial sums of# array elements are stored in BITree[]def getSum(BITree: list, index: int) -> int:    summ = 0 # Initialize result     # index in BITree[] is 1 more than the index in arr[]    index = index + 1     # Traverse ancestors of BITree[index]    while index > 0:         # Add current element of BITree to sum        summ += BITree[index]         # Move index to parent node in getSum View        index -= index & (-index)    return summ # Updates a node in Binary Index Tree (BITree) at given# index in BITree. The given value 'val' is added to# BITree[i] and all of its ancestors in tree.def updateBit(BITTree: list, n: int, index: int, val: int) -> None:     # index in BITree[] is 1 more than the index in arr[]    index = index + 1     # Traverse all ancestors and add 'val'    while index <= n:         # Add 'val' to current node of BI Tree        BITTree[index] += val         # Update index to that of parent in update View        index += index & (-index)  # Returns the sum of array from [0, x]def summation(x: int, BITTree1: list, BITTree2: list) -> int:    return (getSum(BITTree1, x) * x) - getSum(BITTree2, x)  def updateRange(BITTree1: list, BITTree2: list, n: int, val: int, l: int,                r: int) -> None:     # Update Both the Binary Index Trees    # As discussed in the article     # Update BIT1    updateBit(BITTree1, n, l, val)    updateBit(BITTree1, n, r + 1, -val)     # Update BIT2    updateBit(BITTree2, n, l, val * (l - 1))    updateBit(BITTree2, n, r + 1, -val * r) def rangeSum(l: int, r: int, BITTree1: list, BITTree2: list) -> int:     # Find sum from [0,r] then subtract sum    # from [0,l-1] in order to find sum from    # [l,r]    return summation(r, BITTree1, BITTree2) - summation(        l - 1, BITTree1, BITTree2) # Driver Codeif __name__ == "__main__":    n = 5     # BIT1 to get element at any index    # in the array    BITTree1 = [0] * (n + 1)     # BIT 2 maintains the extra term    # which needs to be subtracted    BITTree2 = [0] * (n + 1)     # Add 5 to all the elements from [0,4]    l = 0    r = 4    val = 5    updateRange(BITTree1, BITTree2, n, val, l, r)     # Add 2 to all the elements from [2,4]    l = 2    r = 4    val = 10    updateRange(BITTree1, BITTree2, n, val, l, r)     # Find sum of all the elements from    # [1,4]    l = 1    r = 4    print("Sum of elements from [%d,%d] is %d" %        (l, r, rangeSum(l, r, BITTree1, BITTree2))) # This code is contributed by# sanjeev2552
// C# program to demonstrate Range Update// and Range Queries using BITusing System; class GFG{ // Returns sum of arr[0..index]. This function assumes// that the array is preprocessed and partial sums of// array elements are stored in BITree[]static int getSum(int []BITree, int index){    int sum = 0; // Initialize result     // index in BITree[] is 1 more than    // the index in []arr    index = index + 1;     // Traverse ancestors of BITree[index]    while (index > 0)    {        // Add current element of BITree to sum        sum += BITree[index];         // Move index to parent node in getSum View        index -= index & (-index);    }    return sum;} // Updates a node in Binary Index Tree (BITree) at given// index in BITree. The given value 'val' is added to// BITree[i] and all of its ancestors in tree.static void updateBIT(int []BITree, int n,                      int index, int val){    // index in BITree[] is 1 more than    // the index in []arr    index = index + 1;     // Traverse all ancestors and add 'val'    while (index <= n)    {        // Add 'val' to current node of BI Tree        BITree[index] += val;         // Update index to that of        // parent in update View        index += index & (-index);    }} // Returns the sum of array from [0, x]static int sum(int x, int []BITTree1,                      int []BITTree2){    return (getSum(BITTree1, x) * x) -            getSum(BITTree2, x);}  static void updateRange(int []BITTree1,                        int []BITTree2, int n,                        int val, int l, int r){    // Update Both the Binary Index Trees    // As discussed in the article     // Update BIT1    updateBIT(BITTree1, n, l, val);    updateBIT(BITTree1, n, r + 1, -val);     // Update BIT2    updateBIT(BITTree2, n, l, val * (l - 1));    updateBIT(BITTree2, n, r + 1, -val * r);} static int rangeSum(int l, int r,                    int []BITTree1,                    int []BITTree2){    // Find sum from [0,r] then subtract sum    // from [0,l-1] in order to find sum from    // [l,r]    return sum(r, BITTree1, BITTree2) -           sum(l - 1, BITTree1, BITTree2);} static int[] constructBITree(int n){    // Create and initialize BITree[] as 0    int []BITree = new int[n + 1];    for (int i = 1; i <= n; i++)        BITree[i] = 0;     return BITree;} // Driver Codepublic static void Main(String[] args){    int n = 5;     // Contwo BIT    int []BITTree1;    int []BITTree2;     // BIT1 to get element at any index    // in the array    BITTree1 = constructBITree(n);     // BIT 2 maintains the extra term    // which needs to be subtracted    BITTree2 = constructBITree(n);     // Add 5 to all the elements from [0,4]    int l = 0 , r = 4 , val = 5;    updateRange(BITTree1, BITTree2, n, val, l, r);     // Add 2 to all the elements from [2,4]    l = 2 ; r = 4 ; val = 10;    updateRange(BITTree1, BITTree2, n, val, l, r);     // Find sum of all the elements from    // [1,4]    l = 1 ; r = 4;    Console.Write("Sum of elements from [" + l +                             "," + r + "] is ");    Console.Write(rangeSum(l, r, BITTree1,                                 BITTree2) + "\n");}} // This code is contributed by 29AjayKumar
<script> // JavaScript program to demonstrate Range Update// and Range Queries using BIT // Returns sum of arr[0..index]. This function assumes// that the array is preprocessed and partial sums of// array elements are stored in BITree[]function getSum(BITree,index){    let sum = 0; // Initialize result       // index in BITree[] is 1 more than the index in arr[]    index = index + 1;       // Traverse ancestors of BITree[index]    while (index > 0)    {        // Add current element of BITree to sum        sum += BITree[index];           // Move index to parent node in getSum View        index -= index & (-index);    }    return sum;} // Updates a node in Binary Index Tree (BITree) at given// index in BITree. The given value 'val' is added to// BITree[i] and all of its ancestors in tree.function updateBIT(BITree,n,index,val){    // index in BITree[] is 1 more than the index in arr[]    index = index + 1;       // Traverse all ancestors and add 'val'    while (index <= n)    {        // Add 'val' to current node of BI Tree        BITree[index] += val;           // Update index to that of parent in update View        index += index & (-index);    }} // Returns the sum of array from [0, x]function sum(x,BITTree1,BITTree2){    return (getSum(BITTree1, x) * x) - getSum(BITTree2, x);} function updateRange(BITTree1,BITTree2,n,val,l,r){    // Update Both the Binary Index Trees    // As discussed in the article       // Update BIT1    updateBIT(BITTree1, n, l, val);    updateBIT(BITTree1, n, r + 1, -val);       // Update BIT2    updateBIT(BITTree2, n, l, val * (l - 1));    updateBIT(BITTree2, n, r + 1, -val * r);} function rangeSum(l,r,BITTree1,BITTree2){    // Find sum from [0,r] then subtract sum    // from [0,l-1] in order to find sum from    // [l,r]    return sum(r, BITTree1, BITTree2) -        sum(l - 1, BITTree1, BITTree2);} function constructBITree(n){    // Create and initialize BITree[] as 0    let BITree = new Array(n + 1);    for (let i = 1; i <= n; i++)        BITree[i] = 0;       return BITree;} // Driver Program to test above functionlet n = 5;   // Contwo BITlet BITTree1;let BITTree2; // BIT1 to get element at any index// in the arrayBITTree1 = constructBITree(n); // BIT 2 maintains the extra term// which needs to be subtractedBITTree2 = constructBITree(n); // Add 5 to all the elements from [0,4]let l = 0 , r = 4 , val = 5;updateRange(BITTree1, BITTree2, n, val, l, r); // Add 2 to all the elements from [2,4]l = 2 ; r = 4 ; val = 10;updateRange(BITTree1, BITTree2, n, val, l, r); // Find sum of all the elements from// [1,4]l = 1 ; r = 4;document.write("Sum of elements from [" + l                 + "," + r+ "] is ");document.write(rangeSum(l, r, BITTree1, BITTree2)+ "<br>"); // This code is contributed by rag2127 </script>
Output:  
Sum of elements from [1,4] is 50
Time Complexity : O(q*log(n)) where q is number of queries.This article is contributed by Chirag Agarwal. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
nidhi_biet
29AjayKumar
sanjeev2552
rag2127
array-range-queries
Binary Indexed Tree
Advanced Data Structure
Technical Scripter
Binary Indexed Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Agents in Artificial Intelligence
Decision Tree Introduction with example
AVL Tree | Set 2 (Deletion)
Red-Black Tree | Set 2 (Insert)
Disjoint Set Data Structures
Insert Operation in B-Tree
How to design a tiny URL or URL shortener?
Design a Chess Game
Design a data structure that supports insert, delete, search and getRandom in constant time
Red-Black Tree | Set 3 (Delete)