Double-ended Priority Queue Research Articles

상수 삽입 전이 시간을 가지는 양단 우선순위 큐

우선순위 큐는 스케줄링, 정렬, 유전자 검색과 같은 우선순위에 따른 검색, 최단거리 계산과 같은 응용에 사용될 수 있다. 본 논문에서 제안하는 배열을 이용한 양단 우선순위 큐 자료구조는 삽입과 삭제 연산에 각각 O(1) 전이시간과 O(logn) 시간이 걸린다. 본 저자가 알고 있는 한, 지금까지의 배열을 이용한 양단우선순위 큐 알고리즘은 삽입과 삭제에 모두 O(logn) 시간이 걸린다. Priority queues can be used in applications such as scheduling, sorting, retrival based on a priority like gene searching, shortest paths computation. This paper proposes a data structure using array representation for double-ended priority queue in which insertion and deletion takes O(1) amortized time and O(logn) time, respectively. To the author's knowledge, all the published array-based data structures for double ended priority queue support O(logn) time insertion and deletion operations.

Two new methods for constructing double-ended priority queues from priority queues

We introduce two data-structural transformations to construct double-ended priority queues from priority queues. To apply our transformations the priority queues exploited must support the extraction of an unspecified element, in addition to the standard priority-queue operations. With the first transformation we obtain a double-ended 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 lg n + O(1) element comparisons for delete. 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 most lg n + O(lg lg n) element comparisons for delete; and the worst-case cost of O(min {lg m, lg n}) for meld. Here, m and n denote the number of elements stored in the data structures prior to the operation in question.

The d-deap*: a fast and simple cache-aligned d-ary deap

This paper presents a generalized and cache-aligned implicit version of the deap, called d-deap* that utilizes cache memory efficiently. The d-deap* is based on a tree structure that may be mapped into a cache-aligned array without padding. This results in a match between node indexes and array indexes as well as good cache utilization. Experimental results show that the d-deap* clearly outperforms the symmetric min-max heap and deap structures proposed earlier for double-ended priority queues.

Improvements in double ended priority queues

In this paper, we present improved algorithms for min-max pair heaps introduced by S. Olariu et al. (A Mergeable Double-ended Priority Queue - The Comp. J. 34, 423-427, 1991). We also show that in the 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, Oct, 1986) in respect of deletion, and is equally good for insertion when an improved technique using binary search is applied. 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.

Correspondence-based data structures for double-ended priority queues

We describe three general methods--total, dual, and leaf correspondence--that may be used to derive efficient double-ended priority queues from single-ended priority queues. These methods are illustrated by developing double-ended priority queues based on the classical heap. Experimental results indicate that the leaf-correspondence method generally leads to a faster double-ended priority queue than either total or dual correspondence. On randomly generated test sets, however, the splay tree outperforms the tested correspondence-based double-ended priority queues.

MERGEABLE DOUBLE-ENDED PRIORITY QUEUES

We show that the leftist tree data structure may be adapted to obtain data structures that permit the double-ended priority queue operations Insert, DeleteMin, DeleteMax, and Merge to be done in O( log n) time where n is the size of the resulting queue. The operations FindMin and FindMax can be done in O(1) time. Experimental results are also presented.

Symmetric Min-Max heap: A simpler data structure for double-ended priority queue

Several data structures have been proposed to implement double-ended priority queue operations in O(log n) time, e.g., Min-Max heap [ 11, Deap [2], Diamond deque [3] and back-to-back heap [4]. In MinMax heaps, the even layers form a Min-heap and the odd layers form a Max-heap. Deap has separate Minheaps and Max-heaps that are built on the left and right subtrees, respectively. In Diamond deque, the Minheap and Max-heap are not separable. The separation of the Minand Max-heaps in [l] and [2] tend to make computations complicated. The

An Efficient Construction Algorithm for a Class of Implicit Double-Ended Priority Queues

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, int ...

The relaxed min-max heap

A data structure that implements a mergeable double-ended priority queue, namely therelaxed min-max heap, is presented. A relaxed min-max heap ofn items can be constructed inO(n) time. In the worst case, operationsfind_min() andfind_max() can be performed in constant time, while each of the operationsmerge(),insert(),delete_min(),delete_max(),decrease_key(), anddelete_key() can be performed inO(logn) time. Moreover,insert() hasO(1) amortized running time. If lazy merging is used,merge() will also haveO(1) worst-case and amortized time. The relaxed min-max heap is the first data structure that achieves these bounds using only two pointers (puls one bit) per item.

An optimal parallel algorithm to construct a deap

Recently, Carlsson [3] proposed a variation of the heap data structure as an efficient implementation of a double-ended priority queue. This new data structure is referred to as the deap. We show that constructing a deap with special properties can be done very easily, both sequentially and in parallel, by reducing the problem to selection and heap construction. Our parallel algorithm can be implemented to run in O(log n log ∗ n) time using an optimal number of processors in the EREW-PRAM model or in O(log n) time using an optimal number of processors in the CRCW model.

A Mergeable Double-ended Priority Queue

A Mergeable Double-ended Priority Queue

Optimal parallel initialization algorithms for a class of priority queues

An adaptive parallel algorithm for inducing a priority queue structure on an n-element array is presented. The algorithm is extended to provide optimal parallel construction algorithms for three other heap-like structures useful in implementing double-ended priority queues, namely min-max heaps, deeps, and min-max-pair heaps. It is shown that an n-element array can be made into a heap, a deap, a min-max heap, or a min-max-pair heap in O(log n+(n/p)) time using no more than n/log n processors, in the exclusive-read-exclusive-write parallel random-access machine model.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

A note on constructing min-max heaps

In this paper we show that to construct an implicit, double-ended priority queue organized as a min-max heap, 17/9n = 1.88 ...n comparisons suffice in the worst case (neglectng lower order terms). The algorithm improves the previously best known upper bound of 2.15 ...n comparisons.

The deap—a double-ended heap to implement double-ended priority queues

This paper presents a symmetrical implicit double-ended priority queue implementation, which can be built in linear time. The smallest and the largest element can be found in constant time, and deleted in logarithmic time. This structure is an improvement of the MinMaxHeap presented by Atkinson et al. (1986).

Bounds for min-max heaps

Very recently a new data structure, called a min-max heap, was presented for implementing the double-ended priority queue. A min-max heap onn keys is constructed inO(n) time; the minimum and maximum keys are found in constant time, and the operations of deleting the minimum, deleting the maximum and inserting a new key into the heap are performed inO(logn) time. In addition, the data structure can be stored implicitly, i.e. in an array ofn elements without using any additional pointers.

Min-max heaps and generalized priority queues

A simple implementation of double-ended priority queues is presented. The proposed structure, called a min-max heap, can be built in linear time; in contrast to conventional heaps, it allows both FindMin and FindMax to be performed in constant time; Insert, DeleteMin, and DeleteMax operations can be performed in logarithmic time. Min-max heaps can be generalized to support other similar order-statistics operations efficiently (e.g., constant time FindMedian and logarithmic time DeleteMedian); furthermore, the notion of min-max ordering can be extended to other heap-ordered structures, such as leftist trees.