Skip to content

Segment Tree | Range Minimum Query

Segment Tree | Range Minimum Query

Last Updated : 11 Feb, 2025

Try it on GfG Practice

We have introduced a segment tree with a simple example in the previous post. In this post, the Range Minimum Query problem is discussed as another example where a Segment Tree can be used. The following is the problem statement:
We have an array arr[0 . . . n-1]. We should be able to efficiently find the minimum value from index q_s (query start) to q_e (query end) where 0 <= q_s <= q_e <= n-1.

A simple solution is to run a loop from q_s to q_e and find the minimum element in the given range. This solution takes O(n) time in the worst case.
Another solution is to create a 2D array where an entry [i, j] stores the minimum value in range arr[i..j]. The minimum of a given range can now be calculated in O(1) time, but preprocessing takes O(n²) time. Also, this approach needs O(n²) extra space which may become huge for large input arrays.
Segment tree can be used to do preprocessing and query in moderate time. With a segment tree, preprocessing time is O(n) and the time complexity for a range minimum query is O(log n). The extra space required is O(n) to store the segment tree.

Representation of Segment trees

1. Leaf Nodes are the elements of the input array.
2. Each internal node represents minimum of all leaves under it.
An array representation of tree is used to represent Segment Trees. For each node at index i, the left child is at index (2 * i + 1), right child at (2 * i + 2) and the parent is at (i - 1) / 2

Construction of Segment Tree from given array

We start with a segment arr[0 . . . n-1]. and every time we divide the current segment into two halves (if it has not yet become a segment of length 1), and then call the same procedure on both halves, and for each such segment, we store the minimum value in a segment tree node.

All levels of the constructed segment tree will be completely filled except the last level. Also, the tree will be a Full Binary Tree because we always divide segments in two halves at every level. Since the constructed tree is always full binary tree with n leaves, there will be n - 1 internal nodes. So total number of nodes will be 2 * n - 1.
Height of the segment tree will be ?log?n?. Since the tree is represented using array and relation between parent and child indexes must be maintained, size of memory allocated for segment tree will be 2 * 2^?log₂^n? - 1.

Query for minimum value of given range

Once the tree is constructed, how to do range minimum query using the constructed segment tree. Following is algorithm to get the minimum.
// q_s--> query start index, q_e --> query end index
int RMQ(node, q_s, q_e) {
if range of node is within q_sand q_e
return value in node
else if range of node is completely outside q_sand q_e
return INFINITE
else
return min ( RMQ(node's left child, q_s, q_e), RMQ (node's right child, q_s, q_e) )
}

C++

// C++ program for range minimum // query using segment tree  #include <bits/stdc++.h> using namespace std;  // A utility function to get minimum of two numbers  int minVal(int x, int y) {      return (x < y)? x: y;  }   // A utility function to get the  // middle index from corner indexes.  int getMid(int s, int e) {      return s + (e -s)/2;  }   // A recursive function to get the // minimum value in a given range of array // st --> Pointer to segment tree  // index --> Index of current node in the tree // ss & se --> Starting and ending indexes  // qs & qe --> Starting and ending indexes of query range int RMQUtil(vector<int> &st, int ss, int se, int qs,                                  int qe, int index) {       // If segment of this node is a part of given range     // then return the min of the segment     if (qs <= ss && qe >= se)          return st[index];       // If segment of this node if outside the range     if (se < qs || ss > qe)          return INT_MAX;       // If a part of this segment     // overlaps with the given range      int mid = getMid(ss, se);      return minVal(RMQUtil(st, ss, mid, qs, qe, 2*index+1),                  RMQUtil(st, mid+1, se, qs, qe, 2*index+2));  }   // Return minimum of elements in range // from index qs to qe int RMQ(vector<int> &st, int n, int qs, int qe) {       // Check for invalid input     if (qs < 0 || qe > n-1 || qs > qe) {          cout<<"Invalid Input";          return -1;      }      return RMQUtil(st, 0, n-1, qs, qe, 0);  }   // A recursive function that constructs // Segment Tree for array[ss..se].  int constructSTUtil(vector<int> &arr, int ss, int se,                             vector<int> &st, int si) {      // If there is one element in array,     // store it in current node of      // segment tree and return      if (ss == se) {          st[si] = arr[ss];          return arr[ss];      }       // If there are more than one elements,      // then recur for left and right subtrees      // and store the minimum of two values in this node      int mid = getMid(ss, se);      st[si] = minVal(constructSTUtil(arr, ss, mid, st, si*2+1),                      constructSTUtil(arr, mid+1, se, st, si*2+2));      return st[si];  }   // Function to construct segment tree  vector<int> constructST(vector<int> &arr, int n) {       //Height of segment tree      int x = (int)(ceil(log2(n)));       // Maximum size of segment tree      int max_size = 2*(int)pow(2, x) - 1;       vector<int> st(max_size);      // Fill the allocated memory st      constructSTUtil(arr, 0, n-1, st, 0);       // Return the constructed segment tree      return st;  }   int main() {       vector<int> arr = {1, 3, 2, 7, 9, 11};      int n = arr.size();      // Build segment tree from given array      vector<int> st = constructST(arr, n);       // Starting index of query range      int qs = 1;           // Ending index of query range      int qe = 5;       // Print minimum value in arr[qs..qe]      cout<<"Minimum of values in range ["<<qs<<", "<<qe<<"] "<<     "is = "<<RMQ(st, n, qs, qe)<<endl;       return 0;  }

