# Queries for elements having values within the range A to B in the given index range using Segment Tree

• Difficulty Level : Hard
• Last Updated : 03 Jun, 2021

Given an array arr[] of N elements and two integers A to B, the task is to answer Q queries each having two integers L and R. For each query, the task is to find the number of elements in the subarray arr[L…R] which lies within the range A to B (both included).

Examples:

Input: arr[] = {7, 3, 9, 13, 5, 4}, A=4, B=7
query = { 1, 5 }
Output:
Explanation :
Only 5 and 4 lies within 4 to 7
in the subarray {3, 9, 13, 5, 4}.

Input: arr[] = {0, 1, 2, 3, 4, 5, 6, 7}, A=1, B=5
query = { 3, 5 }
Output:
Explanation :
All the elements 3, 4 and 5 lies within 1 to 5
in the subarray {3, 4, 5}.

Prerequisite: Segment tree
Naive approach: Find the answer for each query by simply traversing the array from index L till R and keep adding 1 to the count whenever the array element lies within the range A to B. Time Complexity of this approach will be O(n * q).

Efficient approach:
Build a Segment Tree.
Representation of Segment trees
1. Leaf Nodes are the elements of the input array.
2. Each internal node contains the number of leaves which lies within the range A to B of all leaves under it.

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 number of elements which lies within the range A to B of all nodes under it.
Time complexity of this approach will be O(q * log(n))

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Procedure to build the segment tree``void` `buildTree(vector<``int``>& tree, ``int``* arr,``               ``int` `index, ``int` `s, ``int` `e, ``int` `A, ``int` `B)``{` `    ``// Reached the leaf node``    ``// of the segment tree``    ``if` `(s == e) {``        ``if` `(arr[s] >= A && arr[s] <= B)``            ``tree[index] = 1;``        ``else``            ``tree[index] = 0;``        ``return``;``    ``}` `    ``// Recursively call the buildTree``    ``// on both the nodes of the tree``    ``int` `mid = (s + e) / 2;``    ``buildTree(tree, arr, 2 * index, s, mid, A, B);``    ``buildTree(tree, arr, 2 * index + 1, mid + 1, e, A, B);` `    ``tree[index] = tree[2 * index] + tree[2 * index + 1];``}` `// Query procedure to get the answer``// for each query l and r are query range``int` `query(vector<``int``> tree, ``int` `index, ``int` `s,``          ``int` `e, ``int` `l, ``int` `r)``{` `    ``// out of bound or no overlap``    ``if` `(r < s || l > e)``        ``return` `0;` `    ``// Complete overlap``    ``// Query range completely lies in``    ``// the segment tree node range``    ``if` `(s >= l && e <= r) {``        ``return` `tree[index];``    ``}` `    ``// Partially overlap``    ``// Query range partially lies in``    ``// the segment tree node range``    ``int` `mid = (s + e) / 2;``    ``return` `(query(tree, 2 * index, s, mid, l, r)``            ``+ query(tree, 2 * index + 1, mid + 1, e, l, r));``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 7, 3, 9, 13, 5, 4 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``vector<``int``> tree(4 * n + 1);` `    ``int` `L = 1, R = 5, A = 4, B = 7;` `    ``buildTree(tree, arr, 1, 0, n - 1, A, B);` `    ``cout << query(tree, 1, 0, n - 1, L, R)``         ``<< endl;``    ``return` `0;``}`

## Java

 `// Java implementation of the approach``class` `GFG{``    ` `// Procedure to build the segment tree``static` `void` `buildTree(``int` `tree[] , ``int` `arr[] ,``                      ``int` `index, ``int` `s, ``int` `e,``                      ``int` `A, ``int` `B)``{``    ` `    ``// Reached the leaf node``    ``// of the segment tree``    ``if` `(s == e)``    ``{``        ``if` `(arr[s] >= A && arr[s] <= B)``            ``tree[index] = ``1``;``        ``else``            ``tree[index] = ``0``;``            ` `        ``return``;``    ``}` `    ``// Recursively call the buildTree``    ``// on both the nodes of the tree``    ``int` `mid = (s + e) / ``2``;``    ``buildTree(tree, arr, ``2` `* index,``              ``s, mid, A, B);``    ``buildTree(tree, arr, ``2` `* index + ``1``,``              ``mid + ``1``, e, A, B);` `    ``tree[index] = tree[``2` `* index] +``                  ``tree[``2` `* index + ``1``];``}` `// Query procedure to get the answer``// for each query l and r are query range``static` `int` `query(``int` `tree[], ``int` `index, ``int` `s,``                 ``int` `e, ``int` `l, ``int` `r)``{``    ` `    ``// Out of bound or no overlap``    ``if` `(r < s || l > e)``        ``return` `0``;` `    ``// Complete overlap``    ``// Query range completely lies in``    ``// the segment tree node range``    ``if` `(s >= l && e <= r)``    ``{``        ``return` `tree[index];``    ``}` `    ``// Partially overlap``    ``// Query range partially lies in``    ``// the segment tree node range``    ``int` `mid = (s + e) / ``2``;``    ``return` `(query(tree, ``2` `* index,``                  ``s, mid, l, r) +``            ``query(tree, ``2` `* index + ``1``,``                  ``mid + ``1``, e, l, r));``}` `// Driver code``public` `static` `void` `main (String []args)``{``    ``int` `arr[] = { ``7``, ``3``, ``9``, ``13``, ``5``, ``4` `};``    ``int` `n = arr.length;``    ``int` `tree[] = ``new` `int` `[(``4` `* n + ``1``)];` `    ``int` `L = ``1``, R = ``5``, A = ``4``, B = ``7``;` `    ``buildTree(tree, arr, ``1``, ``0``, n - ``1``, A, B);` `    ``System.out.print(query(tree, ``1``, ``0``, n - ``1``, L, R));``}``}` `// This code is contributed by chitranayal`

## Python3

 `# Python3 implementation of the approach` `# Procedure to build the segment tree``def` `buildTree(tree,arr,index, s, e, A, B):` `    ``# Reached the leaf node``    ``# of the segment tree``    ``if` `(s ``=``=` `e):``        ``if` `(arr[s] >``=` `A ``and` `arr[s] <``=` `B):``            ``tree[index] ``=` `1``        ``else``:``            ``tree[index] ``=` `0``        ``return` `    ``# Recursively call the buildTree``    ``# on both the nodes of the tree``    ``mid ``=` `(s ``+` `e) ``/``/` `2``    ``buildTree(tree, arr, ``2` `*` `index, s, mid, A, B)``    ``buildTree(tree, arr, ``2` `*` `index ``+` `1``, mid ``+` `1``, e, A, B)` `    ``tree[index] ``=` `tree[``2` `*` `index] ``+` `tree[``2` `*` `index ``+` `1``]` `# Query procedure to get the answer``# for each query l and r are query range``def` `query(tree, index, s, e, l, r):` `    ``# out of bound or no overlap``    ``if` `(r < s ``or` `l > e):``        ``return` `0` `    ``# Complete overlap``    ``# Query range completely lies in``    ``# the segment tree node range``    ``if` `(s >``=` `l ``and` `e <``=` `r):``        ``return` `tree[index]` `    ``# Partially overlap``    ``# Query range partially lies in``    ``# the segment tree node range``    ``mid ``=` `(s ``+` `e) ``/``/` `2``    ``return` `(query(tree, ``2` `*` `index, s, mid, l, r)``            ``+` `query(tree, ``2` `*` `index ``+` `1``, mid ``+` `1``, e, l, r))` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``arr``=``[``7``, ``3``, ``9``, ``13``, ``5``, ``4``]``    ``n ``=` `len``(arr)``    ``tree``=``[``0``]``*``(``4` `*` `n ``+` `1``)` `    ``L ``=` `1``    ``R ``=` `5``    ``A ``=` `4``    ``B ``=` `7` `    ``buildTree(tree, arr, ``1``, ``0``, n ``-` `1``, A, B)` `    ``print``(query(tree, ``1``, ``0``, n ``-` `1``, L, R))` `# This code is contributed by mohit kumar 29`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG{``    ` `// Procedure to build the segment tree``static` `void` `buildTree(``int``[] tree, ``int``[] arr,``                      ``int` `index, ``int` `s, ``int` `e,``                      ``int` `A, ``int` `B)``{``    ` `    ``// Reached the leaf node``    ``// of the segment tree``    ``if` `(s == e)``    ``{``        ``if` `(arr[s] >= A && arr[s] <= B)``            ``tree[index] = 1;``        ``else``            ``tree[index] = 0;``            ` `        ``return``;``    ``}` `    ``// Recursively call the buildTree``    ``// on both the nodes of the tree``    ``int` `mid = (s + e) / 2;``    ``buildTree(tree, arr, 2 * index,``              ``s, mid, A, B);``    ``buildTree(tree, arr, 2 * index + 1,``              ``mid + 1, e, A, B);` `    ``tree[index] = tree[2 * index] +``                  ``tree[2 * index + 1];``}` `// Query procedure to get the answer``// for each query l and r are query range``static` `int` `query(``int``[] tree, ``int` `index, ``int` `s,``                 ``int` `e, ``int` `l, ``int` `r)``{``    ` `    ``// Out of bound or no overlap``    ``if` `(r < s || l > e)``        ``return` `0;` `    ``// Complete overlap``    ``// Query range completely lies in``    ``// the segment tree node range``    ``if` `(s >= l && e <= r)``    ``{``        ``return` `tree[index];``    ``}` `    ``// Partially overlap``    ``// Query range partially lies in``    ``// the segment tree node range``    ``int` `mid = (s + e) / 2;``    ``return` `(query(tree, 2 * index,``                  ``s, mid, l, r) +``            ``query(tree, 2 * index + 1,``                  ``mid + 1, e, l, r));``}` `// Driver code``public` `static` `void` `Main ()``{``    ``int``[] arr = ``new` `int``[] { 7, 3, 9, 13, 5, 4 };``    ``int` `n = arr.Length;``    ``int``[] tree = ``new` `int` `[(4 * n + 1)];` `    ``int` `L = 1, R = 5, A = 4, B = 7;` `    ``buildTree(tree, arr, 1, 0, n - 1, A, B);` `    ``Console.Write(query(tree, 1, 0, n - 1, L, R));``}``}` `// This code is contributed by sanjoy_62`

## Javascript

 ``

Output:

`2`

My Personal Notes arrow_drop_up