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

**What is this page?**

This page lists the scientific contributions of an author, who either does not have a ResearchGate profile, or has not yet added these contributions to their profile.

It was automatically created by ResearchGate to create a record of this author's body of work. We create such pages to advance our goal of creating and maintaining the most comprehensive scientific repository possible. In doing so, we process publicly available (personal) data relating to the author as a member of the scientific community.

If you're a ResearchGate member, you can follow this page to keep up with this author's work.

If you are this author, and you don't want us to display this page anymore, please let us know.

It was automatically created by ResearchGate to create a record of this author's body of work. We create such pages to advance our goal of creating and maintaining the most comprehensive scientific repository possible. In doing so, we process publicly available (personal) data relating to the author as a member of the scientific community.

If you're a ResearchGate member, you can follow this page to keep up with this author's work.

If you are this author, and you don't want us to display this page anymore, please let us know.

## Publications (121)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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.

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

Reference: Regular numeral systems for data structures

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