An efficient compression scheme for data communication which uses a new family of self‐organizing binary search trees

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.

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.

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.

This paper presents the analysis of element deletion in different data structures, like linked lists, binary search trees, stacks, and queues. For random data sequence, we build the linked list and binary search tree and we compare the element deletion procedure. We find the much more stable performance of the binary search tree than that of the linked list. Additionally, we analyze the stack as a complex data structure and its basic operations. We present the element deletion with the basic operations for array stack implementation and we note the limitations. Also, we present the element deletion problem for a queue as a complex data structure, implemented with an array. We present the element deletion with the basic queue operations and we point out the limitations.

We present a new connection between self-adjusting binary search trees (BSTs) and heaps, two fundamental, extensively studied, and practically relevant families of data structures. Roughly speaking, we map an arbitrary heap algorithm within a natural model, to a corresponding BST algorithm with the same cost on a dual sequence of operations (i.e. the same sequence with the roles of time and key-space switched). This is the first general transformation between the two families of data structures. There is a rich theory of dynamic optimality for BSTs (i.e. the theory of competitiveness between BST algorithms). The lack of an analogous theory for heaps has been noted in the literature. Through our connection, we transfer all instance-specific lower bounds known for BSTs to a general model of heaps, initiating a theory of dynamic optimality for heaps. On the algorithmic side, we obtain a new, simple and efficient heap algorithm, which we call the smooth heap. We show the smooth heap to be the heap-counterpart of Greedy, the BST algorithm with the strongest proven and conjectured properties from the literature, widely believed to be instance-optimal. Assuming the optimality of Greedy, the smooth heap is also optimal within our model of heap algorithms. As corollaries of results known for Greedy, we obtain instance-specific upper bounds for the smooth heap, with applications in adaptive sorting. Intriguingly, the smooth heap, although derived from a non-practical BST algorithm, is simple and easy to implement (e.g. it stores no auxiliary data besides the keys and tree pointers). It can be seen as a variation on the popular pairing heap data structure, extending it with a "power-of-two-choices" type of heuristic.

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

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.

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

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.

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.

The aim of this talk is to explain a pioneering exploratory research endeavour that attempts to merge two completely different fields in Computer Science so as to yield very fascinating results. These are the well-established fields of Neural Networks (NNs) and Adaptive Data Structures (ADS) respectively. The field of NNs deals with the training and learning capabilities of a large number of neurons, each possessing minimal computational properties. On the other hand, the field of ADS concerns designing, implementing and analyzing data structures which adaptively change with time so as to optimize some access criteria. In this talk, we shall demonstrate how these fields can be merged, so that the neural elements are themselves linked together using a data structure. This structure can be a singly-linked or doubly-linked list, or even a Binary Search Tree (BST). While the results themselves are quite generic, in particular, we shall, as a prima facie case, present the results in which a Self-Organizing Map (SOM) with an underlying BST structure can be adaptively re-structured using conditional rotations. These rotations on the nodes of the tree are local and are performed in constant time, guaranteeing a decrease in the Weighted Path Length of the entire tree. As a result, the algorithm, referred to as the Tree-based Topology-Oriented SOM with Conditional Rotations (TTO-CONROT), converges in such a manner that the neurons are ultimately placed in the input space so as to represent its stochastic distribution. Besides, the neighborhood properties of the neurons suit the best BST that represents the data.KeywordsLearning CapabilityBinary Search TreeAccess ProbabilityPrima Facie CaseAnalyze Data StructureThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

In many trivial or complex situation augmentation of a data structure would required. To solve real world complex problem augmentation of data structure is must by creating entirely new data structure using existing data structure by adding some additional information like Minimum, Maximum, Successor, and Predecessor in it. Augmentation of data structure is not that much straightforward. This approach is developed with respect to existing data structure of BST (Binary Search Tree) and some additional information. So, in this attempt we presented BST as underlying data structure for interval tree, which leads to easy implementation, reduced searching complexity and less memory requirement.

Tree-based string pattern matching on FPGAs

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