We present results of an empirical investigation into the performance of two O(nlogn) worst-case optimal Delaunay triangulation algorithms: a divide-andconquer algorithm and a plane-sweep algorithm. We present improvements which give a factor of 4-5 speedup to the divide-and-conquer algorithm and a factor of 13-16 speed-up to the plane-sweep algorithm. Experiments using our improved implementations of both algorithms show the plane-sweep algorithm to be slightly faster (about 20%) than the divide-andconquer algorithm across a range of distributions. Using our fastest implementation of the plane-sweep algorithm a set of points can be triangulated in 7-8 times the time it takes to (merge) sort them.

Amortization has been underutilized in the design of persistent data structures, largely because traditional accounting schemes break down in a persistent setting. Such schemes depend on saving "credits" for future use, but a persistent data structure may have multiple "futures", each competing for the same credits. We describe how lazy evaluation can often remedy this problem, yielding persistent data structures with good amortized efficiency. In fact, such data structures can be implemented purely functionally in any functional language supporting lazy evaluation. As an example of this technique, we present a purely functional (and therefore persistent) implementation of lists that simultaneously support catenation and all other usual list primitives in constant amortized time. This data structure is much simpler than the only existing data structure with comparable bounds, the recently discovered catenable lists of Kaplan and Tarjan, which support all operations in constant worst-ca...

We give a variation of the pairing heaps for which the time bounds for all the operations match the lower bound proved by Fredman for a family of similar self-adjusting heaps. Namely, our heap structure requires O(1) for insert and findmin, O(log n) for delete-min, and O(log log n) for decreasekey and meld (all the bounds are in the amortized sense except for find-min). 1

In the last three decades a considerable amount of research has been pursued in the efficient implementation of the pending event set (PES) associated with discrete-event simulation. The reason is simple: a fast event management has a very crucial impact in the total running time of both sequential and parallel simulations. This report focuses on this problem by studying the empirical performance of a number of solutions to the PES implementation in which we include a complete binary tree described in [26], 1 Introduction The PES is defined as the set of all the events generated during a discrete-event simulation and whose occurrence have not been simulated yet. In order to determine the next event to take place, it is necessary to extract the event with the least time from the PES. We call this operation extract-min. On the other hand, the occurrence of any event during the simulation can produce the insertion of new pending or future events in the PES; insert operation. These two b...

In this paper we present and analyze functional programs for a number of priority queue operations. These programs are based upon the topdown skew heaps---a truly elegant data structure---designed by D.D. Sleator and R.E. Tarjan. We show how their potential technique can be used to determine the time complexity of functional programs. This functional approach enables us to derive a potential function leading to tighter bounds for the amortized costs of the priority queue operations. From the improved bounds it follows, for instance, that Skewsort, a simple sorting program using these operations, requires only about 1:44Nlog 2 N comparisons to sort N numbers (in the worst case). 1 Amortized complexity in a functional setting By means of a simple example we explain how the potential technique of Sleator and Tarjan [7] can be used to determine the time complexity of functional programs. In this example lists of zeros and ones are used as binary representations of natural numbers. We deno...

Abstract. Finding the sub-vector with the largest sum in a sequence of n numbers is known as the maximum sum problem. Finding the k sub-vectors with the largest sums is a natural extension of this, and is known as the k maximal sums problem. In this paper we design an optimal O(n+k) time algorithm for the k maximal sums problem. We use this algorithm to obtain algorithms solving the two-dimensional k maximal sums problem in O(m 2 ·n+k) time, where the input is an m ×n matrix with m ≤ n. We generalize this algorithm to solve the d-dimensional problem in O(n 2d−1 +k) time. The space usage of all the algorithms can be reduced to O(n d−1 + k). This leads to the first algorithm for the k maximal sums problem in one dimension using O(n + k) time and O(k) space. 1

We present a highly concurrent priority queue algorithm based on the B-link tree, which is a B + -tree in which every node has a pointer to its right sibling. The algorithm is built on the concurrent B-link tree algorithms proposed by Lehman and Yao [15] and Sagiv [19]. Since the priority queue is based on highly concurrent search structure algorithms, a large number of insert operations can execute concurrently with little or no interference. We present two algorithms for executing the deletemin operation. The first algorithm executes deletemin operations serially, but we show that it can support a higher throughput that previous shared memory concurrent priority queue algorithms because most deletemin operations execute very quickly. The second deletemin algorithm uses the fetch-and-add operation to allow several deletemin operations to execute concurrently, and can support a much higher throughput. 1 Introduction A priority queue handles two operations: insert and deletemin. The ...

. In this paper, we make a proposal for a second year course on advanced programming, based on the functional paradigm. It assumes the existence of a first course on programming, also based on functional languages. Its main subject is data structures. We claim that advanced data structures and algorithms can be better taught at the functional paradigm than at the imperative one, and that this can be done without losing efficiency. We also claim that, as a consequence of the higher level of abstraction of functional languages, more subjects can be covered in the given amount of time. In the paper, numerous examples of unusual data structures and algorithms are presented illustrating the contents and the philosophy of the proposed course. 1 Introduction The controversy about the use of a functional language as the first programming language is still alive. Several proposals have been made on a first programming course based on the functional paradigm or on a mixture of the functional a...

this paper we study the performance of the very first tournament based complete binary tree. We focus on discrete-event simulation and our results show that this unknown predecessor of heaps can be a more efficient alternative to the fastest pending event set implementations reported in the literature. We also extend the idea of binary tournaments to a (2; L)-tournament structure which exhibits the property of delaying the processing of events with larger timestamps whilst it keeps similar theoretical performance bounds to the native (2; 1)-structure or CBT. This property can be certainly useful in systems where many pending events are expected to be deleted or rescheduled during the simulation. 2 Tournament trees

The bulk-synchronous parallel (BSP) model of computing has been proposed to enable the development of portable software which achieves scalable performance across diverse parallel architectures. A number of applications of computing science have been demonstrated to be efficiently supported by the BSP model in practice.