C

// C program for range minimum query  // using segment tree #include <stdio.h> #include <math.h> #include <limits.h> #include <stdlib.h>  // A utility function to get minimum of two numbers  int minVal(int x, int y) {      return (x < y)? x: y;  }   // A utility function to get the  // middle index from corner indexes.  int getMid(int s, int e) {      return s + (e -s)/2;  }   // A recursive function to get the // minimum value in a given range of array // st --> Pointer to segment tree  // index --> Index of current node in the tree // ss & se --> Starting and ending indexes  // qs & qe --> Starting and ending indexes of query range int RMQUtil(int *st, int ss, int se,              int qs, int qe, int index) {      // If segment of this node is a part of given range     // then return the min of the segment     if (qs <= ss && qe >= se)          return st[index];       // If segment of this node if outside the range     if (se < qs || ss > qe)          return INT_MAX;       // If a part of this segment     // overlaps with the given range      int mid = getMid(ss, se);      return minVal(RMQUtil(st, ss, mid, qs, qe, 2*index+1),                  RMQUtil(st, mid+1, se, qs, qe, 2*index+2)); }  // Return minimum of elements in range // from index qs to qe int RMQ(int *st, int n, int qs, int qe) {      // Check for erroneous input values     if (qs < 0 || qe > n-1 || qs > qe) {         printf("Invalid Input");         return -1;     }      return RMQUtil(st, 0, n-1, qs, qe, 0); }  // A recursive function that constructs // Segment Tree for array[ss..se].  int constructSTUtil(int arr[], int ss, int se,                              int *st, int si) {      // If there is one element in array,     // store it in current node of      // segment tree and return      if (ss == se) {          st[si] = arr[ss];          return arr[ss];      }       // If there are more than one elements,      // then recur for left and right subtrees      // and store the minimum of two values in this node      int mid = getMid(ss, se);      st[si] = minVal(constructSTUtil(arr, ss, mid, st, si*2+1),                      constructSTUtil(arr, mid+1, se, st, si*2+2));      return st[si];  }  // Function to construct segment tree int *constructST(int arr[], int n) {      //Height of segment tree     int x = (int)(ceil(log2(n)));       // Maximum size of segment tree     int max_size = 2*(int)pow(2, x) - 1;       int *st = (int*)malloc(max_size * sizeof(int));      // Fill the allocated memory st     constructSTUtil(arr, 0, n-1, st, 0);      // Return the constructed segment tree     return st; }  int main() {     int arr[] = {1, 3, 2, 7, 9, 11};     int n = sizeof(arr)/sizeof(arr[0]);      // Build segment tree from given array     int *st = constructST(arr, n);      // Starting index of query range     int qs = 1;        // Ending index of query range     int qe = 5;        // Print minimum value in arr[qs..qe]     printf("Minimum of values in range [%d, %d] is = %d\n",                            qs, qe, RMQ(st, n, qs, qe));      return 0; }

Java

