In computer science, the all nearest smaller values problem is the following task: for each position in a sequence of numbers, search among the previous positions for the last position that contains a smaller value. This problem can be solved efficiently both by parallel and non-parallel algorithms:, who first identified the procedure as a useful subroutine for other parallel programs, developed efficient algorithms to solve it in the Parallel Random Access Machine model; it may also be solved in linear time on a non-parallel computer using a stack-based algorithm. Later researchers have studied algorithms to solve it in other models of parallel computation.
Example
Suppose that the input is the binary van der Corput sequence The first element of the sequence has no previous value. The nearest smaller value previous to 8 and to 4 is 0. All three values previous to 12 are smaller, but the nearest one is 4. Continuing in the same way, the nearest previous smaller values for this sequence are In most applications, the positions of the nearest smaller values, and not the values themselves, should be computed, and in many applications the same computation should be computed for the reversal of the sequence in order to find the following smaller value that is closest in the sequence.
Applications
mention many other problems that may be solved efficiently in parallel using a nearest smaller values computation. Among them, they include the following:
Merge algorithms, computing the merge step of a merge sort. The input to these algorithms consists of two sorted arrays of numbers; the desired output is the same set of numbers in a single sorted array. If one concatenates the two sorted arrays, the first in ascending order and the second in descending order, then the predecessor of each value in the output is either its closest previous smaller value or its closest following smaller value, and the position of each value in the sorted output array may easily be calculated from the positions of these two nearest smaller values.
Construction of Cartesian trees. A Cartesian tree is a data structure introduced by and further studied by for range searching applications. Cartesian trees also arise in the definition of the treap and randomized binary search tree data structures for binary searching. The Cartesian tree of a sequence of values has a node for each value. The root of the tree is the minimum value of the sequence; for every other node, the parent of the node is either its closest previous smaller value or its closest following smaller value. Thus, Cartesian trees may be constructed in linear time based on an all nearest smaller values algorithm.
Matching parentheses. If a sequence of open and close parenthesis characters is given as input, together with the nesting depth of each parenthesis, then the match to each open parenthesis is the next close parenthesis with no larger nesting depth, so it can be found by an all nearest smaller values computation that breaks ties in favor of close parentheses. If the nesting depths are not given, they can be calculated using a prefix sum computation.
Similar techniques may also be applied to problems of polygon triangulation, convex hull construction, reconstruction of trees from two of the trees' traversal orderings, and quadtree construction.
Sequential algorithm
On a sequential computer, it is straightforward to compute all nearest smaller values using a stack data structure: one processes the values in sequence order, using the stack to maintain a subsequence of the values that have been processed so far and are smaller than any later value that has already been processed. In pseudocode, the algorithm is as follows. S = new empty stack data structure for x in the input sequence do while S is nonempty and the top element of S is greater than or equal to x do pop S if S is empty then x has no preceding smaller value else the nearest smaller value to x is the top element of S push x onto S Despite having a nested loop structure, the running time of this algorithm is linear, because every iteration of the inner loop removes an item that had been added in some previous iteration of the outer loop. It is closely related to an algorithm of Knuth for sorting with a stack. An even simpler linear-time sequential algorithm does not even need a stack; it assumes that the input sequence is given as an array A, and stores the index j of the preceding smaller value of the i'th value A in P. We assume an artificial overall minimum at A: for i from 1 to n: j = i-1 while A >= A: j = P P = j
Parallel algorithms
showed how to solve the all nearest smaller values problem efficiently on a concurrent-read concurrent-write Parallel Random Access Machine. For a sequence of n values, stored as an array, they show that the problem may be solved in time O using a linear amount of total work. For sequences where all values are integers in the interval , improved this bound to O; they also showed that, for sufficiently large values of s, the previous doubly logarithmic time bound is the best that can be achieved for the problem. Since this work, parallel algorithms for the all nearest smaller values problem have also been developed on other models of parallel computation, including parallel computers with a hypercube-structured communications network, and the bulk synchronous parallel model.
