Balancing weight-balanced trees

Binary search trees have received a great deal of attention in recent years. As a result of this interest, several methods have been developed for balancing them; namely, random, height-balanced, bounded-balance, and weight-balanced trees. These methods which include weighted and non-weighted binary search trees are grouped into two classes: 1) dynamic balancing and 2) total restructuring. The rational and properties of the more significant methods are discussed and compared with other tree balancing algorithms. These comparisons provide insight about the conditions under which an algorithm is appropriate.

On the average number of rebalancing operations in weight-balanced trees

We present a new linear-time algorithm for constructing multiway search trees with near-optimal search cost whose running time is independent of the size of the node in the tree. With the analysis of our construction method, we provide a new upper bound on the average search cost for multiway search trees that nearly matches the lower bound. In fact, it is tight for infinitely many probability distributions. This problem is well-studied in the literature for the case of binary search trees. Using our new construction method, we are able to provide the tightest upper bound on the average search cost for an optimal binary search tree.

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.

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.

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.

Change-Point (CP) detection has attracted considerable attention in the fields of data mining and statistics; it is very meaningful to discuss how to quickly and efficiently detect abrupt change from large-scale bioelectric signals. Currently, most of the existing methods, like Kolmogorov-Smirnov (KS) statistic and so forth, are time-consuming, especially for large-scale datasets. In this paper, we propose a fast framework for abrupt change detection based on binary search trees (BSTs) and a modified KS statistic, named BSTKS (binary search trees and Kolmogorov statistic). In this method, first, two binary search trees, termed as BSTcA and BSTcD, are constructed by multilevel Haar Wavelet Transform (HWT); second, three search criteria are introduced in terms of the statistic and variance fluctuations in the diagnosed time series; last, an optimal search path is detected from the root to leaf nodes of two BSTs. The studies on both the synthetic time series samples and the real electroencephalograph (EEG) recordings indicate that the proposed BSTKS can detect abrupt change more quickly and efficiently than KS, t-statistic (t), and Singular-Spectrum Analyses (SSA) methods, with the shortest computation time, the highest hit rate, the smallest error, and the highest accuracy out of four methods. This study suggests that the proposed BSTKS is very helpful for useful information inspection on all kinds of bioelectric time series signals.

Binary Search Tree (BST) is an important data structure for managing ordered data. Many algorithms have been proposed for concurrent manipulation of a binary search tree in an asynchronous shared memory system that supports search, insert and delete operations based on both external and internal representations of a search tree. An important step in executing an operation on a tree is to traverse the tree from top-to-down in order to locate the operation's window. A process may need to perform this traversal several times to handle failures occurring due to other processes performing concurrent updates on the tree. Most concurrent algorithms that have been proposed so far use a naive approach and simply restart the traversal from the root of the tree. In this work, we present a new approach to recover from such failures more efficiently for certain types of concurrent binary search tree algorithms using local recovery by restarting the traversal from the middle of the tree in order to locate an operation's window (tree section of interest). Our approach is sufficiently general in the sense that it can be applied to most of the existing concurrent binary search trees using internal representation based on both blocking as well as non-blocking approaches. Using experimental evaluation, we demonstrate that our local recovery approach can significantly improve the performance of a concurrent internal BST by up to 124.7% when the contention is high.

Binary search trees built from the postorder traversal sequence of other binary search trees are characterized in terms of their binary tree structure. A connection is established between this structure and the Eulerian numbers. This yields considerable information concerning the “average” binary search tree with a given number of nodes. Periodicity is established for the process of repeatedly taking postorder sequences and building binary search trees. Finally, the average depth of a node in a postorder tree withn nodes is determined.

In this chapter, we will explain the following: The difference between a tree and a binary tree How to perform pre-order, in-order, and post-order traversals of a binary tree How to represent a binary tree in a computer program How to build a binary tree from given data What a binary search tree is and how to build one How to write a program to do a word-frequency count of words in a passage How to use an array as a binary tree representation How to write some recursive functions to obtain information about a binary tree How to delete a node from a binary search tree

