Deletion Without Rebalancing in Binary Search Trees

We present a provably linearizable and lock-free relaxed AVL tree called the non-blocking ravl tree. At any time, the height of a non-blocking ravl tree is upper bounded by log_d (2m) + c, where d is the golden ratio, m is the total number of successful INSERT operations performed so far and c is the number of active concurrent processes that have inserted new keys and are still rebalancing the tree at this time. The most significant feature of the non-blocking ravl tree is that it does not rebalance itself after DELETE operations. Instead, it performs rebalancing only after INSERT operations. Thus, the non-blocking ravl tree is much simpler to implement than other self-balancing concurrent binary search trees (BSTs) which typically introduce a large number of rebalancing cases after DELETE operations, while still providing a provable non-trivial bound on its height. We further conduct experimental studies to compare our solution with other state-of-the-art concurrent BSTs using randomly generated data sequences under uniform distributions, and find that our solution achieves the best performance among concurrent self-balancing BSTs. As the keys in access sequences are likely to be partially sorted in system software, we also conduct experiments using data sequences with various degrees of presortedness to better simulate applications in practice. Our experimental results show that, when there are enough degrees of presortedness, our solution achieves the best performance among all the concurrent BSTs used in our studies, including those that perform self-balancing operations and those that do not, and thus is potentially the best candidate for many real-world applications.

The ordered set is one of the most important data type in both theoretical algorithm design and analysis and practical programming. In this paper we study the set operations on two ordered sets, including Union, Intersect and Difference, based on four types of balanced Binary Search Trees (BST) including AVL trees, red-black trees, weight balanced trees and treaps. We introduced only one subroutine Join that needs to be implemented differently for each balanced BST, and on top of which we can implement generic, simple and efficient parallel functions for ordered sets. We first prove the work-efficiency of these Join-based set functions using a generic proof working for all the four types of balanced BSTs. We also implemented and tested our algorithm on all the four balancing schemes. Interestingly the implementations on all four data structures and three set functions perform similarly in time and speedup (more than 45x on 64 cores). We also compare the performance of our implementation to other existing libraries and algorithms.

Since the invention of AVL trees in 1962, a wide variety of ways to balance binary search trees have been proposed. Notable are red-black trees, in which bottom-up rebalancing after an insertion or deletion takes O(1) amortized time and O(1) rotations worst-case. But the design space of balanced trees has not been fully explored. We introduce the rank-balanced tree , a relaxation of AVL trees. Rank-balanced trees can be rebalanced bottom-up after an insertion or deletion in O(1) amortized time and at most two rotations worst-case, in contrast to red-black trees, which need up to three rotations per deletion. Rebalancing can also be done top-down with fixed lookahead in O(1) amortized time. Using a novel analysis that relies on an exponential potential function, we show that both bottom-up and top-down rebalancing modify nodes exponentially infrequently in their heights.

We present the Adaptive Compact Tree (AC-Tree), a data structure similar to a self-balancing binary search tree (BST) that improves storage and operations for sets of integers with few “holes”. AC-Trees can be implemented on top of any classic BST (e.g. AVL trees [3]), holding discontiguous intervals at each node to obtain a compact representation only requiring O(k) storage and supporting efficient O(log k) operations, with k the number of intervals. These properties can improve the performances of applications, like Constraint Programming (CP) solvers, that incrementally remove values and intervals on domains initially consisting of one large interval. First experiments show that AC-Trees outperform classic self-balancing BSTs in most cases and improve CP solvers performances for problems with large domains.

Three relevant types of suboptimal binary search trees are comparatively evaluated in this paper: two well-known representatives of height-balanced approaches (the AVL and red-black trees) and a popular self-adjusting splay tree. After a brief theoretical background, an evaluation method was described that employs a suitable synthetic workload method capable of producing diverse desired workload characteristics (different distributions and ranges of key values, varying input sequence lengths, etc.). Evaluation analysis was conducted for search, insert, and delete operations separately for each particular type and in appropriate combinations. Experimental results for an average operation cost as well as for tree maintenance cost are comparatively presented and carefully discussed. Finally, the suggested favorable conditions for application of each tree type are summarized.

We introduce the relaxed k-tree, a search tree with relaxed balance and a height bound, when in balance, of (1 + Ɛ) log2 n + 1, for any Ɛ > 0. The rebalancing work is amortized O(1/Ɛ) per update. This is the first binary search tree with relaxed balance having a height bound better than c ċ log2 n for a fixed constant c. In all previous proposals, the constant is at least 1/ log2 Φ > 1.44, where Φ is the golden ratio. As a consequence, we can also define a standard (non-relaxed) k-tree with amortized constant rebalancing per update, which is an improvement over the original definition. Search engines based on main-memory databases with strongly fluctuating workloads are possible applications for this line of work.

Content authentication is a critical issue for online multimedia systems. A new content authentication scheme based on optimal binary search tree (OBST) was proposed and evaluated to reduce the authentication cost. A balanced tree based approach, however, can not achieve optimal authentication cost when each element is accessed with different probabilities, so it's not appropriate for a practical online multimedia system in which access of the contents is expected to obey Zipf's law. We prove that an OBST based scheme achieves minimized expected authentication cost; we also compare the authentication cost of our scheme to that of a binary search tree (BST) and a red-black tree.

