Adding range restriction capability to dynamic data structures
Journal of the ACM (JACM)
The cell probe complexity of dynamic data structures
STOC '89 Proceedings of the twenty-first annual ACM symposium on Theory of computing
The C programming language
Surpassing the information theoretic bound with fusion trees
Journal of Computer and System Sciences - Special issue: papers from the 22nd ACM symposium on the theory of computing, May 14–16, 1990
Trans-dichotomous algorithms for minimum spanning trees and shortest paths
Journal of Computer and System Sciences - Special issue: 31st IEEE conference on foundations of computer science, Oct. 22–24, 1990
Fusion trees can be implemented with AC0 instructions only
Theoretical Computer Science
SODA '97 Proceedings of the eighth annual ACM-SIAM symposium on Discrete algorithms
Faster deterministic sorting and priority queues in linear space
Proceedings of the ninth annual ACM-SIAM symposium on Discrete algorithms
Efficiency of a Good But Not Linear Set Union Algorithm
Journal of the ACM (JACM)
Improved fast interger sorting in linear space
Information and Computation
Introduction to Algorithms
SIAM Journal on Computing
Optimal bounds for the predecessor problem and related problems
Journal of Computer and System Sciences - STOC 1999
On AC0 implementations of fusion trees and atomic heaps
SODA '03 Proceedings of the fourteenth annual ACM-SIAM symposium on Discrete algorithms
Integer Sorting in 0(n sqrt (log log n)) Expected Time and Linear Space
FOCS '02 Proceedings of the 43rd Symposium on Foundations of Computer Science
Combinatorial power in multimedia processors
ACM SIGARCH Computer Architecture News
Deterministic sorting in O(nlog logn) time and linear space
Journal of Algorithms
Journal of Computer and System Sciences - Special issue: STOC 2003
Black box for constant-time insertion in priority queues (note)
ACM Transactions on Algorithms (TALG)
ACM Transactions on Algorithms (TALG)
Dynamic ordered sets with exponential search trees
Journal of the ACM (JACM)
Priority sampling for estimation of arbitrary subset sums
Journal of the ACM (JACM)
Stream sampling for variance-optimal estimation of subset sums
SODA '09 Proceedings of the twentieth Annual ACM-SIAM Symposium on Discrete Algorithms
Sorting algorithms as special cases of a priority queue sort
Proceedings of the 42nd ACM technical symposium on Computer science education
Approximate shortest path queries using Voronoi duals
Transactions on computational science IX
Approximate shortest path queries using Voronoi duals
Transactions on computational science IX
Efficient Stream Sampling for Variance-Optimal Estimation of Subset Sums
SIAM Journal on Computing
SIAM Journal on Computing
A simple reduction from maximum weight matching to maximum cardinality matching
Information Processing Letters
Linear-Time Approximation for Maximum Weight Matching
Journal of the ACM (JACM)
Hi-index | 0.01 |
We present a general deterministic linear space reduction from priority queues to sorting implying that if we can sort up to n keys in S(n) time per key, then there is a priority queue supporting delete and insert in O(S(n)) time and find-min in constant time. Conversely, a priority queue can trivially be used for sorting: first insert all keys to be sorted, then extract them in sorted order by repeatedly deleting the minimum. Asymptotically, this settles the complexity of priority queues in terms of that of sorting. Previously, at SODA'96, such a result was presented by the author for the special case of monotone priority queues where the minimum is not allowed to decrease. Besides nailing down the complexity of priority queues to that of sorting, and vice versa, our result yields several improved bounds for linear space integer priority queues with find-min in constant time: Deterministically. We get O(log log n) update time using a sorting algorithm of Han from STOC'02. This improves the O((log log n)(log log log n)) update time of Han from SODA'01. Randomized. We get O(&sqrt;log log n) expected update time using a randomized sorting algorithm of Han and Thorup from FOCS'02. This improves the O(log log n) expected update time of Thorup from SODA'96. Deterministically in AC0 (without multiplication). For any ϵ 0, we get O((log log n)1+ϵ) update time using an AC0 sorting algorithm of Han and Thorup from FOCS'02. This improves the O((log log n)2) update time of Thorup from SODA'98. Randomized in AC0. We get O(log log n) expected update time using a randomized AC0 sorting algorithm of Thorup from SODA'97. This improves the O((log log n)1+ϵ) expected update time of Thorup also from SODA'97. The above bounds assume that each integer is stored in a single word and that word operations take unit time as in the word RAM.