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.
Abstract: We 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
Proceedings Article•
12 Jun 2019TL;DR: In this paper, the authors consider the sorted top-k problem with pairwise comparisons and show that the optimal sample complexity depends on the number of rounds (up to a polylogarithmic factor for general $r$ and up to a constant factor for $r=1$ or 2).
Abstract: We consider the sorted top-$k$ problem whose goal is to recover the top-$k$ items with the correct order out of $n$ items using pairwise comparisons. In many applications, multiple rounds of interaction can be costly. We restrict our attention to algorithms with a constant number of rounds $r$ and try to minimize the sample complexity, i.e. the number of comparisons.
When the comparisons are noiseless, we characterize how the optimal sample complexity depends on the number of rounds (up to a polylogarithmic factor for general $r$ and up to a constant factor for $r=1$ or 2). In particular, the sample complexity is $\Theta(n^2)$ for $r=1$, $\Theta(n\sqrt{k} + n^{4/3})$ for $r=2$ and $\tilde{\Theta}\left(n^{2/r} k^{(r-1)/r} + n\right)$ for $r \geq 3$.
We extend our results of sorted top-$k$ to the noisy case where each comparison is correct with probability $2/3$. When $r=1$ or 2, we show that the sample complexity gets an extra $\Theta(\log(k))$ factor when we transition from the noiseless case to the noisy case.
We also prove new results for top-$k$ and sorting in the noisy case. We believe our techniques can be generally useful for understanding the trade-off between round complexities and sample complexities of rank aggregation problems.
3 citations
TL;DR: The Renaming Problem, a basic processing step in string algorithms, is considered, for which a simultaneously work and time optimal Las Vegas type PRAM algorithm is given.
3 citations
Cites methods from "A fast probabilistic parallel sorti..."
...While our algorithm is obtained by random sampling somewhat reminiscent of randomized parallel sorting algorithms [9], the fact that k is unknown and that we seek an algorithm with time dependent on only k introduces new technical difficulties in our setting, which we overcome....
[...]
Proceedings Article•
22 Jun 1987
TL;DR: Nested Annealing is shown to be easily parallelizable and modified procedure for problems that have certain separation properties has a worst case performance better than that of Simulated Annealing.
Abstract: The subject of this thesis is randomized parallel algorithms. The goal is to demonstrate the power of randomization in designing efficient parallel algorithms for various computational problems.
The specific problems we are concerned with are: sorting, routing, and combinatorial optimization.
A survey of existing randomized parallel algorithms for many important problems is given first. This is followed by a procedure for deriving randomized parallel algorithms for selection and sorting. Next we present optimal algorithms for sorting both general and integer keys. We also present algorithms that run in sub-logarithmic time.
A very important problem in parallel computation is routing. We give an optimal algorithm for permutation routing on a square mesh. We also identify a class of mesh-like networks that have optimal diameter.
Many heuristic algorithms have been proposed for solving presumably hard combinatorial problems (like the travelling salesman problem etc.). Simulated Annealing is one such heuristic that employs randomization. We modify this procedure for problems that have certain separation properties. We prove this modified procedure (called Nested Annealing) has a worst case performance better than that of Simulated Annealing. Nested Annealing is shown to be easily parallelizable.
2 citations
Cites background from "A fast probabilistic parallel sorti..."
...Most of the problems studied in this paper belong to RNC....
[...]
TL;DR: The average case of the best deterministic or randomized algorithm for the problem of merging m disjoint ordered lists is not faster than the worst cases of thebest deterministic one by more than a constant factor.
1 citations
01 Jan 1997
TL;DR: In this paper, the authors presented an algorithm for sorting N elements in time O(N/sup 1/4/) on an SIMD multi-mesh architecture, thereby significantly improving the order of the time complexity.
Abstract: The shear-sort algorithm on an SIMD mesh model requires 4/spl radic/N+o(/spl radic/N) time for sorting N elements arranged on a /spl radic/N/spl times//spl radic/N mesh. In this paper, we present an algorithm for sorting N elements in time O(N/sup 1/4/) on an SIMD multi-mesh architecture, thereby significantly improving the order of the time complexity. The multi-mesh architecture is built around n/sup 2/ blocks, where each block is an n/spl times/n mesh with n=N/sup 1/4/, so that each processor will uniformly have four neighbors in the final topology.
1 citations
References
More filters
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.
412 citations
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.
319 citations
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.
169 citations