. A priority queue Q is a data structure that maintains a collection of elements, each element having an associated priority drawn from a totally ordered universe, under the operations Insert, which inserts an element into Q, and DeleteMin, which deletes an element with the minimum priority from Q. In this paper a priority-queue implementation is given which is efficient with respect to the number of block transfers or I/Os performed between the internal and external memories of a computer. Let B and M denote the respective capacity of a block and the internal memory measured in elements. The developed data structure handles any intermixed sequence of Insert and DeleteMin operations such that in every disjoint interval of B consecutive priorityqueue operations at most c log M=B N M I/Os are performed, for some positive constant c. These I/Os are divided evenly among the operations: if B c log M=B N M , one I/O is necessary for every B=(c log M=B N M )th operation ...

Simulation time is often the bottleneck in the cache design process. In this paper, algorithms for the efficient simulation of direct mapped and set associative caches are presented. Two classes of direct mapped caches are considered: fixed line size caches and fixed size caches. A binomial tree representation of the caches in each class is introduced. The fixed line size class is considered for set associative caches. A generalization of the binomial tree data structure is introduced and the fixed line size class of set associative caches is represented using the generalized binomial tree. Algorithms are developed that use the data structures to determine miss ratios for the caches in each class. Analytical and empirical comparisons of the algorithms to previously published algorithms such as all-associativity and forest simulation are presented. Analytically it is shown that the new algorithms always perform better than earlier algorithms. Empirically, the new algorithms are shown to...

Brodal recently introduced the first implementation of imperative priority queues to support findMin, insert, and meld in O(1) worst-case time, and deleteMin in O(log n) worst-case time. These bounds are asymptotically optimal among all comparison-based priority queues. In this paper, we adapt Brodal's data structure to a purely functional setting. In doing so, we both simplify the data structure and clarify its relationship to the binomial queues of Vuillemin, which support all four operations in O(log n) time. Specifically, we derive our implementation from binomial queues in three steps: first, we reduce the running time of insert to O(1) by eliminating the possibility of cascading links; second, we reduce the running time of findMin to O(1) by adding a global root to hold the minimum element; and finally, we reduce the running time of meld to O(1) by allowing priority queues to contain other priority queues. Each of these steps is expressed using ML-style functors. The last transformation, known as data-structural bootstrapping, is an interesting application of higher-order functors and recursive structures.

We consider the information complexity of learning in metric spaces. We discuss two models of such learning processes. The first one is the Learning By Distances (LBD) model of Ben-David et al [BIK]. In this model a concept is a point in a metric space, at each step of the learning process the student offers a hypothesis and receives from the teacher an approximation of its distance to the target. We also present a new Relative Distances (RD) model. In this model, at each step, the student presents two points and receives a bit indicating which of them is closer to the target. We investigate the learning complexity in both models. We provide general lower and upper bounds on the complexity of learning concept classes in these models. We then analyze the complexity of several natural concept classes in two metric spaces; the space of boolean formulas with the metric induced by the number of satisfying assignments and spaces defined on graphs with the metric induced by the length of the shortest path between pairs of nodes. 1

Efficient implementations of priority queues can often be clumsy beasts. We express a functional implementation of binomial queues which is both elegant and efficient. We also quantify some of the differences with other functional implementations. The operations decreaseKey and delete always pose a problem without destructive update, we show how our implementation may be extended to express these. 1 Functional priority queues A crucial part of many algorithms is the data structure that is used. Frequently, an algorithm needs an abstract data type providing a number of primitive operations on a data structure. A priority queue is one such data structure that is used by a number of algorithms. Applications include, Dijkstra's [4] algorithm for single-source shortest paths, and the minimum cost spanning tree problem (see Tarjan [12] for a discussion of minimumspanning tree algorithms). See Knuth [8] and Aho et al [1] for many other applications of priority queues. A priority queue is a ...

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

Part of this work has been presented in [17]. This paper analyzes the performances of portable distributed priority queues by examining the theoretical features required and by comparing various implementations. In spite of intrinsic bottlenecks and induced hot-spots, we argue that tree topologies are attractive to manage the natural centralized control required for the deletemin operation in order to detect the site which holds the item with the largest priority. We introduce an original perfect balancing to cope with the load variation due to the priority queue operations which continuously modify the overall number of items in the network. For comparison, we introduce the d-heap and the binomial distributed priority queue. The purpose of this experiment is to convey, through executions on Cray-T3D and MeikoT800, an understanding of the nature of the distributed priority queues, the range of their concurrency and a comparison of their efficiency to reduce requests latency. In particu...

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

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.