Binary Indexed Tree Range Updates and Point Queries

Introduction:

In this article, we are going about the Range Updates and Point Queries of Binary Indexed Tree. But before that, we have to know what a binary index tree is.

We can say that a binary index tree is a type of data structure that helps us store the data in the form of an array. With the help of this, we can calculate the Sum of the prefix of the array element. In this data structure, we can represent all the positive numbers in the form of a Sum of power of 2.

Now, let's take an example and understand the range update and range queries.

Let's say we have an array that contains an N integer. By taking this array, we have to perform the operation below.

Update {x, L, R}:

In this section, we have to perform the update operation of the array element which have the index, and the range of the index starts from L to R. After that, we have to add an x element to each element whose index range starts from L to R. This operation is known as the Range update.

Query{L, R}:

In this section, we have to find the Sum of the index of the array element whose range starts from L to R. This is an example of a range query.

Now, we are going to perform the above two operations with the help of a binary-indexed tree. We have the array, which contains n number of elements. All the elements present in this array have the initial value of 0. Q represents the Number of queries.

Solution Approach

In this section, we are going to solve the update and range queries in the binary-indexed tree. We can solve the range sum query with the help of the Sum of the prefixes. Let's say we have to find the Sum of an array whose range starts from L to R. We can find this Sum by subtracting the prefix sum [0, L-1] from the prefix sum [0, R]. We can calculate the prefix by taking the help of binary indexed trees in O(log N) time.

Suppose there is a range update query whose range is from L to R, and we have to find the Sum of the prefix whose range is from 0 to M.

Case-1:

In this case, we have to find the Sum that may not affect the range by updating the range from L to R.

Case-2:

In this case, we have to increase the Sum of the range to (x*M - x*(L-1)). Then, we have to update the range from L to R.

Case-3:

In this case, we have to increase the Sum of the range to (x*R - x*(L-1)). Then, we have to update the range from L to R.

Algorithm-

To solve this problem, we have to follow the below steps. These are as follows.

Step-1:

First, we have to write the main function. Inside that main function, we have to create the variable that stores the array and the Number of elements present in that array. After that, we have to create two binary indexes, and then we have to initialize that variable to zero.

Step-2:

Now we have to call "rangeUpdateQuery()" and "rangeSumQuery()" functions based on the type of query.

Step-3

Then, we have to create the function rangeSumQuery() that accepts two parameters, such as binary indexes of the binary tree. This functions the Sum of the element of the array whose ranges from L to R. Inside that function, we have perform prefix sum [0, R] and [0, L-1] and subtract the prefix sum [0, L-1] from the prefix sum [0, R] to get the required Sum of the range [L, R].

Step-4

Then we have to create rangeUpdateQuery(), which updates both the binary indexed tree such that one binary indexed tree can be used to get the value at any index, and the other can be used to get the value of (x*(L-1)) after each update query.

Implementation in C++ code:

Code:

#include <bits/stdc++.h>
using namespace std;

// Updates a node in the Binary Index Tree (BITree) at a given index in BITree. Add 'x' to BIT[i] and all of its ancestors
void update(int BIT[], int n, int index, int val)
{
       int i = index + 1;
       // Traverse all ancestors and add 'val'
       while (i <= n)
       {
              BIT[i] += val;
              i += i & (-i);
       }
}

void rangeUpdateQuery(int BIT1[], int BIT2[], int n, int val, int l, int r)
{
       // Update BIT1
       update(BIT1,n,l,val);
       update(BIT1,n,r+1,-val);
      // Update BIT2
       update(BIT2,n,l,val*(l-1));
       update(BIT2,n,r+1,-val*r);
}

int getSum(int BIT[], int index)
{
       int sum = 0; 
       int i = index + 1;
       // Traverse ancestors of BITree[index]
       while (i > 0)
       {
              sum += BIT[i];
              i -= i & (-i);
       }
       return sum;
}

int rangeSumQuery(int BIT1[], int BIT2[], int l, int r)
{
       //Sum of elements in [0, r]
       int sum1 = (getSum(BIT1, r)*r) - getSum(BIT2, r);
       //Sum of elements in [0, l-1]
       int sum2 = (getSum(BIT1, l-1)*(l-1)) - getSum(BIT2, l-1);
       //Sum of elements in [l,r] = Sum of elements in [0,r] - Sum of elements in [0, l-1]
       return sum1-sum2;
}

// Main Function
int main()
{
       //Number of elements in the given array
       int n = 6;
       // Given array
       int arr[6] = {0, 0, 0, 0, 0, 0};
             // Construct a binary indexed tree to get an element at a given index in the array
       int *BIT1 = new int[n+1];
       //Initialize each element with zero
       for(int i=1; i<=n; i++)
       {
              BIT1[i] = 0;
       }
       // BIT 2 maintains the extra term, which needs to be subtracted
       int *BIT2 = new int[n+1];
       //Initialize each element with zero
       for(int i=1; i<=n; i++)
       {
              BIT2[i] = 0;
       }
       // First Query: Range Update Query: Add 5 to all the elements from [0,4]
       int l = 0 , r = 3 , val = 4;
       rangeUpdateQuery(BIT1,BIT2,n,val,l,r);
       // Second Query: Range Update Query: Add 2 to all the elements from [2,4]
       l = 1 , r = 4 , val = 6;
       rangeUpdateQuery(BIT1,BIT2,n,val,l,r);
       // Third Query: Range Query: Find the Sum of all the elements in the array from [1, 4]
       l = 0 , r = 5;
       int sum = rangeSumQuery(BIT1, BIT2, l, r);
       cout << "Sum of elements from [" << l << "," << r << "] is ";
       cout << sum << "\n";

       return 0;
}

Output:

Binary Indexed Tree Range Updates and Point Queries

Explanation:

In the above code, we have created two functions such as rangeUpdateQuery() and rangeSumQuery(), with the help of C++ code. This code helps us to solve the above-described problem.

Implementation in Java:

Code:

class javatpoint { 
static void update(int arr[], int l, int r, int val) 
{ 
               arr[l] += val;
               if(r + 1 < arr.length)
               arr[r+1] -= val; 
} 
static int getElement(int arr[], int i) 
{ 
               int res = 0; 
               for (int j = 0 ; j <= i; j++) 
                               res += arr[j]; 
               return res; 
} 
public static void main(String[] args) 
{ 
               int arr[] = {0, 0, 0, 0, 0}; 
               int n = arr.length; 
               int l = 2, r = 4, val = 2; 
               update(arr, l, r, val); 
               int index = 4; 
               System.out.println("Element at index " + index + " is " +getElement(arr, index)); 
               l = 0;
               r = 3;
               val = 4; 
               update(arr,l,r,val); 
               index = 3; 
               System.out.println("Element at index " + index + " is " +getElement(arr, index)); 

}
}

Output:

Explanation:

In the above code, we have implemented two methods in Java, such as update() and getElement(). With the help of these two methods, we can update the index of the array, and we can also fetch the element present in the updated index value.

Algorithm Complexity:

Time complexity:

The time complexity for above approach is O(Q * log(N))

Here, 'Q' and 'N' are the Number of queries and the Number of elements in the array.

Space complexity:

The time complexity of the above problem is O(N).

Here, 'N' is the total number of elements in the given array.

Next TopicBurn the binary tree starting from the target node

← prev next →