// Java program for range minimum  // query using segment tree  import java.util.*;  class GFG {      // A utility function to get minimum of two numbers     static int minVal(int x, int y) {         return (x < y) ? x : y;     }      // A utility function to get the      // middle index from corner indexes.     static int getMid(int s, int e) {         return s + (e - s) / 2;     }      // A recursive function to get the     // minimum value in a given range of array     static int RMQUtil(int[] st, int ss, int se,                          int qs, int qe, int index) {          // If segment of this node is a part of given range         // then return the min of the segment         if (qs <= ss && qe >= se)             return st[index];          // If segment of this node is outside the range         if (se < qs || ss > qe)             return Integer.MAX_VALUE;          // If a part of this segment         // overlaps with the given range         int mid = getMid(ss, se);         return minVal(RMQUtil(st, ss, mid, qs, qe, 2 * index + 1),                       RMQUtil(st, mid + 1, se, qs, qe, 2 * index + 2));     }      // Return minimum of elements in range     // from index qs to qe     static int RMQ(int[] st, int n, int qs, int qe) {          // Check for invalid input         if (qs < 0 || qe > n - 1 || qs > qe) {             System.out.println("Invalid Input");             return -1;         }         return RMQUtil(st, 0, n - 1, qs, qe, 0);     }      // A recursive function that constructs     // Segment Tree for array[ss..se].      static int constructSTUtil(int[] arr, int ss,                          int se, int[] st, int si) {          // If there is one element in array,         // store it in current node of          // segment tree and return          if (ss == se) {             st[si] = arr[ss];             return arr[ss];         }          // If there are more than one elements,          // then recur for left and right subtrees          // and store the minimum of two values in this node          int mid = getMid(ss, se);         st[si] = minVal(constructSTUtil(arr, ss, mid, st, si * 2 + 1),                         constructSTUtil(arr, mid + 1, se, st, si * 2 + 2));         return st[si];     }      // Function to construct segment tree     static int[] constructST(int[] arr, int n) {          // Height of segment tree         int x = (int) (Math.ceil(Math.log(n) / Math.log(2)));          // Maximum size of segment tree         int max_size = 2 * (int) Math.pow(2, x) - 1;          int[] st = new int[max_size];          // Fill the allocated memory st         constructSTUtil(arr, 0, n - 1, st, 0);          // Return the constructed segment tree         return st;     }      public static void main(String[] args) {          int[] arr = {1, 3, 2, 7, 9, 11};         int n = arr.length;          // Build segment tree from given array         int[] st = constructST(arr, n);          // Starting index of query range         int qs = 1;          // Ending index of query range         int qe = 5;          // Print minimum value in arr[qs..qe]         System.out.println("Minimum of values in range [" + qs + ", " + qe + "] " +                            "is = " + RMQ(st, n, qs, qe));     } }

Python

# A utility function to get minimum of two numbers def minVal(x, y):     return x if x < y else y  # A utility function to get the  # middle index from corner indexes. def getMid(s, e):     return s + (e - s) // 2  # A recursive function to get the # minimum value in a given range of array def RMQUtil(st, ss, se, qs, qe, index):      # If segment of this node is a part of given range     # then return the min of the segment     if qs <= ss and qe >= se:         return st[index]      # If segment of this node is outside the range     if se < qs or ss > qe:         return float('inf')      # If a part of this segment     # overlaps with the given range     mid = getMid(ss, se)     return minVal(RMQUtil(st, ss, mid, qs, qe, 2 * index + 1),                   RMQUtil(st, mid + 1, se, qs, qe, 2 * index + 2))  # Return minimum of elements in range # from index qs to qe def RMQ(st, n, qs, qe):      # Check for invalid input     if qs < 0 or qe > n - 1 or qs > qe:         print("Invalid Input")         return -1     return RMQUtil(st, 0, n - 1, qs, qe, 0)  # A recursive function that constructs # Segment Tree for array[ss..se].  def constructSTUtil(arr, ss, se, st, si):      # If there is one element in array,     # store it in current node of      # segment tree and return      if ss == se:         st[si] = arr[ss]         return arr[ss]      # If there are more than one elements,      # then recur for left and right subtrees      # and store the minimum of two values in this node      mid = getMid(ss, se)     st[si] = minVal(constructSTUtil(arr, ss, mid, st, si * 2 + 1),                     constructSTUtil(arr, mid + 1, se, st, si * 2 + 2))     return st[si]  # Function to construct segment tree def constructST(arr, n):      # Height of segment tree     x = (n - 1).bit_length()      # Maximum size of segment tree     max_size = 2 * (2**x) - 1      st = [0] * max_size      # Fill the allocated memory st     constructSTUtil(arr, 0, n - 1, st, 0)      # Return the constructed segment tree     return st  if __name__ == "__main__" :      arr = [1, 3, 2, 7, 9, 11]     n = len(arr)      # Build segment tree from given array     st = constructST(arr, n)      # Starting index of query range     qs = 1      # Ending index of query range     qe = 5      # Print minimum value in arr[qs..qe]     print(f"Minimum of values in range [{qs}, {qe}] is = {RMQ(st, n, qs, qe)}")

