Range query (computer science)

For finding items that fall within a range, see range query (database).

In data structures, a range query consists of preprocessing some input data into a data structure to efficiently answer any number of queries on any subset of the input. Particularly, there is a group of problems that have been extensively studied where the input is an array of unsorted numbers and a query consists of computing some function, such as the minimum, on a specific range of the array.

Definition

A range query $q_{f}(A,i,j)$ on an array $A=[a_{1},a_{2},..,a_{n}]$ of n elements of some set S, denoted $A[1,n]$, takes two indices $1\leq i\leq j\leq n$, a function f defined over arrays of elements of S and outputs $f(A[i,j])=f(a_{i},\ldots ,a_{j})$.

For example, for $f=\sum$ and $A[1,n]$ an array of numbers, the range query $\sum _{i,j}A$ computes $\sum A[i,j]=(a_{i}+\ldots +a_{j})$, for any $1\leq i\leq j\leq n$. These queries may be answered in constant time and using $O(n)$ extra space by calculating the sums of the first i elements of A and storing them into an auxiliary array B, such that $B[i]$ contains the sum of the first i elements of A for every $0\leq i\leq n$. Therefore, any query might be answered by doing $\sum A[i,j]=B[j]-B[i-1]$.

This strategy may be extended for every group operator f where the notion of $f^{-1}$ is well defined and easily computable. Finally, this solution can be extended to two-dimensional arrays with a similar preprocessing.

Examples

Semigroup operators

Range minimum query reduced to the lowest common ancestor problem.

Main article: Range minimum query

When the function of interest in a range query is a semigroup operator, the notion of $f^{-1}$ is not always defined, so the strategy in the previous section does not work. Andrew Yao showed that there exists an efficient solution for range queries that involve semigroup operators. He proved that for any constant c, a preprocessing of time and space $\theta (c\cdot n)$ allows to answer range queries on lists where f is a semigroup operator in $\theta (\alpha _{c}(n))$ time, where $\alpha _{c}$ is a certain functional inverse of the Ackermann function.

There are some semigroup operators that admit slightly better solutions. For instance when $f\in \{\max ,\min \}$. Assume $f=\min$ then $\min(A[1..n])$ returns the index of the minimum element of $A[1..n]$. Then $\min _{i,j}(A)$ denotes the corresponding minimum range query. There are several data structures that allow to answer a range minimum query in $O(1)$ time using a preprocessing of time and space $O(n)$. One such solution is based on the equivalence between this problem and the lowest common ancestor problem.

The Cartesian tree $T_{A}$ of an array $A[1,n]$ has as root $a_{i}=\min\{a_{1},a_{2},\ldots ,a_{n}\}$ and as left and right subtrees the Cartesian tree of $A[1,i-1]$ and the Cartesian tree of $A[i+1,n]$ respectively. A range minimum query $\min _{i,j}(A)$ is the lowest common ancestor in $T_{A}$ of $a_{i}$ and $a_{j}$. Because the lowest common ancestor can be solved in constant time using a preprocessing of time and space $O(n)$, range minimum query can as well. The solution when $f=\max$ is analogous. Cartesian trees can be constructed in linear time.

Mode

Main article: Range mode query

The mode of an array A is the element that appears the most in A. For instance the mode of $A=[4,5,6,7,4]$ is 4. In case of ties any of the most frequent elements might be picked as mode. A range mode query consists in preprocessing $A[1,n]$ such that we can find the mode in any range of $A[1,n]$. Several data structures have been devised to solve this problem, we summarize some of the results in the following table.

Range Mode Queries

Space	Query Time	Restrictions
$O(n^{2-2\epsilon })$	$O(n^{\epsilon }\log n)$	$0\leq \epsilon \leq {\frac {1}{2}}$
$O\left({\frac {n^{2}\log \log n}{\log n}}\right)$	$O(1)$

Recently Jørgensen et al. proved a lower bound on the cell-probe model of $\Omega \left({\tfrac {\log n}{\log(Sw/n)}}\right)$ for any data structure that uses S cells.

Median

This particular case is of special interest since finding the median has several applications. On the other hand, the median problem, a special case of the selection problem, is solvable in O(n), using the median of medians algorithm. However its generalization through range median queries is recent. A range median query $\operatorname {median} (A,i,j)$ where A,i and j have the usual meanings returns the median element of $A[i,j]$. Equivalently, $\operatorname {median} (A,i,j)$ should return the element of $A[i,j]$ of rank ${\frac {j-i}{2}}$. Range median queries cannot be solved by following any of the previous methods discussed above including Yao's approach for semigroup operators.

There have been studied two variants of this problem, the offline version, where all the k queries of interest are given in a batch, and a version where all the preprocessing is done up front. The offline version can be solved with $O(n\log k+k\log n)$ time and $O(n\log k)$ space.

