On RAM priority queues

  title={On RAM priority queues},
  author={Mikkel Thorup},
  journal={SIAM J. Comput.},
  • M. Thorup
  • Published 28 January 1996
  • Computer Science
  • SIAM J. Comput.
Priority queues are some of the most fundamental data structures. [] Key Result Plugging this priority queue into Dijkstra's algorithm gives an O(mlog log m) algorithm for the single source shortest path problem on a graph with m edges, as compared with the previous $O(m\sqrt{\log m})$ bound based on Fredman and Willard's priority queue. The above bounds assume $O(n 2^{{\varepsilon} w})$ space, where w is the word length and ${\varepsilon}>0$. They can, however, be achieved in linear space using randomized…
An Experimental Study of Priority Queues in External Memory
It is required to design PQs which take explicitly into account the physical properties of the disk systems in order to achieve efficient I/O-performances that allow these data structures to be plugged successfully in software libraries.
Integer priority queues with decrease key in constant time and the single source shortest paths problem
  • M. Thorup
  • Computer Science, Mathematics
    STOC '03
  • 2003
A deterministic linear space solution that with n integer keys support delete in O(log log n) time, which is a deterministic, worst-case, with no restriction to monotonicity, and exponentially faster.
Fast Algorithms for Shortest Paths and Sorting
  • R. Raman
  • Computer Science, Mathematics
  • 1996
A priority queue (pq) is said to be monotone if the value of the smallest element stored in the priority queue is a non-decreasing function of time. We consider the problem of maintaining a monotone
Worst-Case External-Memory Priority Queues
A priority-queue implementation is given which is efficient with respect to the number of block transfers or I/Os performed between the internal and external memories of a computer.
Two-level heaps: a new priority queue structure with applications to the single source shortest path problem
A new data structure to implement priority queues called two-level heap (TLH) and a new variant of Dijkstra’s algorithm called Phased DijkStra are introduced and it is empirically established that TLH are far superior to Fibonacci heaps on every graph family considered.
2 Priority Queue
This lecture will discuss the relationship between integer sorting algorithms and priority queue data structures, and how to make fast priority queues once the authors have fast sorting algorithms.
Equivalence between priority queues and sorting
A general deterministic linear space reduction from priority queues to sorting is presented implying that if there is a priority queue supporting delete and insert in O(n) time and find-min in constant time, then this settles the complexity of priority queues in terms of that of sorting.
A survey of the connection between SSSP, sorting, and priority queues on the word RAM
  • Computer Science
  • 2017
The connection between three of the most fundamental problems in theoretical computer science: sorting, priority queues, and shortest paths is surveyed and the connection between Thorup’s results on the equivalence of sorting and priority queues is presented.
Computational evaluation of hot queues
This paper shows that the hot queue implementation of monotone priority queues is competitive in a more general context and has very good practical performance and is robust over a wide range of graph types.
Improved Data Structures for Predecessor Queries in Integer Sets
We consider the problem of maintaining a dynamic ordered set of n integers in the range 0 : :2 w ?1, under the operations of insertion, deletion and predecessor queries, on a unit-cost RAM with a


Equivalence between sorting and priority queues
For a RAM with arbitrary word size, it is shown that if we can sort n integers, each contained in one word, in time n*s(n), then (and only then) there is a priority queue with capacity for n
Sorting in linear time?
We show that a unit-cost RAM with a word length of bits can sort integers in the range in time, for arbitrary ! , a significant improvement over the bound of " # $ achieved by the fusion trees of
Fibonacci Heaps and Their Uses in Improved Network Optimization Algorithms
The structure, Fibonacci heaps (abbreviated F-heaps), extends the binomial queues proposed by Vuillemin and studied further by Brown to obtain improved running times for several network optimization algorithms.
Preserving Order in a Forest in Less Than Logarithmic Time and Linear Space
  • P. Boas
  • Computer Science
    Inf. Process. Lett.
  • 1977
Hash functions for priority queues
A method utilizing families of hash functions is developed which permits priority queue operations to be implemented in constant worst case time provided that a size constraint is satisfied.
Trans-dichotomous algorithms for minimum spanning trees and shortest paths
  • M. Fredman, D. Willard
  • Computer Science
    Proceedings [1990] 31st Annual Symposium on Foundations of Computer Science
  • 1990
The fusion tree method is extended to develop a linear-time algorithm for the minimum spanning tree problem and an O(m+n log n/log log n) implementation of Dijkstra's shortest-path algorithm for a
A new efficient radix sort
  • A. Andersson, S. Nilsson
  • Computer Science
    Proceedings 35th Annual Symposium on Foundations of Computer Science
  • 1994
Forward Radix Sort is introduced which combines the advantages of traditional left- to-right and right-to-left radix sort in a simple manner and is argued that this algorithm will work very well in practice.
Fishspear: a priority queue algorithm
Fishspear differs from the heap method in that it can be implemented efficiently using sequential storage such as stacks or tapes, making it potentially attractive for implementation of very large queues on paged memory systems.
Optimal bounds for decision problems on the CRCW PRAM
Lower bounds on the time for CRCW PRAM's with polynomially bounded numbers of processors or memory cells to compute parity and a number of related problems are proved and almost all Boolean functions of n bits require log n - log log n + time when the number of processors is at most polynomial in n.