A copy of this work was available on the public web and has been preserved in the Wayback Machine. The capture dates from 2017; you can also visit the original URL.
The file type is `application/pdf`

.

## Filters

##
###
Worst-case efficient external-memory priority queues
[chapter]

1998
*
Lecture Notes in Computer Science
*

. - Aggarwal, Vitter, 1988

doi:10.1007/bfb0054359
fatcat:pox4uo3nbnguhafaulzilf7o2q
*Worst*-*Case*Effeciency Internal Each*priority**queue*operation should require (log 2 N ) External-Memory*Priority**Queues*Binary heap - Williams, 1964 -Random memory accesses ... Incremental List Merging Lists Conclusion The first*worst**case*external-memory*priority*-*queue*implementation. Open Problems Is the definition of "*worst*-*case*" reasonable in practice ? ...##
###
Two new methods for constructing double-ended priority queues from priority queues

2008
*
Computing
*

With the first transformation we obtain a double-ended

doi:10.1007/s00607-008-0019-2
fatcat:tym6ges4yjgpzoa3a5wxtw5kdu
*priority**queue*which guarantees the*worst*-*case*cost of O(1) for find-min, find-max, insert, extract; and the*worst*-*case*cost of O(lg n) with at most ... With the second transformation we get a meldable double-ended*priority**queue*which guarantees the*worst*-*case*cost of O(1) for find-min, find-max, insert, extract; the*worst*-*case*cost of O(lg n) with at ... Lemma 2 [13] There exists a meldable*priority**queue*that supports find-min, insert, extract, and decrease at the*worst*-*case*cost of O (1) ; delete at the*worst*-*case*cost of O(lg n) including at most ...##
###
Fast Meldable Priority Queues

1995
*
BRICS Report Series
*

We present

doi:10.7146/brics.v2i12.19515
fatcat:dxsmuwetabfvfebajaisjcfply
*priority**queues*that support the operations MakeQueue,<br />FindMin, Insert and Meld in*worst**case*time O(1) and Delete and<br />DeleteMin in*worst**case*time O(log n). ... <br />To our knowledge this is the first*priority**queue*implementation that<br />supports Meld in*worst**case*constant time and DeleteMin in logarithmic<br />time. ... If we want to perform Insert in*worst**case*constant time two*efficient*data structures exist. The implicit*priority**queues*of Carlsson and Munro [2] and the relaxed heaps of Driscoll et al. ...##
###
Fast meldable priority queues
[chapter]

1995
*
Lecture Notes in Computer Science
*

We present

doi:10.1007/3-540-60220-8_70
fatcat:iaau75pvyzhjrie2roitruncyi
*priority**queues*that support the operations MakeQueue, FindMin, Insert and Meld in*worst**case*time O(1) and Delete and DeleteMin in*worst**case*time O(log n). ... The time bounds are optimal for all implementations where Meld takes*worst**case*time o(n). ... If we want to perform Insert in*worst**case*constant time two*efficient*data structures exist. The implicit*priority**queues*of Carlsson and Munro [2] and the relaxed heaps of Driscoll et al. ...##
###
Weak Heaps and Friends: Recent Developments
[chapter]

2013
*
Lecture Notes in Computer Science
*

In applications where this set of operations is sufficient, the

doi:10.1007/978-3-642-45278-9_1
fatcat:xpymmd6toralpgl57qb3ia4ahm
*priority**queue*that the users would select is a binary heap [29] or a weak heap [7] . ... Weak Heaps In its elementary form, a*priority**queue*is a data structure that stores a collection of elements and supports the operations construct, minimum, insert, and extract-min [4] . ... As a culmination, in [13] , an in-place*priority**queue*was introduced that supports insert in O(1)*worst*-*case*time and extract-min in O(lg n)*worst*-*case*time involving at most lg n + O(1) element comparisons ...##
###
Selectable Heaps and Optimal Lazy Search Trees
[article]

2022
*
arXiv
*
pre-print

An O(1) time merge operation is also made possible when used as a

arXiv:2011.11772v3
fatcat:6rssj263o5c3fctwdhzftts2vq
*priority**queue*, among other situations. If Brodal*queues*are used, all runtimes of the lazy search tree can be made*worst*-*case*. ... We show the O(log n) time extract minimum function of*efficient**priority**queues*can be generalized to the extraction of the k smallest elements in O(k log(n/k)) time (we define log(x) as max(log_2(x), ... Brodal gave two*priority**queues*matching Fibonacci heap bounds but in the*worst*-*case*. ...##
###
Policy-Based Benchmarking of Weak Heaps and Their Relatives,
[chapter]

2010
*
Lecture Notes in Computer Science
*

In this paper we describe an experimental study where we evaluated the practical

doi:10.1007/978-3-642-13193-6_36
fatcat:xbihqjez5zfcjopljjgtbk4egi
*efficiency*of three*worst*-*case**efficient**priority**queues*: 1) a weak heap that is a binary tree fulfilling half-heap ordering ... A weak heap supports insert and decrease in logarithmic*worst*-*case*time, whereas a weak*queue*reduces the*worst*-*case*running time of insert to O(1), and a run-relaxed weak*queue*that of both insert and ... Hence,*worst*-*case**efficient**priority**queues*should only be used in applications where*worst*-*case**efficiency*is essential. 3) Memory management is expensive. ...##
###
Improvements in double ended priority queues

2003
*
International Journal of Computer Mathematics
*

