this paper, we are concerned primarily with the insert and delete min operations. The different data structures that have been proposed for the representation of a priority queue differ in terms of the performance guarantees they provide. Some guarantee good performance on a per operation basis while others do this only in the amortized sense. Heaps permit one to delete the min element and insert an arbitrary element into an n element priority queue in O(logn) time per operation; a find min takes O(1) time. Additionally, a heap is an implicit data structure that has no storage overhead associated with it. All other priority queue structures are pointer-based and so require additional storage for the pointers. Leftist trees also support the insert and delete min operations in O(log n) time per operation and the find min operation in O(1) time. Additionally, they permit us to meld pairs of priority queues in logarithmic time

We present 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). They can be implemented on the pointer machine and require linear space. The time bounds are optimal for all implementations where Meld takes worst case time o(n).

Abstract. Two new ways of transforming a priority queue into a double-ended priority queue are introduced. These methods can be used to improve all known bounds for the comparison complexity of double-ended priority-queue operations. Using an efficient priority queue, the first transformation can produce a doubleended priority queue which guarantees the worst-case cost of O(1) for find-min, find-max, and insert; and the worst-case cost of O(lg n) including at most lg n + O(1) element comparisons for delete, but the data structure cannot support meld efficiently. Using a meldable priority queue that supports decrease efficiently, the second transformation can produce a meldable double-ended priority queue which guarantees the worst-case cost of O(1) for find-min, find-max, and insert; the worst-case cost of O(lg n) including 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, and lg n is a shorthand for log 2 (max {2, n}). 1.

Abstract. In this project we compare the practical effectiveness of three different algorithms for “priority deques”, namely MinMax-heaps, The Deap and Interval Heaps. By implementing the algorithms and running benchmarks we find that interval heaps are the most effective, mainly due to its simplicity and similarity to standard heaps. We also discover some crucial shortcomings of Svante Carlsson’s deap algorithm and propose solutions for these. Our code is targeted towards submission to the Copenhagen STL project so we implement a “PriorityDeque”-class, in which the programmer can choose the underlying algorithm.

Median smoothing of a series of data values is considered. Naive programming of such an algorithm would result in large amount of computation, especially when the series of data values is long. By maintaining a heap structure that we update when moving along the data we obtain an optimal median smoothing algorithm.

Propagation front or grassfire methods are very popular in image processing because of their efficiency and because of their inherent geodesic nature. However, because of their random-access nature, they are inefficient in large images that cannot fit in available random access memory. In this paper, we explore ways to increase the memory efficiency of two algorithms that use propagation fronts: the skeletonization by influence zones and the watershed transform. Two algorithms are presented for the skeletonization by influence zones. The first computes the skeletonization on surfaces without storing the enclosing volume. The second performs the skeletonization without any region reference, by using only the propagation fronts. The watershed transform algorithm that was developed keeps in memory the propagation fronts and only one greylevel of the image. All three algorithms use much less memory than the ones presented in the literature so far. Several techniques have been developed in ...

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(logn) 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.

this paper is to demonstrate the generality of two techniques used in [6] to develop an MDEPQ representation from an MPQ representation - height biased leftist trees. These methods - total correspondence and leaf correspondence - may be used to arrive at efficient DEPQ and MDEPQ data structures from PQ and MPQ data structures such as the pairing heap [8; 18], Binomial and Fibonacci heaps [9], and Brodal's FMPQ [2] which also provide efficient support for the operation: --Delete(Q,p): delete and return the element located at p We begin, in Section 2, by reviewing a rather straightforward way, dual priority queues, to obtain a (M)DEPQ structure from a (M)PQ structure. This method [2; 6] simply puts each element into both a minPQ and a maxPQ. In Section 3, we describe the total correspondence method and in Section 4, we describe leaf correspondence. Both sections provide examples of PQs and MPQs and the resulting DEPQs and MDEPQs. Section 5 gives complexity results. In Section 6, we provide the result of experiments that compare the performance of the MDEPQs based on height biased leftist tree [7], pairing heaps [8; 18], and FMPQs [2]. For reference purpose, we also provide run times for the splay tree data structure [16]. Although splay trees were not specifically designed to represent DEPQs, it is easy min Heap max Heap Fig. 1. Dual heap structure to use them for this purpose. Note that splay trees do not provide efficient support for the Meld operation

In this paper we present a simple and e#cient 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 Hyer.

The influence zone transform is a fundamental tool in morphological and qualitative digital image processing. Because of its inherent geodesic properties, it is most efficiently computed using propagation front or grassfire based methods. However, when the image processed is too large to be contained in available memory, the random access nature of these algorithms makes them exceptionally inefficient. In order to alleviate this problem, we have developed two algorithms that greatly reduce the memory requirements of the transform. The first is designed specifically for computing the influence zone transform on surfaces, without storing the volume enclosing the surface. The second performs the transform using only the propagation fronts, and without storing any part of the region that is being processed. Both methods use much less memory than the ones in the literature, and thus enable the transform to be performed on much larger images than before. However, since all three algorithms use a...