Kakkot Tree is a Binary Searching Tree with the caching concept added. It is used to speed up the searching process that is carried on a Binary Search Tree. The time complexity of BST varies between O(n) and O(log n) depends upon the number of nodes that are present in left and right children. Kakkot Tree is a new data structure which is a variant of BST with some initial nodes which act like caching.

Generally, Change Point (CP) detection is time-consuming, especially from large-scale time series. In this paper, a fast method of CP detection is proposed based on Haar Wavelet (HW) and Binary Search Tree (BST), named HWBST. In this method, by multi-level HW, a Binary Search Tree, termed BSTcD, is constructed from a diagnosed time series, and two binary search criteria are introduced to detect abrupt change from root to leaf nodes in BSTcD. Then, the sensitivity and accuracy of HWBST are analyzed and evaluated on the simulated and Electrocardiogram (ECG) time series. The results show that HWBST has better performance than HW, KS, and T statistic methods, in terms of computation time, error, accuracy etc.

In this paper, we demonstrate that we can effectively use the results from the field of adaptive self‐organizing data structures in enhancing compression schemes. Unlike adaptive lists, which have already been used in compression, to the best of our knowledge, adaptive self‐organizing trees have not been used in this regard. To achieve this, we introduce a new data structure, the partitioning binary search tree (PBST) which, although based on the well‐known binary search tree (BST), also appropriately partitions the data elements into mutually exclusive sets. When used in conjunction with Fano encoding, the PBST leads to the so‐called Fano binary search tree (FBST), which, indeed, incorporates the required Fano coding (nearly equal probability) property into the BST. We demonstrate how both the PBST and the FBST can be maintained adaptively and in a self‐organizing manner. The updating procedure that converts a PBST into an FBST, and the corresponding new tree‐based operators, namely the shift‐to‐left and the shift‐to‐right operators, are explicitly presented. The encoding and decoding procedures that also update the FBST have been implemented and rigorously tested. Our empirical results on the files of the well‐known benchmarks, the Calgary and Canterbury Corpora, show that the adaptive Fano coding using FBSTs, the Huffman, and the greedy adaptive Fano coding achieve similar compression ratios. However, in terms of encoding/decoding speed, the new scheme is much faster than the latter two in the encoding phase, and they achieve approximately the same speed in the decoding phase. We believe that the same philosophy, namely that of using an adaptive self‐organizing BST to maintain the frequencies, can also be utilized for other data encoding mechanisms, even as the Fenwick scheme has been used in arithmetic coding. Copyright © 2008 John Wiley & Sons, Ltd.

We design an efficient sublinear time parallel construction of optimal binary search trees. The efficiency of the parallel algorithm corresponds to its total work (the product time × processors). Our algorithm works in O(n1−ɛ log n) time with the total work O(n2−2ɛ), for an arbitrarily small constant 0 < e ≤ 1/2. This is optimal within a factor n2ɛ with respect to the best known sequential algorithm given by Knuth, which needs only O(n2) time due to a monotonicity property of optimal binary search trees, see [6]). It is unknown how to explore this property in an efficient NC construction of binary search trees. Here we show that it can be effectively used in sublinear time parallel computation. Our improvement also relies on the use (in independently processed small subcomputations) of the parallelism present in Knuth's algorithm. The best known sublinear time algorithms for the construction of binary search trees (as an instance of a more general problem) have O(n3) work for time larger than n3/4, see [3] and [7]. For time √n these algorithms need n4 work, while our algorithm needs for this time only n3 work, thus improving the known algorithms by a linear factor. Also if time is O(n1−ɛ) and e is very small our improvement is close to O(n). Such improvement is similar to the one implied by the monotonicity property in sequential computations (from n3 sequential time for a more general dynamic programming problem to n2 time for the special case of optimal binary search trees).