We also show that in the

doi:10.1080/207160310001599079
fatcat:3j3e5ohlwffqzblro7uoc3vshe
*worst**case*, this structure, though slightly costlier to create, is better than min-max heaps of Strothotte (Min-max Heaps and Generalized*Priority**Queues*-CACM, 29(10), 996-1000 ... Experimental results show that, in the average*case*, with the exception of creation phase data movement, our algorithm outperforms min-max heap of Strothotte in all other aspects. ... CONCLUDING REMARKS We have presented*efficient*algorithms for the implementation of implicit double-ended*priority**queues*using min-max pair-heap. ...##
###
Multipartite priority queues

2008
*
ACM Transactions on Algorithms
*

In particular, we give a

doi:10.1145/1435375.1435389
fatcat:7fvtifjtdvhqzm6ioudb7tolbe
*priority**queue*which guarantees the worstcase cost of O(1) per minimum finding and insertion, and the*worst*-*case*cost of O(log n) with at most log n + O(1) element comparisons ... We introduce a framework for reducing the number of element comparisons performed in*priority*-*queue*operations. ... Deletion from the insert buffer is performed in the same way as that of the*worst*-*case**efficient*binomial*queue*. ...##
###
Fat Heaps without Regular Counters
[chapter]

2012
*
Lecture Notes in Computer Science
*

Our variant is simpler to explain, more

doi:10.1007/978-3-642-28076-4_18
fatcat:vaf46pzhrvfcxocobeoy22cjzi
*efficient*, and easier to implement. ... We introduce a variant of fat heaps that does not rely on regular counters, and still achieves the optimal*worst*-*case*bounds: O(1) for find -min, insert and decrease, and O(lg n) for delete and delete-min ... Many data structures-such as*worst*-*case*-*efficient*finger trees [11] , fat heaps [12, 13] , fast meldable*priority**queues*[1] , and*worst*-*case*-optimal meldable*priority**queues*[2] -rely on numeral systems ...##
###
FAT HEAPS WITHOUT REGULAR COUNTERS

2013
*
Discrete Mathematics, Algorithms and Applications (DMAA)
*

Our variant is simpler to explain, more

doi:10.1142/s1793830913600069
fatcat:gajg2zhz4fe6xc2yay5wxn6crq
*efficient*, and easier to implement. ... We introduce a variant of fat heaps that does not rely on regular counters, and still achieves the optimal*worst*-*case*bounds: O(1) for find -min, insert and decrease, and O(lg n) for delete and delete-min ... Many data structures-such as*worst*-*case*-*efficient*finger trees [11] , fat heaps [12, 13] , fast meldable*priority**queues*[1] , and*worst*-*case*-optimal meldable*priority**queues*[2] -rely on numeral systems ...##
###
An Efficient Construction Algorithm for a Class of Implicit Double-Ended Priority Queues

1995
*
Computer journal
*

*Priority*

*queues*and double-ended

*priority*

*queues*are fundamental data types in Computer Science, and various data structures have been proposed to implement them. ... In particular, diamond deques, interval heaps, min-max-pair heaps, and twin-heaps provide implicit structures for double-ended

*priority*

*queues*. ... Various data structures have been developed for implementing

*priority*

*queues*and

*priority*deques

*efficiently*. ...

##
###
Hybrid LRU Algorithm for Enterprise Data Hub

2019
*
VOLUME-8 ISSUE-10, AUGUST 2019, REGULAR ISSUE
*

This paper depicts about the experimental advantage of execution time optimization and

doi:10.35940/ijitee.l3489.119119
fatcat:l4so6pnmzfb5dac3ydgmych4g4
*efficient*page/cache hit ratio, using hybrid Least Recently Used algorithm with*priority*mechanism. ... This research paper is to leverage the in memory processing for the business use*case*of Enterprise Data Hub. ... (Cache aware) O (log4 N) 2 Bottom up Binary Heap (*worst**case*) O (log2 N) 3 Aligned 4-ary Heap (*worst**case*) N:queue size, B: block size, M: cache size, l: (M), k: Pseudo code of LRU algorithm is represented ...##
###
A comparative study of parallel and sequential priority queue algorithms

1997
*
ACM Transactions on Modeling and Computer Simulation
*

For large

doi:10.1145/249204.249205
fatcat:iglffwap4vebrgerxu2iucsfk4
*queue*sizes of 5,000 elements or more, the Calendar*Queue*and the Lazy*Queue*offer good average access times but have very long*worst*-*case*access times. ... The Skew Heap and the Splay Tree exhibit the best*worst*-*case*access times. ... Of the tested*priority**queues*, the implicit binary heap had the best*worst*-*case*performance for individual operations, which was better than O(n). ...##
###
Multiresolution Priority Queues
[article]

2017
*
arXiv
*
pre-print

The new data structure can reduce the

arXiv:1705.09642v6
fatcat:3y4jelk7wzeepflwrlttddhue4
*worst**case*performance of inserting an element from O(log(n)) to O(log(r)), where n is the number of elements in the*queue*and r is the number of resolution groups ...*Priority**queues*are container data structures essential to many high performance computing (HPC) applications. ... Williams' work lead to a very*efficient*implementation with a*worst**case*cost to insert and extract elements from the*priority**queue*of , (log(n)) O where is the number of elements in the*queue*. ...
« Previous

*Showing results 1 — 15 out of 22,557 results*