Min-max Heap Research Articles

An in-place min–max priority search tree

One of the classic data structures for storing point sets in R2 is the priority search tree, introduced by McCreight in 1985. We show that this data structure can be made in-place, i.e., it can be stored in an array such that each entry stores only one point of the point set and no entry is stored in more than one location of that array. It combines a binary search tree with a heap. We show that all the standard query operations can be performed within the same time bounds as for the original priority search tree, while using only O(1) extra space.We introduce the min–max priority search tree which is a combination of a binary search tree and a min–max heap. We show that all the standard queries which can be done in two separate versions of a priority search tree can be done with a single min–max priority search tree.As an application, we present an in-place algorithm to enumerate all maximal empty axis-parallel rectangles amongst points in a rectangular region R in R2 in O(mlogn) time with O(1) extra space, where m is the total number of maximal empty rectangles.

4-딥✽ : 캐쉬를 이용한 빠른 4-원 딥

Double-ended Proirity queues(DEPQ) can be used in applications such as scheduling or sorting. The data structures for DEPQ can be con-structed with or without pointers. The implicit representation without pointers uses less memory space than pointer-based representation. This paper presents a novel fast implicit heap called 4-deapr which utilizes cache memory efficiently. Experimental results show that the 4-deap is faster than symmetric min-max heap as well as deap.

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.

Reflected min-max heaps

In this paper we present a simple and efficient implementation of a min-max priority queue, reflected min-max priority queues. The main merits of our construction are threefold. First, the space utilization of the reflected min-max heaps is much better than the naive solution of putting two heaps back-to-back. Second, the methods applied in this structure can be easily used to transform ordinary priority queues into min-max priority queues. Third, when considering only the setting of min-max priority queues, we support merging in constant worst-case time which is a clear improvement over the best worst-case bounds achieved by Høyer.

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

Diamond deque: a simple data structure for priority deques

A simple pointer-free data structure is proposed to implement priority deques. The two heaps (a min-heap and a max-heap) of a twin-heap are stored in one linear array. The simple parent-child relationship of a traditional heap is retained. The min-heap and the max-heap will jointly grow and shrink at one end of the linear array. The proposed data structure is named a diamond deque because of the diamond shape of its Hasse diagram. Priority deque operations on a diamond deque are as efficient as on a twin-heap, a min-max heap, or a deap. Because a diamond deque is highly symmetrical, its interface relations between min-heap and max-heap are simpler. This makes it easier to implement in practice.

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.

PARALLEL CONSTRUCTIONS OF HEAPS AND MIN-MAX HEAPS

We study parallel solutions to the problem of implementing priority queues and priority deques. It is known that data structures for the implementation (e.g. the heap, the min-max heap, and the deap) can be constructed in linear sequential time. In this paper, we design optimal Θ(( log log n)2) time parallel algorithms with [Formula: see text] processors for the constructions in the parallel comparison tree model.

A pointer-free data structure for merging heaps and min-max heaps

In this paper a data structure for the representation of mergeable heaps and min-max heaps without using pointers is introduced. The supported operations are: Insert, DeleteMax, DeleteMin, FindMax, FindMin, Merge, NewHeap, DeleteHeap. The structure is analyzed in terms of amortized time complexity, resulting in a O(1) amortized time for each operation except for Insert, for which a O(lg n) bound holds.

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.

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.