Results 1  10
of
25
A spaceefficient algorithm for segment intersection
 In Proc. 15th Canad. Conf. Comput. Geom
, 2003
"... We examine the space requirement for the classic linesegment intersection problem. Using socalled implicit data structures, we show how to make the standard sweepline algorithm run in O((n + k) log 2 n) time with only O(log 2 n) extra space, where n is the number of line segments and k is the numb ..."
Abstract

Cited by 9 (3 self)
 Add to MetaCart
We examine the space requirement for the classic linesegment intersection problem. Using socalled implicit data structures, we show how to make the standard sweepline algorithm run in O((n + k) log 2 n) time with only O(log 2 n) extra space, where n is the number of line segments and k is the number of intersections. If division is allowed and input can be destroyed, the algorithm can run in O((n + k) log n) time with O(1) extra space.
Deletion Without Rebalancing in Balanced Binary Trees
"... We address the vexing issue of deletions in balanced trees. Rebalancing after a deletion is generally more complicated than rebalancing after an insertion. Textbooks neglect deletion rebalancing, and many database systems do not do it. We describe a relaxation of AVL trees in which rebalancing is do ..."
Abstract

Cited by 8 (4 self)
 Add to MetaCart
(Show Context)
We address the vexing issue of deletions in balanced trees. Rebalancing after a deletion is generally more complicated than rebalancing after an insertion. Textbooks neglect deletion rebalancing, and many database systems do not do it. We describe a relaxation of AVL trees in which rebalancing is done after insertions but not after deletions, yet access time remains logarithmic in the number of insertions. For many applications of balanced trees, our structure offers performance competitive with that of classical balanced trees. With the addition of periodic rebuilding, the performance of our structure is theoretically superior to that of many if not all classic balanced tree structures. Our structure needs O(log log m) bits of balance information per node, where m is the number of insertions, or O(log log n) with periodic rebuilding, where n is the number of nodes. An insertion takes up to two rotations and O(1) amortized time. Using an analysis that relies on an exponential potential function, we show that rebalancing steps occur with a frequency that is exponentially small in the height of the affected node.
Deletion Without Rebalancing in Multiway Search Trees
, 2009
"... Many database systems that use a B + tree as the underlying data structure do not do rebalancing on deletion. This means that a bad sequence of deletions can create a very unbalanced tree. Yet such databases perform well in practice. Avoidance of rebalancing on deletion has been justified empirica ..."
Abstract

Cited by 6 (3 self)
 Add to MetaCart
Many database systems that use a B + tree as the underlying data structure do not do rebalancing on deletion. This means that a bad sequence of deletions can create a very unbalanced tree. Yet such databases perform well in practice. Avoidance of rebalancing on deletion has been justified empirically and by averagecase analysis, but to our knowledge no worstcase analysis has been done. We do such an analysis. We show that the tree height remains logarithmic in the number of insertions, independent of the number of deletions. Furthermore the amortized time for an insertion or deletion, excluding the search time, is O(1), and nodes are modified by insertions and deletions with a frequency that is exponentially small in their height. The latter results do not hold for standard B + trees. By adding periodic rebuilding of the tree, we obtain a data structure that is theoretically superior to standard B + trees in many ways. We conclude that rebalancing on deletion can be considered harmful.
Formalized Verification of Snapshotable Trees: Separation and Sharing
"... Abstract. We use separation logic to specify and verify a Java program that implements snapshotable search trees, fully formalizing the specification and verification in the Coq proof assistant. We achieve local and modular reasoning about a tree and its snapshots and their iterators, although the i ..."
Abstract

Cited by 5 (2 self)
 Add to MetaCart
(Show Context)
Abstract. We use separation logic to specify and verify a Java program that implements snapshotable search trees, fully formalizing the specification and verification in the Coq proof assistant. We achieve local and modular reasoning about a tree and its snapshots and their iterators, although the implementation involves shared mutable heap data structures with no separation or ownership relation between the various data. The paper also introduces a series of four increasingly sophisticated implementations and verifies the first one. The others are included as future work and as a set of challenge problems for full functional specification and verification, whether by separation logic or by other formalisms. 1
RankBalanced Trees
"... Abstract. Since the invention of AVL trees in 1962, a wide variety of ways to balance binary search trees have been proposed. Notable are redblack trees, in which bottomup rebalancing after an insertion or deletion takes O(1) amortized time and O(1) rotations worstcase. But the design space of ba ..."
Abstract

