# Jyrki Katajainen's research while affiliated with IT University of Copenhagen and other places

## Publications (121)

Article
Full-text available
We formalize several regular numeral systems, state their properties and supported operations, clarify the correctness, and tabulate the proofs. Our goal is to use as few symbols in the presentation of digits and make as few digit changes as possible in every operation. Most importantly, we introduce two new systems: (1) the buffered regular system...
Chapter
In the convex-hull problem, in two-dimensional space, the task is to find, for a given sequence S of n points, the smallest convex polygon for which each point of S is either in its interior or on its boundary. In this paper, we propose a variant of the classical bucketing algorithm that (1) solves the convex-hull problem for any multiset of points...
Chapter
Before the era of ubiquitous computers, the long-division method was presented in primary schools as a paper-and-pencil technique to do whole-number division. In the book “Hacker’s Delight” by Warren [2nd edition, 2013], an implementation of this algorithm was given using the C programming language. In this paper we will report our experiences when...
Article
Full-text available
From a broad perspective, we study issues related to implementation, testing, and experimentation in the context of geometric algorithms. Our focus is on the effect of quality of implementation on experimental results. More concisely, we study algorithms that compute convex hulls for a multiset of points in the plane. We introduce several improveme...
Article
Full-text available
Article
Full-text available
We describe a heap data structure that supports Minimum, Insert, and Borrow at O(1) worst-case cost, Delete at O(lgn) worst-case cost including at most lgn + O(1) element comparisons, and Union at O(lgn) worst-case cost including at most lgn + O(lglgn) element comparisons, where n denotes the (total) number of elements stored in the data structure(...
Article
Full-text available
We study the problem of constructing a binary heap in an array using only a small amount of additional space. Let N denote the size of the input, M the capacity of the cache, and B the width of the cache lines of the underlying computer, all measured as numbers of elements. We show that there exists an in-place heap-construction algorithm that runs...
Article
Even a rough literature review reveals that there are many alternative ways of implementing a binary heap, the fundamental priority-queue structure loved by us all. Which one of these alternatives is the best in practice? The opinions of crowd-pullers and textbook authors are aligned: use an array. Of course, the correct answer is ‘it depends’. To...
Conference Paper
The basic operations of a dynamic array are operator[ ], push_back, and pop_back. This study is an examination of variations of dynamic arrays that support these operations at O(1) worst-case cost. In the literature, many solutions have been proposed, but little information is available on their mutual superiority. Most library implementations only...
Article
Path decompositions of graphs are an important ingredient of dynamic programming algorithms for solving efficiently many NP-hard problems. Therefore, computing the pathwidth and associated path decomposition of graphs has both a theoretical and practical interest. In this article, we design a branch-and-bound algorithm that computes the exact pathw...
Article
Full-text available
We consider space-bounded computations on a random-access machine (RAM) where the input is given on a read-only random-access medium, the output is to be produced to a write-only sequential-access medium, and the available workspace allows random reads and writes but is of limited capacity. The length of the input is $N$ elements, the length of the...
Conference Paper
Full-text available
An in-place priority queue is a data structure that is stored in an array, uses constant extra space in addition to the array elements, and supports the operations $$top$$ ($$find$$-$$min$$), $$push$$ ($$insert$$), and $$pop$$ ($$delete$$-$$min$$). In this paper we introduce an in-place priority queue, for which $$top$$ and $$pus... Article Full-text available Let n denote the number of elements currently in a data structure. An in-place heap is stored in the first n locations of an array, uses O(1) extra space, and supports the operations: minimum, insert, and extract-min. We introduce an in-place heap, for which minimum and insert take O(1) worst-case time, and extract-min takes O(\lg{} n) wo... Conference Paper Given an unordered array of N elements drawn from a totally ordered set and an integer k in the range from 1 to N, in the classic selection problem the task is to find the k-th smallest element in the array. We study the complexity of this problem in the space-restricted random-access model: The input array is stored on read-only memory,... Article A weak heap is a priority queue that supports the operations construct, minimum, insert, and extract-minextract-min. To store n elements, it uses an array of n elements and an array of n bits. In this paper we study different possibilities for optimizing construct and insert such that minimum and extract-minextract-min are not made slower. We provi... Conference Paper Full-text available We introduce a binary counter that supports increments and decrements in O(1) worst-case time per operation. (We assume that arithmetic operations on an index variable that is stored in one computer word can be performed in O(1) time each.) To represent any integer in the range from 0 to 2n − 1, our counter uses an array of at most n bits plus few... Conference Paper Full-text available A weak heap is a variant of a binary heap where, for each node, the heap ordering is enforced only for one of its two children. In 1993, Dutton showed that this data structure yields a simple worst-case-efficient sorting algorithm. In this paper we review the refinements proposed to the basic data structure that improve the efficiency even further.... Conference Paper Full-text available It was reported in a study by Brodal and Moruz that, due to branch mispredictions, skewed search trees may perform better than perfectly balanced search trees. In this paper we take the search procedures under microscopic examination, and show that perfectly balanced search trees—when programmed carefully—are better than skewed search trees. As in... Conference Paper Full-text available We revisit the random-access-machine model in which the input is given on a read-only random-access media, the output is to be produced to a write-only sequential-access media, and in addition there is a limited random-access workspace. The length of the input is N elements, the length of the output is limited by the computation itself, and the cap... Conference Paper Full-text available In this paper we deal with compressed integer arrays that are equipped with fast random access. Our treatment improves over an earlier approach that used address-calculation coding to locate the elements and supported access and search operations in time for a sequence of n non-negative integers summing up to s . The idea is to complement the addre... Article The weak heap is a priority queue that was introduced as a competitive structure for sorting. Its array-based form supports the operations find-min in O(1) worst-case time, and insert and delete-min in O(lgn) worst-case time using at most ⌈lgn⌉ element comparisons. Additionally, its pointer-based form supports delete and decrease in O(lgn) worst-ca... Conference Paper Full-text available We show how to build a binary heap in-place in linear time by performing ˜ 1.625n element comparisons, at most ˜ 2.125n element moves, and ˜ n/B cache misses, where n is the size of the input array, B the capacity of the cache line, and ˜ f(n) approaches f(n) as n grows. The same bound for element comparisons was derived and conjectured to be optim... Conference Paper Full-text available An array-based weak heap is an efficient data structure for realizing an elementary priority queue. In this paper we focus on the construction of a weak heap. Starting from a straightforward algorithm, we end up with a catalogue of algorithms that optimize the standard algorithm in different ways. As the optimization criteria, we consider how to re... Conference Paper Full-text available We consider the classical problem of representing a collection of priority queues under the operations \Findmin{}, \Insert{}, \Decrease{}, \Meld{}, \Delete{}, and \Deletemin{}. In the comparison-based model, if the first four operations are to be supported in constant time, the last two operations must take at least logarithmic time. Brodal showed... Conference Paper Full-text available In quicksort, due to branch mispredictions, a skewed pivot-selection strategy can lead to a better performance than the exact-median pivot-selection strategy, even if the exact median is given for free. In this paper we investigate the effect of branch mispredictions on the behaviour of mergesort. By decoupling element comparisons from branches, we... Conference Paper Full-text available According to a folk theorem, every program can be trans-formed into a program that produces the same output and only has one loop. We generalize this to a form where the resulting program has one loop and no other branches than the one associated with the loop con-trol. For this branch, branch prediction is easy even for a static branch predictor.... Conference Paper Full-text available We introduce a variant of fat heaps that does not rely on regular counters, and still achieves the optimal worst-case bounds: O(1) for find-min, insert and decrease, and O(lgn) for delete and delete-min. Our variant is simpler to explain, more efficient, and easier to implement. Experimental results suggest that our implementation is superior to st... Conference Paper Full-text available In typical applications, a priority queue is used to execute a sequence of n insert, m decrease, and n delete-min operations, starting with an empty structure. We study the performance of different priority queues for this type of operation sequences both theoretically and experimentally. In particular, we focus on weak heaps, weak queues, and thei... Conference Paper Full-text available A graphbase, a term coined by Knuth [7], is a database of graphs and computer programs that generate, analyze, manipulate, and visualize graphs. The terms graph library and graph archive are often used as synonyms for this term. Our vision is to provide an infrastructure and quality standards for a public graphbase, named the Open Graph Archive, th... Article Full-text available We introduce two numeral systems, the magical skew system and the regular skew system, and contribute to their theory development. For both systems, increments and decrements are supported using a constant number of digit changes per operation. Moreover, for the regular skew system, the operation of adding two numbers is supported efficiently. Our... Conference Paper Full-text available In this paper we introduce two efficient priority queues. For both, insert requires O(1) amortized time and extract-min \(O(\lg n)$$ worst-case time including at most $$\lg n + O(1)$$ element comparisons, where n is the number of elements stored. One priority queue is based on a weak heap (array-based) and the other on a weak queue (pointer-based)....
Article
We develop a data structure for maintaining a dynamic multiset that uses O(nlglgn/lgn) bits and O(1) words, in addition to the space required by the n elements stored, supports searches in O(lgn) worst-case time and updates in O(lgn) amortized time. Compared to earlier data structures, we improve the space requirements from O(n) bits to O(nlglgn/lg...
Conference Paper
Full-text available
We introduce a new number system that we call the strictly-regular system, which efficiently supports the operations: digit-increment, digit-decrement, cut, concatenate, and add. Compared to other number systems, the strictly-regular system has distinguishable properties. It is superior to the regular system for its efficient support to decrements,...
Conference Paper
Full-text available
We introduce a new number system that supports increments with a constant number of digit changes. We also give a simple method that extends any number system supporting increments to support decrements using the same number of digit changes. In the new number system the weight of the ith digit is 2 i − 1, and hence we can implement a priority queu...
Conference Paper
In this paper we describe an experimental study where we evaluated the practical efficiency of three worst-case efficient priority queues: 1) a weak heap that is a binary tree fulfilling half-heap ordering, 2) a weak queue that is a forest of perfect weak heaps, and 3) a run-relaxed weak queue that extends a weak queue by allowing some nodes to vio...
Article
The CPH STL is a special edition of the STL, the containers and algorithms part of the C++ standard library. The specification of the generic components of the STL is given in the C++ standard. Any implementation of the STL, e.g. the one that ships with your standard-compliant C++ compiler, should provide at least one realization for each container...
Article
This is an electronic appendix to the article "Policy-based benchmark-ing of weak heaps and their relatives". The report contains the programs related to our priority-queue frameworks. Look at the CPH STL reports 2009-3 and 2009-4 to see examples of other component frameworks.
Article
Full-text available
We introduce two data-structural transformations to construct double-ended priority queues from priority queues. To apply our transformations the priority queues exploited must support the extraction of an unspecified element, in addition to the standard priority-queue operations. With the first transformation we obtain a double-ended priority queu...
Article
Full-text available
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 del...
Conference Paper
Full-text available
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, im...
Article
Full-text available
We describe a number of alternative implementations for the heap functions, which are part of the C++ standard library, and provide a through experimental evaluation of their performance. In our bench-marking framework the heap functions are implemented using the same set of utility functions, the utility functions using the same set of policy func...
Article
Full-text available
In this paper we present a cache-aware realization of a priority queue, named a local heap, which is a slight modification of a standard binary heap. The new data structure is cache efficient, has a small computational overhead, and achieves a good worst-case performance with respect to the number of element comparisons and the number of element mo...
Article
Trajectory data is becoming increasingly available and the size of the trajectories is getting larger. In this paper we study the problem of compressing spatio-temporal trajectories such that the most common queries can still be answered approximately after the compression step has taken place. In the process we develop an O(n logk n)-time implemen...
Article
The Standard Template Library (STL) is a collection of generic algo- rithms and data structures that is part of the standard run-time environment of the C++ programming language. The STL provides four kinds of associative elem- ent containers: set, multiset, map, and multimap. In this project the goal is to develop an associative container that is...
Article
An operation on an element container is said to provide a strong guar- antee of exception safety if, in case an exception is thrown, the operation leaves the container in the state in which it was before the operation. In this paper, we explore how to adjust operations on C++ standard-library containers to provide the strong guarantee of exception...
Conference Paper
Full-text available
We give a priority queue that guarantees the worst- case cost of (1) per minimum nding, insertion, and decrease; and the worst-case cost of (lg n) with at most lg n + O( p lg n) element comparisons per dele- tion. Here, n denotes the number of elements stored in the data structure prior to the operation in ques- tion, and lg n is a shorthand for ma...
Conference Paper
The problem of designing space-efficient parallel merging algorithms is examined. It is shown that two sorted sequences of lengths m and n, mn, can be merged in O(n/p+log n) time on an EREW PRAM with p processors, using only a constant amount of extra storage per processor. After a slight modification, the algorithm runs on a DCM (Direct Connection...
Article
Full-text available
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 double- ended priority queue which guarantees the wo...
Article
Full-text available
Article
Full-text available
A simplification of a run-relaxed heap, called a relaxed weak queue, is presented. This new priority-queue implementation supports all operations as efficiently as the original:find-min, insert, and decrease (also called decrease-key) in O(1) worst-case time, and delete in O(lgn) worst-case time, n denoting the number of elements stored prior to th...
Article
The Standard Template Library (STL) is a library of generic algorithms and data structures that has been incorporated in the C++ standard and ships with all modern C++ compilers. In the CPH STL project the goal is to implement an enhanced edition of the STL. The priority-queue class of the STL is just an adapter that makes any resizable array to a...
Article
A space-efficient algorithm is one in which the output is given in the same location as the input and only a small amount of additional memory is used by the algorithm. We describe four space-efficient algorithms for computing the convex hull of a planar point set.
Article
Full-text available
We introduce a framework for reducing the number of element compari-sons 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,...
Article
We present a general framework for computing various optimal embeddings of undirected and directed connected graphs in two and multi-dimensional integer lattices in time sub-exponential either in the minimum number n of lattice points used by such optimal embeddings or in the budget upper bound b on the number of lattice points that may be used in...
Article
Full-text available
A data structure, named a navigation pile, is described and exploited in the implementation of a sorting algorithm, a priority queue, and a priority deque. When carrying out these tasks, a linear number of bits is used in addition to the elements manipulated, and extra space for a sublinear number of elements is allocated if the grow and shrink ope...
Conference Paper
We study the behaviour of an algorithm which compresses relational tables by representing common subspaces as Cartesian products. The output produced allows space to be saved while preserving the functionality of many relational operations such as select, project and join. We describe an implementation of an existing algorithm, propose a slight mod...
Conference Paper
A variant of the classical selection problem, called the positioning problem, is considered. In this problem we are given a sequence A[1:n] of size n, an integer k, 1 ≤ k ≤ n, and an ordering function ⧀, and the task is to rearrange the elements of the sequence such that A[k] ⧀ A[j] is false for all j, 1 ≤ j k, and A[l] ⧀ A[k] is false for all l, k...
Conference Paper
Full-text available
An in-place algorithm is one in which the output is given in the same location as the input and only a small amount of additional memory is used by the algorithm. In this paper we describe three in-place algorithms for computing the convex hull of a planar point set. All three algorithms are optimal, some more so than others.
Conference Paper
A new realization of a space-efficient deque is presented. The data structure is constructed from three singly resizable arrays, each of which is a blockwise-allocated pile (a heap without the order property). The data structure is easily explainable provided that one knows the classical heap concept. All core deque operations are performed in O(1)...
Article
Two in-place variants of the classical mergesort algorithm are analysed in detail. The first, straightforward variant performs at most N log 2 N + O(N ) comparisons and 3N log 2 N + O(N ) moves to sort N elements. The second, more advanced variant requires at most N log 2 N + O(N ) comparisons and "N log 2 N moves, for any fixed " ? 0 and any N ? N...
Conference Paper
In a decision tree model, Ω(n log2n − ∑ mi=1 n i log2n i + n) is known to be a lower bound for sorting a multiset of size n containing m distinct elements, where the ith distinct element appears n t times. We present a minimum space algorithm that sorts stably a multiset in asymptotically optimal worst-case time. A Quicksort type approach is used,...
Conference Paper
The problem of interchanging tw segments of an array is considered.Using the known methods as a starting-point, two new adaptations are developed that achieve higher memory locality. It is confirmed, both analytically and experimentally, that on a computer with a hierarchical memory the adaptations are superior to the earlier methods.
Article
Two new linear-time algorithms for in-place merging are presented. Both algorithms perform at most (1 + t)m + n/2 2 + o(m) element comparisons, where m and n are the sizes of the input sequences, m ⩽ n, and t = ILlog 2(n/m)⌋. The first algorithm is for unstable merging and it carries out no more than 4(m + n) + o(n) element moves. The second algori...
Article
this paper we study, both analytically and experimentally, the performance of programs that construct a binary heap [Williams 1964] in a hierarchical memory system. Especially, we consider the largest memory level that is too small to fit the whole heap. We call that particular level simply the cache. It should, however, be emphasized that our anal...
Article
A heap structure designed for secondary storage is suggested that tries to make the best use of the available buffer space in primary memory. The heap is a complete multi-way tree, with multi-page blocks of records as nodes, satisfying a generalized heap property. A special feature of the tree is that the nodes may be partially filled, as in B-tree...
Article
It is shown that an array of n elements can be sorted using O(1) extra space, O(nlogn/loglogn) element moves, and nlog2n+O(nloglogn) comparisons. This is the first in-place sorting algorithm requiring o(nlogn) moves in the worst case while guaranteeing O(nlogn) comparisons, but due to the constant factors involved the algorithm is predominantly of...
Article
We show that if a flow network has k input/output terminals (for the traditional maximum-flow problem, k=2), its external flow pattern (the possible values of flow into and out of the terminals) has two characterizations of size independent of the total number of vertices: a set of 2k+1 inequalities in k variables representing flow values at the te...
Conference Paper
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 giv...
Article
. A variant of Heapsort---named Ultimate Heapsort---is presented that sorts n elements in-place in Theta(n log 2 (n+ 1)) worst-case time by performing at most n log 2 n + Theta(n) key comparisons and n log 2 n + Theta(n) element moves. The secret behind Ultimate Heapsort is that it occasionally transforms the heap it operates with to a two-layer he...
Article
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 giv...
Article
The following two computational problems are studied: Duplicate grouping: Assume that n items are given, each of which is labeled by an integer key from the set {0,...,U -1}. Store the items in an array of size n such that items with the same key occupy a contiguous segment of the array. Closest pair: Assume that a multiset of n points in the d-dim...
Article
The efficiency of mergesort programs is analysed under a simple unit-cost model. In our analysis the time performance of the sorting programs includes the costs of key comparisons, element moves and address calcula- tions. The goal is to establish the best possible time-bound relative to the model when sorting n integers. By the well-known informat...
Article
We show that if a flow network has k input/output terminals (for the traditional maximum-flow problem, k = 2), its external flow pattern (the possible values of flow into and out of the terminals) has two characterizations of size independent of the total number of vertices: a set of 2 k + 1 inequalities in k variables representing flow values at t...
Conference Paper
Full-text available
The minimum-redundancy prefix code problem is to determine a list of integer codeword lengths l=[l i¦iε{1... n}], given a list of n symbol weights p=[pi¦iε{1...n}], such that $$\sum\nolimits_{i = 1}^n {2^{ - l_i } } \leqslant 1$$, and $$\sum\nolimits_{i = 1}^n {l_i p_i }$$ l ipi is minimised. An extension is the minimum-redundancy length-limited pr...
Conference Paper
The optimal prefixfree code problem is to determine, for a given array p=[p i ¦i∈{1...n}] of n weights, an integer array l= [l i ¦∈{1...n}] of n codeword lengths such that $$\sum\nolimits_{i = 1}^n {2^{ - l_i } \leqslant 1}$$and $$\sum\nolimits_{i = 1}^n {p_i l_i }$$is minmized. Huffman's famous greedy algorithm solves this problem in O(n log n) ti...
Conference Paper
Shows that the use of the lazy list processing technique from the world of functional languages allows, under certain conditions, the package-merge algorithm to be executed in much less space than is indicated by the O(nL) space worst-case bound. For example, the revised implementation generates a 32-bit limited code for the TREC distribution withi...
Article
We show that if a flow network has k input/output terminals (for the traditional maximum-flow problem, k = 2), its external flow pattern (possible values of flow at the terminals) has two characterizations of size independent of the total number of vertices: a set of at most 2 inequalities in k variables representing flow values at the terminals, a...
Article
We show that if a flow network has k input/output terminals (for the traditional maximum-flow problem, k = 2), its external flow pattern (possible values of flow at the terminals) has two characterizations of size independent of the total number of vertices: a set of at most 2 k inequalities in k variables representing flow values at the terminals,...
Article
We consider the problem of sorting a multiset of sizen containingm distinct elements, where theith distinct element appearsn i times. Under the assumption that our model of computation allows only the operations of comparing elements and moving elements in the memory,(n logn – i=1 m n i logn i +n) is known to be a lower bound for the computa...
Article
Le probleme de la conception d'un algorithme de fusion parallele performant en espace est etudie. Il est montre que deux suites triees de longueur m et n, m ≤ n peuvent etre fusionnee en temps O(n/p + log n) sur un modele PRAM a lecture et ecriture exclusives avec p processeurs, en utilisant une quantite de memoire supplementaire constante par proc...
Article
In the stable0–1 sorting problem the task is to sort an array ofn elements with two distinct values such that equal elements retain their relative input order. Recently, Munro, Raman and Salowe gave an algorithm which solves this problem inO(n log*n) time and constant extra space. We show that by a modification of their method the stable0–1 sorting...
Conference Paper
Article
Text compression is often done using a fixed, previously formed dictionary (code book) that expresses which substrings of the text can be replaced by code words. There always exists an optimal solution for text-encoding problem. Due to the long processing times of the various optimal algorithms, several heuristics have been proposed in the literatu...
Conference Paper
We introduce the first sorting algorithm that is proven to sort n randomly drawn uniformly distributed elements in (n) time in situ. The constants in this algorithm are small, and simulations have shown it competitive with other sorting algorithms. It is, furthermore, conceptually simple and easy to code, which makes it a practical distributive sor...
Article
Standard median filtering that is searched repeatedly for a median from a sample set which changes only slightly between the subsequent searches is discussed. Several well-known methods for solving this running median problem are reviewed, the (asymptotical) time complexities of the methods are analyzed, and simple variants are proposed which are e...
Article
Full-text available
Different methods for compressing trees are surveyed and developed. Tree compression can be seen as a trade-off problem between time and space in which we can choose different strategies depending on whether we prefer better compression results or more efficient operations in the compressed structure. Of special interest is the case where space can...
Article
We present a parallel algorithm for finding the convex hull of a sorted set of points in the plane. Our algorithm runs inO(logn/log logn) time usingO(n log logn/logn) processors in theCommon crcw pram computational model, which is shown to be time and cost optimal. The algorithm is based onn 1/3 divide-and-conquer and uses a simple pointer-based da...
Article
This paper deals with the space requirements of tries. We give a simple proof for the fact that the space minimization problem related to a trie compaction method proposed by M. Al-Suwaiyel and E. Horowitz [ACM Trans. Database Syst. 9, 243-263 (1984; Zbl 0542.68079)] is NP- complete.
Article
In many situations text compression is carried out with a previously formed fixed dictionary (code book) expressing those often-occurring substrings of a text which are to be replaced by code words. The problem of encoding a text in a space-optimal manner is equivalent to the problem of finding a shortest path between a given pair of vertices in an...
Conference Paper
Two measures of presortedness, Dist(X) and logDist(X), are presented. The measures are motivated by a geometric interpretation of the input sequence X. Using these measures, an exact characterization of the local insertion sort algorithm of Mannila is achieved. Variants of local insertion sort, using many fingers (i.e., pointers into a finger searc...
Article
In this paper the divide-and-conquer approach to the two-dimensional closest-pair problem is studied. A new algorithm is proposed by which a closest pair, i.e. a pair of points whose distance δ is smallest among a set of N points, is found in θ(N) expected time when the points are drawn independently from the uniform distribution in a unit square....
Conference Paper
We present a parallel algorithm which constructs the Voronoi diagram of a planar n-point set within a square window. When the points are independently drawn from a uniform distribution, the algorithm runs in O(log n) expected time on CRCW PRAM with O(n/log n) processors. The fast operation of the algorithm results from the efficiency of a new multi...
Article
Recently Rex Dwyer [D87] presented an algorithm which constructs a Delaunay triangulation for a planar set of N sites in O(N log log N) expected time and O(N log N) worst-case time. We show that a slight modification of his algorithm preserves the worst-case running time, but has only O(N) average running time. The methcxl is a hybrid which combine...

## Citations

... So an elimination procedure should not be complicated. In a follow-up paper [51], we implemented a BUCKETING algorithm ( [52], Section 4.4), for which the elimination overhead is three scans and the elimination effectiveness is better than that for the THROW-AWAY algorithm. The work space used by this algorithm is O( √ n) words, but because of random access its competitive advantage may fade away when the problem size becomes large. ...
... In order to have a better understanding of the computational resources required to compute the collision free c-map, let us take into account the same two link planar robot, but with just one polygonal obstacle in the scene (Figure 10). Finding whether the robot collides with a polygonal obstacle is way more expensive as described in book [9,10]. The number of edges of the obstacle covers an important role, but in this chapter every polygonal obstacle is assumed to be defined by no more than 5 edges for sake of simplicity. ...
... Even though Borrow is a non-standard operation, its importance has been demonstrated in several papers (see, for example, [14,19,20,25,36]). ...
... Lastly, we implemented our proposed heuristic-based priority experience replay (hPER) by utilizing a binary heap structure. The insertion operation in a binary heap has a worst-case complexity of O(log n), where n being the number of current elements in the replay memory, and average-case complexity of O(1) [51]. ...
... A k-way merge can be achieved by utilizing a 2-way merge within a binary merging tree. In the first level of this tree, the bottom level, each two consecutive sequences are merged sequentially [13] or in parallel [15,19]. Thus, the k sequences are reduced to k/2 sequences. ...