Proceedings ArticleDOI

# A fast probabilistic parallel sorting algorithm

28 Oct 1981-pp 212-219

TL;DR: A probabilistic parallel algorithm to sort n keys drawn from some arbitrary total ordered set such that the average runtime is bounded by O(log n), which means the product of time and number of processors meets the information theoretic lower bound for sorting.

AbstractWe describe a probabilistic parallel algorithm to sort n keys drawn from some arbitrary total ordered set. This algorithm can be implemented on a parallel computer consisting of n RAMs, each with small private memory, and a common memory of size O(n) such that the average runtime is bounded by O(log n). Hence for this algorithm the product of time and number of processors meets the information theoretic lower bound for sorting.

##### Citations
More filters
Journal ArticleDOI
TL;DR: This paper gives several new demonstrations of the usefulness of random sampling techniques in computational geometry by creating a search structure for arrangements of hyperplanes by sampling the hyperplanes and using information from the resulting arrangement to divide and conquer.
Abstract: This paper gives several new demonstrations of the usefulness of random sampling techniques in computational geometry. One new algorithm creates a search structure for arrangements of hyperplanes by sampling the hyperplanes and using information from the resulting arrangement to divide and conquer. This algorithm requiresO(sd+?) expected preprocessing time to build a search structure for an arrangement ofs hyperplanes ind dimensions. The expectation, as with all expected times reported here, is with respect to the random behavior of the algorithm, and holds for any input. Given the data structure, and a query pointp, the cell of the arrangement containingp can be found inO(logs) worst-case time. (The bound holds for any fixed ?>0, with the constant factors dependent ond and ?.) Using point-plane duality, the algorithm may be used for answering halfspace range queries. Another algorithm finds random samples of simplices to determine the separation distance of two polytopes. The algorithm uses expectedO(n[d/2]) time, wheren is the total number of vertices of the two polytopes. This matches previous results [10] for the cased = 3 and extends them. Another algorithm samples points in the plane to determine their orderk Voronoi diagram, and requires expectedO(s1+?k) time fors points. (It is assumed that no four of the points are cocircular.) This sharpens the boundO(sk2 logs) for Lee's algorithm [21], andO(s2 logs+k(s?k) log2s) for Chazelle and Edelsbrunner's algorithm [4]. Finally, random sampling is used to show that any set ofs points inE3 hasO(sk2 log8s/(log logs)6) distinctj-sets withj≤k. (ForS ?Ed, a setS? ?S with |S?| =j is aj-set ofS if there is a half-spaceh+ withS? =S ?h+.) This sharpens with respect tok the previous boundO(sk5) [5]. The proof of the bound given here is an instance of a "probabilistic method" [15].

332 citations

### Cites methods from "A fast probabilistic parallel sorti..."

• ...Reischuk [24] has used a probabilistic result that is a one-dimensional analog of Lemma 4....

[...]

Book
06 Sep 2015
TL;DR: This paper provides a general method that trims a factor of O(log n) time for many applications of this technique.
Abstract: Megiddo introduced a technique for using a parallel algorithm for one problem to construct an efficient serial algorithm for a second problem. We give a general method that trims a factor o f 0(logn) time (or more) for many applications of this technique.

290 citations

Journal ArticleDOI
TL;DR: A randomized algorithm that sorts on an N- node network with constant valence in O(log N) time with probability at least 1 - N- “α” - “ α” for all large enough items.
Abstract: A randomized algorithm that sorts on an N node network with constant valence in O(log N) time is given. More particularly, the algorithm sorts N items on an N-node cube-connected cycles graph, and, for some constant k, for all large enough a, it terminates within ka log N time with probability at least 1 - N-a.

242 citations

Journal ArticleDOI
TL;DR: In this article, a general method that trims a factor of O(log n) time (or more) for many applications of the Megiddo technique is presented. But it is not suitable for the case of parallel algorithms.
Abstract: Megiddo introduced a technique for using a parallel algorithm for one problem to construct an efficient serial algorithm for a second problem. This paper provides a general method that trims a factor of O(log n) time (or more) for many applications of this technique.

211 citations

Proceedings ArticleDOI
01 Sep 1991
TL;DR: It is demonstrated that randomization is an extremely powerful tool for designing very fast and efficient parallel algorithms and a running time of O(lg* n) (nearly-constant), with high probability, is achieved using n/lG* n (optimal speedup) processors for a wide range of fundamental problems.
Abstract: It is demonstrated that randomization is an extremely powerful tool for designing very fast and efficient parallel algorithms. Specifically, a running time of O(lg* n) (nearly-constant), with high probability, is achieved using n/lg* n (optimal speedup) processors for a wide range of fundamental problems. Also given is a constant time algorithm which, using n processors, approximates the sum of n positive numbers to within an error which is smaller than the sum by an order of magnitude. A variety of known and new techniques are used. New techniques, which are of independent interest, include estimation of the size of a set in constant time for several settings, and ways for deriving superfast optimal algorithms from superfast nonoptimal ones. >

134 citations

##### References
More filters
Journal ArticleDOI
TL;DR: The worst-case time complexity of algorithms for multiprocessor computers with binary comparisons as the basic operations is investigated and the algorithm for finding the maximum is shown to be optimal for all values of k and n.
Abstract: The worst-case time complexity of algorithms for multiprocessor computers with binary comparisons as the basic operations is investigated. It is shown that for the problems of finding the maximum, sorting, and merging a pair of sorted lists, if n, the size of the input set, is not less than k, the number of processors, speedups of at least \$O(k/\log \log k)\$ can be achieved with respect to comparison operations. The algorithm for finding the maximum is shown to be optimal for all values of k and n.

399 citations

Journal ArticleDOI
TL;DR: A new selection algorithm is presented which is shown to be very efficient on the average, both theoretically and practically.
Abstract: A new selection algorithm is presented which is shown to be very efficient on the average, both theoretically and practically. The number of comparisons used to select the ith smallest of n numbers is n + min(i,n-i) + o(n). A lower bound within 9 percent of the above formula is also derived.

313 citations

Journal ArticleDOI
TL;DR: A family of parallel-sorting algorithms for a multiprocessor system that is enumeration sortings and includes the use of parallel merging to implement count acquisition, matching the performance of Hirschberg's algoithm, which, however, is not free of fetch conflicts.
Abstract: In this paper, we describe a family of parallel-sorting algorithms for a multiprocessor system. These algorithms are enumeration sortings and comprise the following phases: 1) count acquisition: the keys are subdivided into subsets and for each key we determine the number of smaller keys (count) in every subset; 2) rank determination: the rank of a key is the sum of the previously obtained counts; 3) data rearrangement: each key is placed in the position specified by its rank. The basic novelty of the algorithms is the use of parallel merging to implement count acquisition. By using Valiant's merging scheme, we show that n keys can be sorted in parallel with n log2n processors in time C log 2 n + o(log 2 n); in addition, if memory fetch conflicts are not allowed, using a modified version of Batcher's merging algorithm to implement phase 1), we show that n keys can be sorted with n1 +αprocessors in time (C'/α a) log 2 n + o(log 2 n), thereby matching the performance of Hirschberg's algoithm, which, however, is not free of fetch conflicts.

166 citations