Segment Tree in Java

Segment Tree is also a binary tree, but it is used to solve specific problems with better time complexity. Similar to the heap, the segment tree in Java is also represented with the help of an array.

Scenario Where Segment Tree is Used

Let's understand in which scenario a segment tree comes in handy.

Suppose we have got an array a[] = {0, 1, …, n - 1}; and it is asked to perform two tasks on this array. The tasks are:

Compute the sum of the elements from index x to y, where 0 <= x <= y <= n - 1
Change the value of an element of the array a[] to the new value p, i.e., one is required to do a[j] = p, where 0 <= j <= n - 1.

Let's discuss various approaches to find the solution to the above-mentioned task.

Native Approach:

Completion of these tasks is easy. One can run a for-loop from index x to y and can compute the cumulative sum of elements lying between index x to y. If we analyze the time complexity of finding the sum, we get O(n) time.

Also, to update the value at the j^thindex, one can do a[j] = p, and this operation take O(1) time. So, the overall time complexity to perform both the task is O(n) + O(1) = O(n).

Another Approach:

The other approach is to create a prefix array in advance and then complete the above-mentioned tasks. After the creation of the prefix array, the sum of elements from index x to y takes O(1) time. However, the updation at the j^thindex will now take O(n) time. It is because the update of any index will be the prefix array, and the updation takes O(1) time. Thus, the overall time complexity turns out to be O(1) + O(n) = O(n), which is the same as the naive approach.

