Results 1  10
of
16
Spaceefficient geometric divideandconquer algorithms
 Comput. Geom
"... We develop a number of spaceefficient tools including an approach to simulate divideandconquer spaceefficiently, stably selecting and unselecting a subset from a sorted set, and computing the kth smallest element in one dimension from a multidimensional set that is sorted in another dimension. ..."
Abstract

Cited by 22 (4 self)
 Add to MetaCart
(Show Context)
We develop a number of spaceefficient tools including an approach to simulate divideandconquer spaceefficiently, stably selecting and unselecting a subset from a sorted set, and computing the kth smallest element in one dimension from a multidimensional set that is sorted in another dimension. We then apply these tools to solve several geometric problems that have solutions using some form of divideandconquer. Specifically, we present solutions running in O(n logn) time using O(1) extra memory given inputs of size n for the closest pair problem and the bichromatic closest pair problem. For the orthogonal line segment intersection problem, we solve the problem in O(n logn + k) time using O(1) extra space where n is the number of horizontal and vertical line segments and k is the number of intersections. 1
SpaceEfficient Algorithms for Computing the Convex Hull of a Simple Polygonal Line in Linear Time
"... We present spaceefficient algorithms for computing the convex hull of a simple polygonal line inplace, in linear time. It turns out that the problem is as hard as stable partition, i.e., if there were a truly simple solution then stable partition would also have a truly simple solution, and vice v ..."
Abstract

Cited by 18 (3 self)
 Add to MetaCart
We present spaceefficient algorithms for computing the convex hull of a simple polygonal line inplace, in linear time. It turns out that the problem is as hard as stable partition, i.e., if there were a truly simple solution then stable partition would also have a truly simple solution, and vice versa. Nevertheless, we present a simple selfcontained solution that uses O(log n) space, and indicate how to improve it to O(1) space with the same techniques used for stable partition. If the points inside the convex hull can be discarded, then there is a truly simple solution that uses a single call to stable partition, and even that call can be spared if only extreme points are desired (and not their order). If the polygonal line is closed, then the problem admits a very simple solution which does not call for stable partitioning at all.
Inplace algorithms for computing (layers of) maxima
 In: Proceedings of the 10th Scandinavian Workshop on Algorithm Theory (SWAT ’06
, 2006
"... Abstract. We describe spaceefficient algorithms for solving problems related to finding maxima among points in two and three dimensions. Our algorithms run in optimal O(n log n) time and occupy only constant extra space in addition to the space needed for representing the input. 1 ..."
Abstract

Cited by 9 (1 self)
 Add to MetaCart
(Show Context)
Abstract. We describe spaceefficient algorithms for solving problems related to finding maxima among points in two and three dimensions. Our algorithms run in optimal O(n log n) time and occupy only constant extra space in addition to the space needed for representing the input. 1
Linesegment intersection made inplace
, 2007
"... We present a spaceefficient algorithm for reporting all k intersections induced by a set of n line segments in the plane. Our algorithm is an inplace variant of Balaban’s algorithm and, in the worst case, runs in O(n log2 n+k) time using O(1) extra words of memory in addition to the space used f ..."
Abstract

Cited by 8 (2 self)
 Add to MetaCart
We present a spaceefficient algorithm for reporting all k intersections induced by a set of n line segments in the plane. Our algorithm is an inplace variant of Balaban’s algorithm and, in the worst case, runs in O(n log2 n+k) time using O(1) extra words of memory in addition to the space used for the input to the algorithm.
InSitu, Stable Merging by way of the Perfect Shuffle.
, 1999
"... We introduce a novel approach to the classical problem of insitu, stable merging, where "insitu" means the use of no more than O(log 2 n) bits of extra memory for lists of size n. Shufflemerge reduces the merging problem to the problem of realising the "perfect shuffle" permu ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
(Show Context)
We introduce a novel approach to the classical problem of insitu, stable merging, where "insitu" means the use of no more than O(log 2 n) bits of extra memory for lists of size n. Shufflemerge reduces the merging problem to the problem of realising the "perfect shuffle" permutation, that is, the exact interleaving of two, equal length lists. The algorithm is recursive, using a logarithmic number of variables, and so does not use absolutely minimum storage, i.e., a fixed number of variables. A simple method of realising the perfect shuffle uses one extra bit per element, and so is not insitu. We show that the perfect shuffle can be attained using absolutely minimum storage and in linear time, at the expense of doubling the number of moves, relative to the simple method. We note that there is a worst case for Shufflemerge requiring time\Omega\Gamma n log n), where n is the sum of the lengths of the input lists. We also present an analysis of a variant of Shufflemerge which uses a ...
InPlace Randomized Slope Selection
"... Abstract. Slope selection is a wellknown algorithmic tool used in the context of computing robust estimators for fitting a line to a collection P of n points in the plane. We demonstrate that it is possible to perform slope selection in expected O(n log n) time using only constant extra space in ad ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
(Show Context)
Abstract. Slope selection is a wellknown algorithmic tool used in the context of computing robust estimators for fitting a line to a collection P of n points in the plane. We demonstrate that it is possible to perform slope selection in expected O(n log n) time using only constant extra space in addition to the space needed for representing the input. Our solution is based upon a spaceefficient variant of Matouˇsek’s randomized interpolation search, and we believe that the techniques developed in this paper will prove helpful in the design of spaceefficient randomized algorithms using samples. To underline this, we also sketch how to compute the repeated median line estimator in an inplace setting. 1
Ratio based stable inplace merging
"... Abstract. We investigate the problem of stable inplace merging from a ratio k = n based point of view where m, n are the sizes of the input m sequences with m ≤ n. We introduce a novel algorithm for this problem that is asymptotically optimal regarding the number of assignments as well as compariso ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
Abstract. We investigate the problem of stable inplace merging from a ratio k = n based point of view where m, n are the sizes of the input m sequences with m ≤ n. We introduce a novel algorithm for this problem that is asymptotically optimal regarding the number of assignments as well as comparisons. Our algorithm uses knowledge about the ratio of the input sizes to gain optimality and does not stay in the tradition of Mannila and Ukkonen’s work [8] in contrast to all other stable inplace merging algorithms proposed so far. It has a simple modular structure and does not demand the additional extraction of a movement imitation buffer as needed by its competitors. For its core components we give concrete implementations in form of Pseudo Code. Using benchmarking we prove that our algorithm performs almost always better than its direct competitor proposed in [6]. As additional subresult we show that stable inplace merging is a quite simple problem for every ratio k ≥ √ m by proving that there exists a primitive algorithm that is asymptotically optimal for such ratios. 1
Multiway Blockwise Inplace Merging
"... Abstract. We present an algorithm for asymptotically efficient multiway blockwise inplace merging. Given an array A containing sorted subsequences A1,..., Ak of respective lengths n1,..., nk, where ∑k ni = n, we assume i=1 that extra k·s elements (so called buffer elements) are positioned at the ve ..."
Abstract
 Add to MetaCart