The following pseudocode of the quickselect algorithm shows how to find the element of rank r in $A[i,j]$ an unsorted array of distinct elements, to find the range medians we set $r={\frac {j-i}{2}}$.

rangeMedian(A, i, j, r) {
    if A.length() == 1
        return A[1]

    if A.low is undefined then
        m = median(A)
        A.low  = [e in A | e <= m]
        A.high = [e in A | e > m ]

    calculate t the number of elements of A[i, j] that belong to A.low

    if r <= t then
        return rangeMedian(A.low, i, j, r)
    else
        return rangeMedian(A.high, i, j, r-t)
}

Procedure rangeMedian partitions A, using A's median, into two arrays A.low and A.high, where the former contains the elements of A that are less than or equal to the median m and the latter the rest of the elements of A. If we know that the number of elements of $A[i,j]$ that end up in A.low is t and this number is bigger than r then we should keep looking for the element of rank r in A.low; otherwise we should look for the element of rank $(r-t)$ in A.high. To find t, it is enough to find the maximum index $m\leq i-1$ such that $a_{m}$ is in A.low and the maximum index $l\leq j$ such that $a_{l}$ is in A.high. Then $t=l-m$. The total cost for any query, without considering the partitioning part, is $\log n$ since at most $\log n$ recursion calls are done and only a constant number of operations are performed in each of them (to get the value of t fractional cascading should be used). If a linear algorithm to find the medians is used, the total cost of preprocessing for k range median queries is $n\log k$. The algorithm can also be modified to solve the online version of the problem.

Majority

Finding frequent elements in a given set of items is one of the most important tasks in data mining. Finding frequent elements might be a difficult task to achieve when most items have similar frequencies. Therefore, it might be more beneficial if some threshold of significance was used for detecting such items. One of the most famous algorithms for finding the majority of an array was proposed by Boyer and Moore which is also known as the Boyer–Moore majority vote algorithm. Boyer and Moore proposed an algorithm to find the majority element of a string (if it has one) in $O(n)$ time and using $O(1)$ space. In the context of Boyer and Moore’s work and generally speaking, a majority element in a set of items (for example string or an array) is one whose number of instances is more than half of the size of that set. Few years later, Misra and Gries proposed a more general version of Boyer and Moore's algorithm using $O(nlog(1/\tau ))$ comparisons to find all items in an array whose relative frequencies are greater than some threshold $0<\tau <1$. A range $\tau$-majority query is one that, given a subrange of a data structure (for example an array) of size $|R|$, returns the set of all distinct items that appear more than (or in some publications equal to) $\tau |R|$ times in that given range. In different structures that support range $\tau$-majority queries, $\tau$ can be either static (specified during preprocessing) or dynamic (specified at query time). Many of such approaches are based on the fact that, regardless of the size of the range, for a given $\tau$ there could be at most $O(1/\tau )$ distinct candidates with relative frequencies at least $\tau$. By verifying each of these candidates in constant time, $O(1/\tau )$ query time is achieved. A range $\tau$-majority query is decomposable in the sense that a $\tau$-majority in a range $R$ with partitions $R_{1}$ and $R_{2}$ must be a $\tau$-majority in either $R_{1}$or $R_{2}$. Due to this decomposability, some data structures answer $\tau$-majority queries on one-dimensional arrays by finding the Lowest common ancestor (LCA) of the endpoints of the query range in a Range tree and validating two sets of candidates (of size $O(1/\tau )$) from each endpoint to the lowest common ancestor in constant time resulting in $O(1/\tau )$ query time.

Range Majority Queries on Two-Dimensional Arrays