C#

// C# program for range minimum  // query using segment tree using System; using System.Collections.Generic;  class GFG {          // A utility function to get minimum of two numbers     static int minVal(int x, int y) {         return (x < y) ? x : y;     }      // A utility function to get the      // middle index from corner indexes.     static int getMid(int s, int e) {         return s + (e - s) / 2;     }      // A recursive function to get the     // minimum value in a given range of array     static int RMQUtil(int[] st, int ss, int se,                          int qs, int qe, int index) {                                      // If segment of this node is a part of given range         // then return the min of the segment         if (qs <= ss && qe >= se)             return st[index];          // If segment of this node is outside the range         if (se < qs || ss > qe)             return int.MaxValue;          // If a part of this segment         // overlaps with the given range         int mid = getMid(ss, se);         return minVal(RMQUtil(st, ss, mid, qs, qe, 2 * index + 1),                       RMQUtil(st, mid + 1, se, qs, qe, 2 * index + 2));     }      // Return minimum of elements in range     // from index qs to qe     static int RMQ(int[] st, int n, int qs, int qe) {                  // Check for invalid input         if (qs < 0 || qe > n - 1 || qs > qe) {             Console.WriteLine("Invalid Input");             return -1;         }         return RMQUtil(st, 0, n - 1, qs, qe, 0);     }      // A recursive function that constructs     // Segment Tree for array[ss..se].      static int constructSTUtil(int[] arr, int ss,                          int se, int[] st, int si) {                                      // If there is one element in array,         // store it in current node of          // segment tree and return          if (ss == se) {             st[si] = arr[ss];             return arr[ss];         }          // If there are more than one elements,          // then recur for left and right subtrees          // and store the minimum of two values in this node          int mid = getMid(ss, se);         st[si] = minVal(constructSTUtil(arr, ss, mid, st, si * 2 + 1),                         constructSTUtil(arr, mid + 1, se, st, si * 2 + 2));         return st[si];     }      // Function to construct segment tree     static int[] constructST(int[] arr, int n) {                  // Height of segment tree         int x = (int)Math.Ceiling(Math.Log(n) / Math.Log(2));          // Maximum size of segment tree         int max_size = 2 * (int)Math.Pow(2, x) - 1;          int[] st = new int[max_size];          // Fill the allocated memory st         constructSTUtil(arr, 0, n - 1, st, 0);          // Return the constructed segment tree         return st;     }      static void Main() {         int[] arr = {1, 3, 2, 7, 9, 11};         int n = arr.Length;          // Build segment tree from given array         int[] st = constructST(arr, n);          // Starting index of query range         int qs = 1;          // Ending index of query range         int qe = 5;          // Print minimum value in arr[qs..qe]         Console.WriteLine("Minimum of values in range [" + qs + ", " + qe + "] " +                           "is = " + RMQ(st, n, qs, qe));     } }

JavaScript

