Results 1 
7 of
7
WorstCase Efficient Priority Queues
 In Proc. 7th ACMSIAM Symposium on Discrete Algorithms
, 1996
"... An implementation of priority queues is presented that supports the operations MakeQueue, FindMin, Insert, Meld and DecreaseKey in worst case time O(1) and DeleteMin and Delete in worst case time O(log n). The space requirement is linear. The data structure presented is the first achieving this wor ..."
Abstract

Cited by 31 (3 self)
 Add to MetaCart
An implementation of priority queues is presented that supports the operations MakeQueue, FindMin, Insert, Meld and DecreaseKey in worst case time O(1) and DeleteMin and Delete in worst case time O(log n). The space requirement is linear. The data structure presented is the first achieving this worst case performance. 1 Introduction We consider the problem of implementing priority queues which are efficient in the worst case sense. The operations we want to support are the following commonly needed priority queue operations [11]. MakeQueue creates and returns an empty priority queue. FindMin(Q) returns the minimum element contained in priority queue Q. Insert(Q; e) inserts an element e into priority queue Q. Meld(Q 1 ; Q 2 ) melds priority queues Q 1 and Q 2 to a new priority queue and returns the resulting priority queue. DecreaseKey(Q; e; e 0 ) replaces element e by e 0 in priority queue Q provided e 0 e and it is known where e is stored in Q. DeleteMin(Q) deletes and...
Complexity Results for Model Checking
, 1995
"... The complexity of model checking branching and linear time temporal logics over Kripke structures has been addressed in e.g. [SC85, CES86]. In terms of the size of the Kripke model and the length of the formula, they show that the model checking problem is solvable in polynomial time for CTL and ..."
Abstract

Cited by 9 (0 self)
 Add to MetaCart
The complexity of model checking branching and linear time temporal logics over Kripke structures has been addressed in e.g. [SC85, CES86]. In terms of the size of the Kripke model and the length of the formula, they show that the model checking problem is solvable in polynomial time for CTL and NPcomplete for L(F ). The model checking problem can be generalised by allowing more succinct descriptions of systems than Kripke structures. We investigate the complexity of the model checking problem when the instances of the problem consist of a formula and a description of a system whose state space is at most exponentially larger than the description. Based on Turing machines, we define compact systems as a general formalisation of such system descriptions. Examples of such compact systems are Kbounded Petri nets and synchronised automata, and in these cases the wellknown algorithms presented in [SC85, CES86] would require exponential space in term of the sizes of the system descriptions and the formulas; we present polynomial space upper bounds for the model checking problem over compact systems and the logics CTL and L(X; U;S). As an example of an application of our general results we show that the model checking problems of both the branching time temporal logic CTL and the linear time temporal logics L(F ) and L(X;U;S) over Kbounded Petri nets are PSPACEcomplete.
The Randomized Complexity of Maintaining the Minimum
, 1996
"... . The complexity of maintaining a set under the operations Insert, Delete and FindMin is considered. In the comparison model it is shown that any randomized algorithm with expected amortized cost t comparisons per Insert and Delete has expected cost at least n=(e2 2t ) \Gamma 1 comparisons for Fi ..."
Abstract

Cited by 7 (5 self)
 Add to MetaCart
. The complexity of maintaining a set under the operations Insert, Delete and FindMin is considered. In the comparison model it is shown that any randomized algorithm with expected amortized cost t comparisons per Insert and Delete has expected cost at least n=(e2 2t ) \Gamma 1 comparisons for FindMin. If FindMin is replaced by a weaker operation, FindAny, then it is shown that a randomized algorithm with constant expected cost per operation exists; in contrast, it is shown that no deterministic algorithm can have constant cost per operation. Finally, a deterministic algorithm with constant amortized cost per operation for an offline version of the problem is given. CR Classification: F.2.2 1. Introduction We consider the complexity of maintaining a set S of elements from a totally ordered universe under the following operations: Insert(x): inserts the element x into S, Delete(x): removes from S the element x provided it is known where x is stored, and Supported by the Danish...
Priority Queues on Parallel Machines
, 1996
"... We present time and work optimal priority queues for the CREW PRAM, supporting FindMin in constant time with one processor and MakeQueue, Insert, Meld, FindMin, ExtractMin, Delete and DecreaseKey in constant time with O(log n) processors. A priority queue can be build in time O(log n) with O(n= lo ..."
Abstract

Cited by 5 (3 self)
 Add to MetaCart