Since the overall time complexity remains the same in both approaches, we need to find a way to reduce its time complexity, and the way is the usage of a segment tree. The segment tree takes O(log(n)) time to compute the sum from index x to y. For updating the value at the j^th index, the segment tree takes O(log(n)) time. Thus, overall time complexity becomes O(log(n)) + O(log(n)) = O(2 *(log(n)), which is less than O(n).

Representation of a Segment Tree

The leaf nodes represent elements of the array.
Internal nodes of the tree are generated by merging their child nodes. Since we are using an array to represent a segment tree, a node sitting at index j has the left child at 2 * j + 1 and right child at 2 * j + 2, and the parent of the node at the index j is ⌊(j - 1) / 2⌋.

Thus, for the array a[] = {2, 4, 7, 10, 12, 13}, the representation of segment tree as an array will be:

segArr[] = {48, 13, 35, 6, 7, 22, 13, 2, 4, k, k, 10, 12, k, k};, where k is a dummy value. The dummy values are of no use. In fact, it is the wastage of some space because of the array representation.

The segment tree will be:

The red-coloured nodes (leaf nodes) represent the elements of the array, while the orange-coloured nodes are the result of merging their child nodes.

Size of the Array Used in Segment Tree Representation

If the size of the input array is of power 2, then there are no dummy nodes. Thus, the size of the segment tree is (2 * n - 1), where n is the size of the input array. It is because the total number of leaf nodes will be s, and internal nodes will be n - 1. Therefore, n + n - 1 = 2 * n - 1 is the total size of the array.

If the size of the input array is not of the power 2, then the size of the segment tree is 2 * y - 1, where y is the smallest power of 2 greater than n. For example, if the value of n is 9, then the smallest power of 2 greater than 9 is 16. So, y is 16.

Pseudo Code for the Given Range Sum

After the construction of the segment tree, the challenge is to compute the sum using the segment tree. The following pseudo-code tackles the issue.

int getSum(nde, x, y) 
{
   if (the range of the node is within x and y)
        return value of the node
   else if (the range of the node is outside of x and y)
        return 0
   else
    return getSum(nde left child, x, y) + 
           getSum(nde right child, x, y)
}

Updating a Value in Segment Tree

The update operation in a segment tree is done recursively. Suppose the j^thindex needs to be updated and the value is val. Starting from the root of the segment tree, add the value val to all those nodes whose range contains the given range. If the range of a given node does not contain a given index, then one should not make any changes to that node.

Implementation of the Segment Tree

The following program shows the implementation of the segment tree.

FileName: SegTree.java

// A Java Program that shows the segment tree operations like construction, query and 
// update
public class SegTree
{
int stArr[]; // The array that keeps the nodes of the segment tree
// Constructor to generate the segment tree from the given array. 
// The constructor allocates memory for the segment tree and invokes
// the method constructST() to fill the memory allocated
SegTree(int a[], int s)
{
// Allocate memory for segment tree
//Height of segment tree
int h = (int) (Math.ceil(Math.log(s) / Math.log(2)));
//Maximum size of segment tree
int maxSize = 2 * (int) Math.pow(2, h) - 1;
// for allocatiing the memory for the array 
// that represents the segment tree
stArr = new int[maxSize]; constructST(a, 0, s - 1, 0);
}
// A utility method to find the middle index from the corner indices.
int getMidIndex(int f, int l) 
{
return f + (l - f) / 2;
}
// A recursive method to find the sum of the values in the given range
// of the given array. The following are the parameters for the method.

// stArr --> The array representing the segment tree
// si --> Index of the current node in the segment tree. 
// Initially, 0 is passed as the root is always at the index 0
// x & y --> Start and end indices of the segment represented
//				by the current node, i.e., stArr[si]
// i & j --> Start and end indices of the query range
int getSumUtil(int x, int y, int i, int j, int si)
{
// If the segment of the node is the part of the given range, 
// then return the sum of the segment
if (i <= x && j >= y)
{
return stArr[si];
}
// If the segment of the node is outside of the given range
if (y < i || x > j)
{
return 0;
}

// If a part of the segment overlaps with the range given
int midVal = getMidIndex(x, y);
return getSumUtil(x, midVal, i, j, 2 * si + 1) +
	getSumUtil(midVal + 1, y, i, j, 2 * si + 2);
}
// A recursive method to update the nodes that have the given
// index in their range. The following are the parameters
//	si, x and y are same as the getSumUtil() method
//	j --> index of the element to be updated. The index is in
//	      the input array.
// val --> Value that has to be added to all of the nodes which have j in the range 
void updateValUtil(int x, int y, int j, int val, int si)
{
// Base Case: If the input index lies outside the range of
// this segment
if (j < x || j > y)
{
return;
}
// If the range of the node contains the input index, then update the
// value of the node and its children
stArr[si] = stArr[si] + val;
if (y != x) 
{
int midVal = getMidIndex(x, y);
updateValUtil(x, midVal, j, val, 2 * si + 1);
updateValUtil(midVal + 1, y, j, val, 2 * si + 2);
}
}
// The method is to update the value in the input array and the segment tree.
// It uses the updateValUtil() to update the value in the segment tree
void updateVal(int a[], int s, int j, int newVal)
{
// Check for erroneous input index
if (j < 0 || j > s - 1) 
{
System.out.println("Input is Invalid");
return;
}
// Get the difference between the old value and new value
int diffVal = newVal - a[j];
// Update the value in array
stArr[j] = newVal;
// Update the values of nodes in segment tree
updateValUtil(0, s - 1, j, diffVal, 0);
}
// Returning the sum of elements in the range from the index x (query start) to
// y (query end). It uses the method getSumUtil()
int getSum(int s, int x, int y)
{
// Checking for the absurd input values
if (x < 0 || x > s - 1 || x > y) 
{
System.out.println("The input is invalid");
return -1;
}
return getSumUtil(0, s - 1, x, y, 0);
}
// A recursive method that does the construction of the Segment Tree for the array 
// a[x ... y].
// si is the index of the current node in the segment tree stArr
int constructST(int a[], int x, int y, int si)
{
// If only one element is present in the array, store it 
// in the current node of the segment tree and then return
if (x == y) 
{
stArr[si] = a[x];
return a[x];
}
// If there are more than one element, then apply recurrence in the left and
// right subtrees and the store the sum of values in this node
int mid = getMidIndex(x, y);
stArr[si] = constructST(a, x, mid, si * 2 + 1) +
	constructST(a, mid + 1, y, si * 2 + 2);
return stArr[si];
}
// Main method
public static void main(String argvs[])
{
// input array
int a[] = {2, 4, 7, 10, 12, 13};
int size = a.length; // size of the input array
// Building the segment tree from the input array
SegTree tree = new SegTree(a, size);
// Printing the sum of values in the input array from index 1 to 4
System.out.println("Sum of values in the given range 1 to 4 = " + tree.getSum(size, 1, 4));
// Update: setting arr[3] = 11 and updating the corresponding segment
// of the tree nodes
tree.updateVal(a, size, 3, 11);
// Finding the sum after the value is getting updated
System.out.println("Updated sum of values in the given range = " + tree.getSum(size, 1, 4));
}
}

Output:

Sum of values in the given range 1 to 4 = 33
Updated sum of values in the given range = 34

Next TopicDTO Java

← prev next →

For Videos Join Our Youtube Channel: Join Now

Feedback

Send your Feedback to [email protected]

Help Others, Please Share

Learn Latest Tutorials

Splunk

SPSS

Swagger

Transact-SQL

Tumblr

ReactJS

Regex

Reinforcement Learning

R Programming

RxJS

React Native

Python Design Patterns

Python Pillow

Python Turtle

Keras

Preparation

Aptitude

Reasoning

Verbal Ability

Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

AWS

Selenium

Cloud Computing

Hadoop

ReactJS

Data Science

Angular 7

Blockchain

Git

Machine Learning

DevOps

B.Tech / MCA

DBMS

Data Structures

DAA

Operating System

Computer Network

Compiler Design

Computer Organization

Discrete Mathematics

Ethical Hacking

Computer Graphics

Software Engineering

Web Technology

Cyber Security

Automata

C Programming

C++

Java

.Net

Python

Programs

Control System

Data Mining

Data Warehouse

^{Like/Subscribe us for latest updates or newsletter}

Java Tutorial

Control Statements

Java Object Class

Java Inheritance

Java Polymorphism

Java Abstraction

Java Encapsulation

Java Array

Java OOPs Misc