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

This paper presents a very general technique for the implementation of mergeable priority queues. The amortized running time is O(log n) for DeleteMin and Delete, and \Theta(1) for all other standard operations. In particular, the operation DecreaseKey runs in amortized constant time. The worst-case running time is O(logn) or better for all operations. Several examples of mergeable priority queues are given. The examples include priority queues that are particular well suited for extenal storage. The space requirement is only two pointers and one information field per item. The technique is also used to implement mergeable, double-ended priority queues. For these queues, the worst-case time bound for insertion is \Theta(1), which improves the best previously known bound. For the other operations, the time bounds are the same as the best previously known bounds, worst-case as well as amortized. 1 Introduction A mergeable priority queue is one of the fundamental data types. It is used...

Abstract. We introduce an adaptation of run-relaxed heaps which provides efficient heap operations with respect to the number of element comparisons performed. Our data structure guarantees the worst-case cost of O(1) for find-min, insert, and decrease; and the worst-case cost of O(lg n) with at most lg n + 3 lg lg n + O(1) element comparisons for delete, improving the bound of 3lg n + O(1) on the number of element comparisons known for run-relaxed heaps. Here, n denotes the number of elements stored prior to the operation in question, and lg n equals max {1, log 2 n}. 1

The problem of determining the evolutionary history of species in the form of phylogenetic trees is known as the phylogeny problem. We present a parallelization of the character compatibility method for solving the phylogeny problem. Abstractly, the algorithm searches through all subsets of characters, which may be traits like opposable thumbs or DNA sequence values, looking for a maximal consistent subset. The notion of consistency in this case is the existence of a particular kind of phylogenetic tree called a perfect phylogeny tree. The two challenges to achieving an efficient implementation are load balancing and efficient sharing of information to enable pruning. In both cases, there is a trade-off between communication overhead and the quality of the solution. For load balancing we use a distributed task queue, which has imperfect load information but avoids centralization bottlenecks. To prune the search space, we use the following property: If a perfect phylogeny tree does not ...

Abstract. We introduce a framework for reducing the number of element comparisons performed in priority-queue operations. In particular, we give a priority queue which guarantees the worst-case 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 per minimum deletion and deletion, improving the bound of 2log n + O(1) on the number of element comparisons known for binomial queues. Here, n denotes the number of elements stored in the data structure prior to the operation in question, and log n equals max {1,log 2 n}. We also give a priority queue that provides, in addition to the above-mentioned methods, the priority-decrease (or decrease-key) method. This priority queue achieves the worst-case cost of O(1) per minimum finding, insertion, and priority decrease; and the worst-case cost of O(log n) with at most log n + O(log log n) element comparisons per minimum deletion and deletion. CR Classification. E.1 [Data Structures]: Lists, stacks, and queues; E.2 [Data

. As an alternative to the Fibonacci heap, we design a new data structure called a 2-3 heap, which supports m decrease-key, and n insert operations and delete-min operations in O(m + n log n) time. The merit of the 2-3 heap is that it is conceptually simpler and easier to implement. The new data structure will have a wide application in graph algorithms. 1 Introduction Since Fredman and Tarjan [7] published Fibonacci heaps in 1987, there has not been an easy alternative that can support n insert and delete-min operations, and m decrease-key operations in O(m+n log n) time. The relaxed heaps by Driscoll, et. al [6] have the same overall complexity with decrease-key in O(1) worst case time, but are di#cult to implement. Logarithm here is with base 2, unless otherwise specified. Two representative application areas for these operations will be the single source shortest path problem and the minimum cost spanning tree problem. Direct use of these operations in Dijkstra's [5] and Pri...

Divide--and--conquer algorithms obtain the solution to a given problem by dividing it into subproblems, solving these recursively and combining their solutions. In this paper we present a system that automatically transforms sequential divide--and--conquer algorithms written in the C programming language into parallel code which is then executed on message--passing multicomputers. The user of the system is expected to add only a few annotations to an existing sequential program. The strategies required for transforming sequential source code to executable binaries are discussed. The performance speedups attainable will be illustrated by several examples. Keywords: divide--and--conquer algorithms, automatic parallelization, parallelizing compilers, message-- passing multicomputers, transputer systems, workstation clusters Abbreviated title: Parallelization of Divide--and--Conquer Algorithms 1 Introduction The generation of efficient parallel code for message--passing multicomputer s...

This paper presents a new implementation technique for priority search queues. This abstract data type is an amazing blend of finite maps and priority queues. Our implementation supports logarithmic access to a binding with a given key and constant access to a binding with the minimum value. Priority search queues can be used, for instance, to give a simple, purely functional implementation of Dijkstra's single-source shortest-paths algorithm.

In this paper we investigate the inherent complexity of the priority queue abstract data type. We show that, under reasonable assumptions, there exist sequences of n Insert, n Delete, m DecreaseKey and t FindMin operations, where 1 t n, which have W(nlogt + n + m) complexity. Although Fibonacci heaps do not achieve this bound, we present a modified Fibonacci heap which does, and so is optimal under our assumptions.

The problem of Similarity Searching consists in finding the elements from a set which are similar to a given query under some criterion. If the similarity is expressed by means of a metric, the problem is called Metric Space Searching. In this thesis we present new methodologies to solve this problem using graphs G(V,E) to represent the metric database. In G, the set V corresponds to the objects from the metric space and E to a small subset of edges from V × V, whose weights are computed according to the metric of the space under consideration. In particular, we study k-nearest neighbor graphs (knngs). The knng is a weighted graph connecting each element from V —or equivalently, each object from the metric space — to its k nearest neighbors. We develop algorithms both to construct knngs in general metric spaces, and to use