We present time and work optimal priority queues for the CREW PRAM, supporting FindMin in constant time with one processor and MakeQueue, Insert, Meld, FindMin, ExtractMin, Delete and DecreaseKey in constant time with O(log n) processors. A priority queue can be build in time O(log n) with O(n= log n) processors. A pipelined version of the priority queues adopt to a processor array of size O(log n), supporting the operations MakeQueue, Insert, Meld, FindMin, ExtractMin, Delete and DecreaseKey in constant time. By applying the kbandwidth technique we get a data structure for the CREW PRAM which supports MultiInsert k operations in O(log k) time and MultiExtractMin k in O(log log k) time. Key words: Parallel priority queues, constant time operations, binomial trees, pipelined operations. 1 Introduction The construction of priority queues is a classical topic in data structures. Some references are [1,3,5,1216,19,29,3133]. A historical overview of implementations has been given by M...
Priority Queues on Parallel Machines
 In Proc. 5th Scandinavian Workshop on Algorithm Theory (SWAT
, 1996
"... . We present time and work optimal priority queues for the CREW PRAM, supporting FindMin in constant time with one processor and MakeQueue, Insert, Meld, FindMin, ExtractMin, Delete and DecreaseKey in constant time with O(log n) processors. A priority queue can be build in time O(log n) with O(n= l ..."
Abstract
 Add to MetaCart
. We present time and work optimal priority queues for the CREW PRAM, supporting FindMin in constant time with one processor and MakeQueue, Insert, Meld, FindMin, ExtractMin, Delete and DecreaseKey in constant time with O(log n) processors. A priority queue can be build in time O(log n) with O(n= log n) processors and k elements can be inserted into a priority queue in time O(log k) with O((log n+ k)= log k) processors. With a slowdown of O(log log n) in time the priority queues adopt to the EREW PRAM by only increasing the required work by a constant factor. A pipelined version of the priority queues adopt to a processor array of size O(log n), supporting the operations MakeQueue, Insert, Meld, FindMin, ExtractMin, Delete and DecreaseKey in constant time. 1 Introduction The construction of priority queues is a classical topic in data structures. Some references are [1, 2, 6, 7, 8, 9, 19, 20]. A historical overview of implementations can be found in [13]. Recently several papers ...
The Randomized Complexity of Maintaining the Minimum
, 1996
"... The complexity of maintaining a set under the operations Insert, Delete and FindMin is considered. In the comparison model it is shown that any randomized algorithm with expected amortized cost t comparisons per Insert and Delete has expected cost at least n=(e2 2t ) \Gamma 1 comparisons for Fin ..."
Abstract
 Add to MetaCart
The complexity of maintaining a set under the operations Insert, Delete and FindMin is considered. In the comparison model it is shown that any randomized algorithm with expected amortized cost t comparisons per Insert and Delete has expected cost at least n=(e2 2t ) \Gamma 1 comparisons for FindMin. If FindMin is replaced by a weaker operation, FindAny, then it is shown that a randomized algorithm with constant expected cost per operation exists, but no deterministic algorithm. Finally, a deterministic algorithm with constant amortized cost per operation for an offline version of the problem is given. 1 Introduction We consider the complexity of maintaining a set S of elements from a totally ordered universe under the following operations: Insert(e): inserts the element e into S, Delete(e): removes from S the element e provided it is known where e is stored, and FindMin: returns the minimum element in S without removing it. We refer to this problem as the InsertDeleteFindMi...
Strict Fibonacci Heaps
"... Wepresentthefirstpointerbasedheapimplementationwith time bounds matching those of Fibonacci heaps in the worst case. We support makeheap, insert, findmin, meld and decreasekey in worstcase O(1) time, and delete and deletemin in worstcase O(lgn) time, where n is the size of the heap. The data s ..."
Abstract
 Add to MetaCart
Wepresentthefirstpointerbasedheapimplementationwith time bounds matching those of Fibonacci heaps in the worst case. We support makeheap, insert, findmin, meld and decreasekey in worstcase O(1) time, and delete and deletemin in worstcase O(lgn) time, where n is the size of the heap. The data structure uses linear space. A previous, very complicated, solution achieving the same time bounds in the RAM model made essential use of arrays and extensive use of redundant counter schemes to maintain balance. Our solution uses neither. Our key simplification is to discard the structure of the smaller heap when doing a meld. We use the pigeonhole principle in place of the redundant counter mechanism.