Enter the computing arboretum and you will find a variety of well-studied trees: AVL trees (Adel'son-Vel'skiĭ & Landis 1962), symmetric binary B-trees (Bayer 1972), Hopcroft's 2-3 trees (Aho et al . 1974), the bushy finger trees (Guibas et al . 1977) and the colourful red-black trees (Guibas & Sedgewick 1978). In this pearl, we look at a more exotic species of balanced search trees, 1-2 brother trees (Ottmann et al . 1979), which deserves to be better known. Brother trees lend themselves well to a functional implementation with deletion (Section 5) as straightforward as insertion (Section 3), both running in logarithmic time. Furthermore, brother trees can be constructed from ordered lists in linear time (Section 4). With some simple optimisations in place, this implementation of search trees is one of the fastest around. So, fasten your seat belts.

A problem that arises in computational geometry, pattern matching, and other applications is the need to quickly determine which of a collection of intervals overlap a query point. The interval binary search tree (IBS-tree) has been proposed as a solution to this problem. A recently discovered randomized data structure called the skip list provides functionality and performance similar to balanced binary trees (e.g., AVL-trees), but is much simpler to implement than balanced trees. This paper introduces an extension of the skip list called the interval skip list, or IS-list, to support interval indexing. IS-lists remain dynamicly balanced, and show similar performance to IBS-trees, but can be implemented in about one-fourth as much high-level language code. Searching an IS-list containing n intervals to find intervals overlapping a point takes expected time O(log n+L) where L is the number of matching intervals. Inserting or deleting an mterval takes expected time O(log2n).

Splay and randomized search trees (RSTs) are self‐balancing binary tree structures with little or no space overhead compared to a standard binary search tree (BST). Both trees are intended for use in applications where node accesses are skewed, for example in gathering the distinct words in a large text collection for index construction. We investigate the efficiency of these trees for such vocabulary accumulation. Surprisingly, unmodified splaying and RSTs are on average around 25% slower than using a standard binary tree. We investigate heuristics to limit splay tree reorganization costs and show their effectiveness in practice. In particular, a periodic rotation scheme improves the speed of splaying by 27%, while other proposed heuristics are less effective. We also report the performance of efficient bit‐wise hashing and red–blacktrees for comparison. Copyright © 2001 John Wiley & Sons, Ltd.

We show that the internal path length of a red-black tree of size N is bounded above by 2N(log N−log log N)+O(N) and that this is, asymptotically, tight. This result further affirms a conjecture that whenever trees of size N, in a class of height-balanced binary trees, have height bounded from above by αlog2N, then the internal path length is bounded from above by α(log2N−log2 log2N)+O(N). We also prove that the asymptotic bound is tight for red-black trees. For this purpose, we introduce a class of red-black trees, the C(k, h) trees, which achieve the bound when k=h−2logh+e, where |e|≤1/2. This result solves the open problem of how bad red-black trees can be. In order to establish this result, we also prove that any red-black tree of a given height can be produced from a “skinniest” red-black tree of the same height by a series of simple insertions.

We study multi-finger binary search trees (BSTs), a far-reaching extension of the classical BST model, with connections to the well-studied k-server problem. Finger search is a popular technique for speeding up BST operations when a query sequence has locality of reference. BSTs with multiple fingers can exploit more general regularities in the input. In this paper we consider the cost of serving a sequence of queries in an optimal (offline) BST with k fingers, a powerful benchmark against which other algorithms can be measured. We show that the k-finger optimum can be matched by a standard dynamic BST (having a single root-finger) with an O(log{k}) factor overhead. This result is tight for all k, improving the O(k) factor implicit in earlier work. Furthermore, we describe new online BSTs that match this bound up to a (log{k})^{O(1)} factor. Previously only the "one-finger" special case was known to hold for an online BST (Iacono, Langerman, 2016; Cole et al., 2000). Splay trees, assuming their conjectured optimality (Sleator and Tarjan, 1983), would have to match our bounds for all k. Our online algorithms are randomized and combine techniques developed for the k-server problem with a multiplicative-weights scheme for learning tree metrics. To our knowledge, this is the first time when tools developed for the k-server problem are used in BSTs. As an application of our k-finger results, we show that BSTs can efficiently serve queries that are close to some recently accessed item. This is a (restricted) form of the unified property (Iacono, 2001) that was previously not known to hold for any BST algorithm, online or offline.

In a multiprocessor system, a lock-based scheme is used to ensure consistency and correctness during parallel processing. To manipulate a binary search tree in parallel, a process that modifies the current state of the data structure has to lock a certain portion of the tree. Lock-based schemes result in a longer wait time for the rest of the processes, particularly if a large portion of the tree has been locked. In a concurrent environment, the root of the binary search tree may therefore become a bottleneck, as it is the only entry point for all processes. To reduce the total wait time, it is possible to create and maintain a binary search tree with multiple roots, thereby allowing multiple processors to act upon different trees simultaneously. In this paper, we present static and dynamic methods to create and maintain a binary search tree with multiple roots. Without considerable overhead, a set of connected trees is created that resembles a forest, yet acts as a single binary search tree.

New Terminology and Results for AVL Trees

An algorithm for inserting an element into a one-sided height-balanced (OSHB) binary search tree is presented. The algorithm operates in time O (log n ), where n is the number of nodes in the tree. This represents an improvement over the best previously known insertion algorithms of Hirschberg and Kosaraju, which require time O (log 2 n ). Moreover, the O (log n ) complexity is optimal. Earlier results have shown that deletion in such a structure can also be performed in O (log n ) time. Thus the result of this paper gives a negative answer to the question of whether such trees should be the first examples of their kind, where deletion has a smaller time complexity than insertion. Furthermore, it can now be concluded that insertion, deletion, and retrieval in OSHB trees can be performed in the same time as the corresponding operations for the more general AVL trees, to within a constant factor. However, the insertion and deletion algorithms for OSHB trees appear much more complicated than the corresponding algorithms for AVL trees.