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

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:2

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:3

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:

## CPP

`// C++ implementation of the approach ` `#include <bits/stdc++.h> ` `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[0]); ` ` ` `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; ` `} ` |

*chevron_right*

*filter_none*

## 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 ` |

*chevron_right*

*filter_none*

**Output:**

2

## Recommended Posts:

- Queries for elements greater than K in the given index range using Segment Tree
- Queries for greatest pair sum in the given index range using Segment Tree
- Queries for the count of even digit sum elements in the given range using Segment Tree.
- Queries for elements having values within the range A to B using MO's Algorithm
- Queries for counts of array elements with values in given range
- Count of elements having odd number of divisors in index range [L, R] for Q queries
- Binary Indexed Tree : Range Update and Range Queries
- Range Queries to count elements lying in a given Range : MO's Algorithm
- Number of elements greater than K in the range L to R using Fenwick Tree (Offline queries)
- Two equal sum segment range queries
- Dynamic Segment Trees : Online Queries for Range Sum with Point Updates
- Segment Tree | Set 3 (XOR of given range)
- Segment Tree | (XOR of a given range )
- Segment Tree | Set 1 (Sum of given range)
- Queries for bitwise OR in the index range [L, R] of the given array
- Queries to update a given index and find gcd in range
- Queries for bitwise AND in the index range [L, R] of the given array
- Segment Tree | Set 2 (Range Minimum Query)
- Range Sum and Update in Array : Segment Tree using Stack
- Iterative Segment Tree (Range Minimum Query)

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.