Cited by 5 (3 self)
 Add to MetaCart
Abstract. Since the invention of AVL trees in 1962, a wide variety of ways to balance binary search trees have been proposed. Notable are redblack trees, in which bottomup rebalancing after an insertion or deletion takes O(1) amortized time and O(1) rotations worstcase. But the design space of balanced trees has not been fully explored. We introduce the rankbalanced tree, a relaxation of AVL trees. Rankbalanced trees can be rebalanced bottomup after an insertion or deletion in O(1) amortized time and at most two rotations worstcase, in contrast to redblack trees, which need up to three rotations per deletion. Rebalancing can also be done topdown with fixed lookahead in O(1) amortized time. Using a novel analysis that relies on an exponential potential function, we show that both bottomup and topdown rebalancing modify nodes exponentially infrequently in their heights. 1
Project proposal: Associative containers with strong guarantees CPH STL Report 20074. Worldwide Web document available at http://cphstl.dk
, 2007
"... Abstract. The Standard Template Library (STL) is a collection of generic algorithms and data structures that is part of the standard runtime environment of the C++ programming language. The STL provides four kinds of associative element containers: set, multiset, map, and multimap. In this project ..."
Abstract

Cited by 4 (2 self)
 Add to MetaCart
(Show Context)
Abstract. The Standard Template Library (STL) is a collection of generic algorithms and data structures that is part of the standard runtime environment of the C++ programming language. The STL provides four kinds of associative element containers: set, multiset, map, and multimap. In this project the goal is to develop an associative container that is safer, more reliable, more usable, and/or more efficient (with respect to time and space) than any of the existing realizations.
Largescale Linear RankSVM
"... Linear rankSVM is one of the widely used methods for learning to rank. Although its performance may be inferior to nonlinear methods such as kernel rankSVM and gradient boosting decision trees, linear rankSVM is useful to quickly produce a baseline model. Furthermore, following the recent developmen ..."
Abstract

Cited by 3 (1 self)
 Add to MetaCart
(Show Context)
Linear rankSVM is one of the widely used methods for learning to rank. Although its performance may be inferior to nonlinear methods such as kernel rankSVM and gradient boosting decision trees, linear rankSVM is useful to quickly produce a baseline model. Furthermore, following the recent development of linear SVM for classification, linear rankSVM may give competitive performance for large and sparse data. Many existing works have studied linear rankSVM. Their focus is on the computational efficiency when the number of preference pairs is large. In this paper, we systematically study past works, discuss their advantages/disadvantages, and propose an efficient algorithm. Different implementation issues and extensions are discussed with detailed experiments. Finally, we develop a robust linear rankSVM tool for public use. 1
A minimalist's implementation of the 3d divideandconquer convex hull algorithm
, 2003
"... We give a simple interpretation and a simple implementation of the classical divideandconquer algorithm for computing 3d convex hulls (and in particular, 2d Delaunay triangulations and Voronoi diagrams). The entire C++ code is under 100 lines long, requires no special data structures, and uses on ..."
Abstract

Cited by 3 (2 self)
 Add to MetaCart
(Show Context)
We give a simple interpretation and a simple implementation of the classical divideandconquer algorithm for computing 3d convex hulls (and in particular, 2d Delaunay triangulations and Voronoi diagrams). The entire C++ code is under 100 lines long, requires no special data structures, and uses only 6n pointers for space. 1
Leftleaning RedBlack Trees
"... The redblack tree model for implementing balanced search trees, introduced by Guibas and Sedgewick thirty years ago, is now found throughout our computational infrastructure. Redblack trees are described in standard textbooks and are the underlying data structure for symboltable implementations w ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
(Show Context)
The redblack tree model for implementing balanced search trees, introduced by Guibas and Sedgewick thirty years ago, is now found throughout our computational infrastructure. Redblack trees are described in standard textbooks and are the underlying data structure for symboltable implementations within C++, Java, Python, BSD Unix, and many other modern systems. However, many of these implementations have sacrificed some of the original design goals (primarily in order to develop an effective implementation of the delete operation, which was incompletely specified in the original paper), so a new look is worthwhile. In this paper, we describe a new variant of redblack trees that meets many of the original design goals and leads to substantially simpler code for insert/delete, less than onefourth as much code as in implementations in common use. All redblack trees are based on implementing 23 or 234 trees within a binary tree, using red links to bind together internal nodes into 3nodes or 4nodes. The new code is based on combining three ideas: • Use a recursive implementation. • Require that all 3nodes lean left.