Gagie et al. proposed a data structure that supports range $\tau$-majority queries on an $m\times n$ array $A$. For each query $\operatorname {Q} =(\operatorname {R} ,\tau )$ in this data structure a threshold $0<\tau <1$ and a rectangular range $\operatorname {R}$ are specified, and the set of all elements that have relative frequencies (inside that rectangular range) greater than or equal to $\tau$ are returned as the output. This data structure supports dynamic thresholds (specified at query time) and a preprocessing threshold $\alpha$ based on which it is constructed. During the preprocessing, a set of vertical and horizontal intervals are built on the $m\times n$ array. Together, a vertical and a horizontal interval form a block. Each block is part of a superblock nine times bigger than itself (three times the size of the block's horizontal interval and three times the size of its vertical one). For each block a set of candidates (with ${\frac {9}{\alpha }}$ elements at most) is stored which consists of elements that have relative frequencies at least ${\frac {\alpha }{9}}$ (the preprocessing threshold as mentioned above) in its respective superblock. These elements are stored in non-increasing order according to their frequencies and it is easy to see that, any element that has a relative frequency at least $\alpha$ in a block must appear its set of candidates. Each $\tau$-majority query is first answered by finding the query block, or the biggest block that is contained in the provided query rectangle in $O(1)$ time. For the obtained query block, the first ${\frac {9}{\tau }}$ candidates are returned (without being verified) in $O(1/\tau )$ time, so this process might return some false positives. Many other data structures (as discussed below) have proposed methods for verifying each candidate in constant time and thus maintaining the $O(1/\tau )$ query time while returning no false positives. The cases in which the query block is smaller than $1/\alpha$ are handled by storing $log(1/\alpha )$ different instances of this data structure of the following form:

$\beta =2^{-i},\;\;i\in \{1,\dots ,log({\frac {1}{\alpha }})\}$

where $\beta$ is the preprocessing threshold of the $i$-th instance. Thus, for query blocks smaller than $1/\alpha$ the $\lceil \log(1/\tau )\rceil$-th instance is queried. As mentioned above, this data structure has query time $O(1/\tau )$ and requires ${\mathcal {O}}(mn(H+1)\log ^{2}(1/\alpha ))$ bits of space by storing a Huffman-encoded copy of it (note the $log(1/\alpha )$ factor and also see Huffman coding).

Range Majority Queries on One-Dimensional Arrays

Chan et al. proposed a data structure that given a one-dimensional array$A$, a subrange $R$ of $A$ (specified at query time) and a threshold $\tau$ (specified at query time), is able to return the list of all $\tau$-majorities in $O(1/\tau )$ time requiring $O(nlogn)$ words of space. To answer such queries, Chan et al. begin by noting that there exists a data structure capable of returning the top-k most frequent items in a range in $O(k)$ time requiring $O(n)$ words of space. For a one-dimensional array $A[0,..,n-1]$, let a one-sided top-k range query to be of form $A[0..i]{\text{ for }}0\leq i\leq n-1$. For a maximal range of ranges $A[0..i]{\text{ through }}A[0..j]$ in which the frequency of a distinct element $e$ in $A$ remains unchanged (and equal to $f$), a horizontal line segment is constructed. The $x$-interval of this line segment corresponds to $[i,j]$ and it has a $y$-value equal to $f$. Since adding each element to $A$ changes the frequency of exactly one distinct element, the aforementioned process creates $O(n)$ line segments. Moreover, for a vertical line $x=i$ all horizonal line segments intersecting it are sorted according to their frequencies. Note that, each horizontal line segment with $x$-interval $[\ell ,r]$ corresponds to exactly one distinct element $e$ in $A$, such that $A[\ell ]=e$. A top-k query can then be answered by shooting a vertical ray $x=i$ and reporting the first $k$ horizontal line segments that intersect it (remember from above that these line line segments are already sorted according to their frequencies) in $O(k)$ time.

Chan et al. first construct a range tree in which each branching node stores one copy of the data structure described above for one-sided range top-k queries and each leaf represents an element from $A$. The top-k data structure at each node is constructed based on the values existing in the subtrees of that node and is meant to answer one-sided range top-k queries. Please note that for a one-dimensional array $A$, a range tree can be constructed by dividing $A$ into two halves and recursing on both halves; therefore, each node of the resulting range tree represents a range. It can also be seen that this range tree requires $O(nlogn)$ words of space, because there are $O(logn)$ levels and each level $\ell$ has $2^{\ell }$ nodes. Moreover, since at each level $\ell$ of a range tree all nodes have a total of $n$ elements of $A$ at their subtrees and since there are $O(logn)$ levels, the space complexity of this range tree is $O(nlogn)$.

Using this structure, a range $\tau$-majority query $A[i..j]$ on $A[0..n-1]$ with $0\leq i\leq j\leq n$ is answered as follows. First, the lowest common ancestor (LCA) of leaf nodes $i$ and $j$ is found in constant time. Note that there exists a data structure requiring $O(n)$ bits of space that is capable of answering the LCA queries in $O(1)$ time . Let $z$ denote the LCA of $i$ and $j$, using $z$ and according to the decomposability of range $\tau$-majority queries (as described above and in ), the two-sided range query $A[i..j]$ can be converted into two one-sided range top-k queries (from $z$ to $i$ and $j$). These two one-sided range top-k queries return the top-($1/\tau$) most frequent elements in each of their respective ranges in $O(1/\tau )$ time. These frequent elements make up the set of candidates for $\tau$-majorities in $A[i..j]$ in which there are $O(1/\tau )$ candidates some of which might be false positives. Each candidate is then assessed in constant time using a linear-space data structure (as described in Lemma 3 in ) that is able to determine in $O(1)$ time whether or not a given subrange of an array $A$ contains at least $q$ instances of a particular element $e$.

Related problems

All the problems described above have been studied for higher dimensions as well as their dynamic versions. On the other hand, range queries might be extended to other data structures like trees, such as the level ancestor problem. A similar family of problems are orthogonal range queries, also known as counting queries.

See also

• Level ancestor problem
• Lowest common ancestor

External links

• Open Data Structure - Chapter 13 - Data Structures for Integers
• Data Structures for Range Median Queries - Gerth Stolting Brodal and Allan Gronlund Jorgensen