Segment Tree in C

A Segment Tree is a data structure in C that helps us quickly perform operations (like finding the sum, minimum, or maximum) on a range of elements in an array. It’s like a tree that stores information about parts of the array in each node.

In this article, we will learn what are segement trees, how they work and how to implement them in C language.

Segment Trees in C

A Segment Tree is a data structure that stores information about a range of elements in its nodes. It is mostly used to handle range queries with updates in an efficient manner. For example, we can perform a range summation of an array between the range L to R while also modifying the array from range L to R all in log (N) time complexity

The tree is built recursively by dividing the array into segments until each segment represents a single element. This structure enables fast query and update operations with a time complexity of O (log n), making it a powerful tool in algorithm design and optimization.

Basic Operations on Segement Trees in C

The basic processes provided by segment trees can be outlined as the construction, query, and update.

Implementation of Basic Operations

Algorithm of Build Segement Tree

Build_Segment_Tree(arr, tree, start, end, treeNode):
 If start == end:
 tree[treeNode] = arr[start]
 Return
 mid = (start + end) / 2
 Build_Segment_Tree(arr, tree, start, mid, 2*treeNode)
 Build_Segment_Tree(arr, tree, mid+1, end, 2*treeNode+1)
 tree[treeNode] = tree[2*treeNode] + tree[2*treeNode+1]

Algorithm of Update

Update_Segment_Tree(arr, tree, start, end, treeNode, idx, value):
 If start == end:
 arr[idx] = value
 tree[treeNode] = value
 Return
 mid = (start + end) / 2
 If idx > mid:
 Update_Segment_Tree(arr, tree, mid+1, end, 2*treeNode+1, idx, value)
 Else:
 Update_Segment_Tree(arr, tree, start, mid, 2*treeNode, idx, value)
 tree[treeNode] = tree[2*treeNode] + tree[2*treeNode+1]

Algorithm of Query

Query_Segment_Tree(tree, start, end, treeNode, left, right):
 If start > right or end < left: // No overlap
 Return 0
 If start >= left and end <= right: // Complete overlap
 Return tree[treeNode]
 mid = (start + end) / 2 // Partial overlap
 ans1 = Query_Segment_Tree(tree, start, mid, 2*treeNode, left, right)
 ans2 = Query_Segment_Tree(tree, mid+1, end, 2*treeNode+1, left, right)
 Return ans1 + ans2

In the above:

• arr is the input array.
• tree is the segment tree.
• start and end are the start and end indices of the segment of the input array that the current node of the segment tree represents.
• treeNode is the index of the current node in the segment tree.
• idx is the index of the element to be updated in the input array.
• value is the new value to be updated.
• left and right are the range of the query.

C Program to Implement Segment Tree

Sum of elements in range [1, 3] is 15
Sum of elements in range [1, 3] after update is 20

Applications of Segment Trees

1. Segment Trees are used to answer range queries like finding the minimum, maximum, sum, greatest common divisor, least common multiple, etc., in an array in logarithmic time.
2. Segment Trees can handle updates and modifications in the data structure.
3. Segment Trees can be used with a technique called Lazy Propagation to perform range updates in logarithmic time.
4. Segment Trees are used to solve the Range Minimum Query problem, which aims to find the minimum element from a range in an array.
5. Segment Trees can also solve the Range Maximum Query problem, which aims to find the maximum element from a range in an array.
6. Segment Trees can be used to find the count of distinct elements in a range.
7. Segment Trees can be used to find the K-th number in a sequence.

Conclusion

In summary, a Segment Tree is a versatile data structure that allows efficient querying and updating of intervals or segments of an array. It is particularly useful for problems involving range queries, such as finding the sum, minimum, maximum, or any other operation over a specific range of elements in an array.