Segment trees

Segment trees are also called statistical trees in computer science. They are a type of tree data structure. Segment trees are used to store information regarding segments and intervals. The stored segments contain a particular point, and segment trees allow the querying about it. Segment trees are static structures in principle. This means that the structure of a segment tree cannot be modified once it is built. The interval tree is similar to the segment tree.

In computational geometry, segment trees are a part of tree data structure, and Bentley proposed this well-known technique in 1977. Segment trees are similar to binary trees, and the information related to the segments of linear data structures, such as arrays, linked lists, etc., are stored in the nodes of the segment trees.

The questions related to range queries, including updates, can be solved using segment trees. These segment trees can enable the execution of range queries or intervals in logarithmic time. They can also be used to process n number of such questions. A dynamic structure can also be made from this method.

We can use segment trees in many ways, including modifying elements in a given array and other multiple-range queries on arrays. For example, we can solve the following problems with the help of the versatile data structure – the segment trees:

In a given array, the sum of all the elements from indices 'x' to 'y' can be found using segment trees.
We can find the minimum of all elements between 'x' and 'y' using segment trees in a given array. This is popularly known as the 'Range minimum query problem'.

Segment tree definition

A segment tree is a type of binary tree. It generally stores segments and intervals, representing every interval as a node in a given segment tree.

For a given segment tree represented by 'T', let 'A' be an array and 'N' be the array 'A' size. Then:

The whole array A[0: N – 1] is represented by the root of the segment tree T.
Each element A[i] from 0 < i < N is represented in each leaf node of the respective segment tree T.
The union of elementary intervals A[i : j] where 0 <= i < j < N, are represented in the internal nodes of the T (Segment tree).

The whole array A[0: N – 1] is represented by the root of the segment tree T. Then, the root node is broken down into two equal segments or intervals. Both the child nodes of the root node of the segment tree T are represented by the following formulae: (A[0 : ((N – 1)/2)] and A[(((N – 1)/2) + 1) : (N – 1)]). Further, each node is divided into two equal child nodes until the leaf nodes are reached. Therefore, the segment tree's height is given as (log₂N). All the N elements of array A are represented in the N leaf nodes of the segment tree. The count of the number of internal nodes is given by (N – 1). Hence, the total number of nodes in a segment tree is (2 * (N – 1)).

Segment trees are static structures in principle, meaning that a segment tree's structure cannot be modified once built. Though the structure of a segment tree cannot be changed, we can alter or update the values in the nodes of the segment tree. The following operations can be performed to alter or update the values in the nodes of the segment tree:

Update: Using this operation, the elements in array A are updated, and the respective change is reflected in the segment tree T.

Query: Using this operation, a segment or interval can be queried, and the answer to the given problem is returned. These questions may include finding either the maximum or minimum or summation in a chosen segment of the segment tree T.

Implementation of segment trees

We can represent a segment tree using a simple linear array as a binary tree. We should first figure out what a node in the segment tree should store before actually building the segment tree. For example, if we need to find the sum of all the elements from indices 'x' to 'y' in a given array, then we can choose to store the sum of the child nodes in each segment tree node (excluding the leaf nodes).

We can use the bottom-up approach or recursion to build a segment tree. As the name suggests (bottom-up approach), we start from the bottom, i.e., the leaf nodes of the segment tree, and go up until we reach the top end, i.e., the root node of the segment tree. In this process, we update the respective changes to the nodes that fall in the paths of the leaf nodes and the root node.

A single element is represented in each leaf node. In each step of this bottom-up approach, the data present in two selected child nodes is computed according to the problem to be solved and are calculated to form the internal parent node. This means that each internal parent node represents the combination of both child nodes. This combination may differ in different segment trees based on the various questions. Hence, the bottom-up approach ends at the root node, representing the whole array.

Using the Update(), the elements in the array A are updated, and the respective change is reflected in the segment tree T. First, the leaf node that needs to be operated by the update operation is found. It is updated, and then the bottom-up approach is applied, updating all the nodes that fall in the path of the selected leaf node and root node (including the root node).

Using the Query() operation, the elements in the array A are updated, and the respective change is reflected in the segment tree T. First, the leaf node that needs to be operated by the query operation is found. It is computed based on the query asked, and then the bottom-up approach is applied, calculating the question on all the nodes that fall in the path of the selected leaf node and root node (including the root node).