(Show Context)
Abstract. We present an algorithm for asymptotically efficient multiway blockwise inplace merging. Given an array A containing sorted subsequences A1,..., Ak of respective lengths n1,..., nk, where ∑k ni = n, we assume i=1 that extra k·s elements (so called buffer elements) are positioned at the very end of array A, and that the lengths n1,..., nk are positive integer multiples of some parameter s (i.e., multiples of a given block of length s). The number of input sequences k is a fixed constant parameter, not dependent on the lengths of input sequences. Then our algorithm merges the subsequences A1,..., Ak into a single sorted sequence, performing Θ(log k·n) + O((n/s) 2) + O(s· log s) element comparisons and 3·n + O(s·log s) element moves. 1 Then, for s = ⌈n 2/3 /(log n) 1/3 ⌉, this gives an algorithm performing Θ(log k·n) + O((n·log n) 2/3) comparisons and 3·n + O((n·log n) 2/3) moves. That is, our algorithm runs in linear time, with an asymptotically optimal number of comparisons and with the number of moves independent on the number of input sequences. Moreover, our algorithm is “almost inplace”, it requires only k extra blocks of size s = o(n). 1
InPlace Sorting With Fewer Moves
 Information Processing Letters
, 1999
"... It is shown that an array of n elements can be sorted using O(1) extra space, O(n log n= log log n) element moves, and n log 2 n+O(n log log n) comparisons. This is the first inplace sorting algorithm requiring o(n log n) moves in the worst case while guaranteeing O(n log n) comparisons but, due to ..."
Abstract
 Add to MetaCart
It is shown that an array of n elements can be sorted using O(1) extra space, O(n log n= log log n) element moves, and n log 2 n+O(n log log n) comparisons. This is the first inplace sorting algorithm requiring o(n log n) moves in the worst case while guaranteeing O(n log n) comparisons but, due to the constant factors involved, the algorithm is predominantly of theoretical interest. Key words: Inplace algorithms, sorting, merging, mergesort, multiway merge 1