Data structures and network algorithms
Data structures and network algorithms
The pairing heap: a new form of self-adjusting heap
Algorithmica
Fibonacci heaps and their uses in improved network optimization algorithms
Journal of the ACM (JACM)
Relaxed heaps: an alternative to Fibonacci heaps with applications to parallel computation
Communications of the ACM
Journal of Algorithms
Splitsort—an adaptive sorting algorithm
Information Processing Letters
Journal of Algorithms
Pairing heaps: experiments and analysis
Communications of the ACM
Splaysort: fast, versatile, practical
Software—Practice & Experience
Shortest paths algorithms: theory and experimental evaluation
Mathematical Programming: Series A and B
Introspective sorting and selection algorithms
Software—Practice & Experience
LEDA: a platform for combinatorial and geometric computing
LEDA: a platform for combinatorial and geometric computing
A unifying look at data structures
Communications of the ACM
A data structure for manipulating priority queues
Communications of the ACM
On the Performance of WEAK-HEAPSORT
STACS '00 Proceedings of the 17th Annual Symposium on Theoretical Aspects of Computer Science
Scaling and related techniques for geometry problems
STOC '84 Proceedings of the sixteenth annual ACM symposium on Theory of computing
Implementing HEAPSORT with (n logn - 0.9n) and QUICKSORT with (n logn + 0.2n) comparisons
Journal of Experimental Algorithmics (JEA)
Acta Informatica
On the adaptiveness of Quicksort
Journal of Experimental Algorithmics (JEA)
ACM Transactions on Algorithms (TALG)
Bulk-Insertion Sort: Towards Composite Measures of Presortedness
SEA '09 Proceedings of the 8th International Symposium on Experimental Algorithms
Introduction to Algorithms, Third Edition
Introduction to Algorithms, Third Edition
Cache-aware and cache-oblivious adaptive sorting
ICALP'05 Proceedings of the 32nd international conference on Automata, Languages and Programming
Policy-based benchmarking of weak heaps and their relatives,
SEA'10 Proceedings of the 9th international conference on Experimental Algorithms
Journal of Discrete Algorithms
Hi-index | 0.00 |
The weak heap is a priority queue that was introduced as a competitive structure for sorting. Its array-based form supports the operations find-min in O(1) worst-case time, and insert and delete-min in O(lgn) worst-case time using at most @?lgn@? element comparisons. Additionally, its pointer-based form supports delete and decrease in O(lgn) worst-case time using at most @?lgn@? element comparisons. In this paper we enhance this data structure as follows:1.We improve the array-based form to support insert in O(1) amortized time. The main idea is to temporarily store the inserted elements in a buffer, and, once the buffer is full, to move its elements to the heap using an efficient bulk-insertion procedure. As an application, we use this variant in the implementation of adaptive heapsort. Accordingly, we guarantee, for several measures of disorder, that the formula expressing the number of element comparisons performed by the algorithm is optimal up to the constant factor of the high-order term. Unlike other previous constant-factor-optimal adaptive sorting algorithms, adaptive heapsort relying on the developed priority queue is practically workable. 2.We improve the pointer-based form to support insert and decrease in O(1) worst-case time per operation. The expense is that delete then requires at most 2@?lgn@? element comparisons, but this is still better than the 3@?lgn@? bound known for run-relaxed heaps. The main idea is to allow some nodes to violate the weak-heap ordering; we call the resulting priority queue a relaxed weak heap. We also develop a more efficient amortized variant that provides delete guaranteeing an amortized bound of 1.5@?lgn@? element comparisons, which is better than the 2@?log"@fn@? bound known for Fibonacci heaps, where @f is the golden ratio. As an application, we use this variant in the implementation of Dijkstra@?s shortest-paths algorithm. Experimental results indicate that weak heaps are practically efficient; they are competitive with other priority-queue structures when considering the number of element comparisons performed, and lose by a small margin when considering the actual running time.