// A utility function to get minimum of two numbers function minVal(x, y) {     return (x < y) ? x : y; }  // A utility function to get the  // middle index from corner indexes. function getMid(s, e) {     return s + Math.floor((e - s) / 2); }  // A recursive function to get the // minimum value in a given range of array function RMQUtil(st, ss, se, qs, qe, index) {      // If segment of this node is a part of given range     // then return the min of the segment     if (qs <= ss && qe >= se)         return st[index];      // If segment of this node is outside the range     if (se < qs || ss > qe)         return Number.MAX_SAFE_INTEGER;      // If a part of this segment     // overlaps with the given range     let mid = getMid(ss, se);     return minVal(RMQUtil(st, ss, mid, qs, qe, 2 * index + 1),                   RMQUtil(st, mid + 1, se, qs, qe, 2 * index + 2)); }  // Return minimum of elements in range // from index qs to qe function RMQ(st, n, qs, qe) {      // Check for invalid input     if (qs < 0 || qe > n - 1 || qs > qe) {         console.log("Invalid Input");         return -1;     }     return RMQUtil(st, 0, n - 1, qs, qe, 0); }  // A recursive function that constructs // Segment Tree for array[ss..se].  function constructSTUtil(arr, ss, se, st, si) {      // If there is one element in array,     // store it in current node of      // segment tree and return      if (ss === se) {         st[si] = arr[ss];         return arr[ss];     }      // If there are more than one elements,      // then recur for left and right subtrees      // and store the minimum of two values in this node      let mid = getMid(ss, se);     st[si] = minVal(constructSTUtil(arr, ss, mid, st, si * 2 + 1),                     constructSTUtil(arr, mid + 1, se, st, si * 2 + 2));     return st[si]; }  // Function to construct segment tree function constructST(arr, n) {      // Height of segment tree     let x = Math.ceil(Math.log2(n));      // Maximum size of segment tree     let max_size = 2 * Math.pow(2, x) - 1;      let st = new Array(max_size).fill(0);      // Fill the allocated memory st     constructSTUtil(arr, 0, n - 1, st, 0);      // Return the constructed segment tree     return st; }  // Main function function main() {     let arr = [1, 3, 2, 7, 9, 11];     let n = arr.length;      // Build segment tree from given array     let st = constructST(arr, n);      // Starting index of query range     let qs = 1;      // Ending index of query range     let qe = 5;      // Print minimum value in arr[qs..qe]     console.log(`Minimum of values in range [${qs}, ${qe}] is = ${RMQ(st, n, qs, qe)}`); }  main();

Output:

 Minimum of values in range [1, 5] is = 2

Time Complexity:

Tree Construction: Time Complexity for tree construction is O(n). There are total 2n-1 nodes, and value of every node is calculated only once in tree construction.
Query: Time complexity for each query is O(log n). To query a range minimum, we process at most two nodes at every level and number of levels is O(log n).

Auxiliary Space: O(n), since n extra space has been taken.

Further read
https://www.geeksforgeeks.org/range-minimum-query-for-static-array/

Segment Tree | Range Minimum Query

K

kartik

Improve

Article Tags :

Practice Tags :

Similar Reads

Segment Tree is a 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. The tree

Segment tree meaning in DSA

A segment tree is a data structure used to effectively query and update ranges of array members. It's typically implemented as a binary tree, with each node representing a segment or range of array elements. Segment tree Characteristics of Segment Tree:A segment tree is a binary tree with a leaf nod

Introduction to Segment Trees - Data Structure and Algorithm Tutorials

A Segment Tree is used to store information about array intervals in its nodes.It allows efficient range queries over array intervals.Along with queries, it allows efficient updates of array items.For example, we can perform a range summation of an array between the range L to R in O(Log n) while al

Persistent Segment Tree | Set 1 (Introduction)

Prerequisite : Segment Tree Persistency in Data Structure Segment Tree is itself a great data structure that comes into play in many cases. In this post we will introduce the concept of Persistency in this data structure. Persistency, simply means to retain the changes. But obviously, retaining the

Segment tree | Efficient implementation

Let us consider the following problem to understand Segment Trees without recursion.We have an array arr[0 . . . n-1]. We should be able to, Find the sum of elements from index l to r where 0 <= l <= r <= n-1Change the value of a specified element of the array to a new value x. We need to d

Iterative Segment Tree (Range Maximum Query with Node Update)

Given an array arr[0 . . . n-1]. The task is to perform the following operation: Find the maximum of elements from index l to r where 0 <= l <= r <= n-1.Change value of a specified element of the array to a new value x. Given i and x, change A[i] to x, 0 <= i <= n-1. Examples: Input:

Range Sum and Update in Array : Segment Tree using Stack

Given an array arr[] of N integers. The task is to do the following operations: Add a value X to all the element from index A to B where 0 ? A ? B ? N-1.Find the sum of the element from index L to R where 0 ? L ? R ? N-1 before and after the update given to the array above.Example: Input: arr[] = {1

Dynamic Segment Trees : Online Queries for Range Sum with Point Updates

Prerequisites: Segment TreeGiven a number N which represents the size of the array initialized to 0 and Q queries to process where there are two types of queries: 1 P V: Put the value V at position P.2 L R: Output the sum of values from L to R. The task is to answer these queries. Constraints: 1 ? N

Applications, Advantages and Disadvantages of Segment Tree

First, let us understand why we need it prior to landing on the introduction so as to get why this concept was introduced. Suppose we are given an array and we need to find out the subarray Purpose of Segment Trees: A segment tree is a data structure that deals with a range of queries over an array.