AVL Trees Research Articles

Hairy Search Trees

Random search trees have the property that their depth depends on the order in which they are built. They have to be balanced in order to obtain a more efficient storage-and-retrieval data structure. Balancing a search tree is time consuming. This explains the popularity of data structures which approximate a balanced tree but have lower amortized balancing costs, such as AVL trees, Fibonacci trees and 2-3 trees. The algorithms for maintaining these data structures efficiently are complex and hard to derive. This observation has led to insertion algorithms that perform local balancing around the newly inserted node, without backtracking on the search path. This is also called a fringe heuristic. The resulting class of trees is referred to as 1-locally balanced trees, in this note referred to as hairy trees. In this note a simple analysis of their behaviour is provided.

Adaptive encoding for numerical data compression

This paper discusses the adaptive compression of computer files of numerical data whose statistical properties are not given in advance. A new lossless coding method for this purpose, which utilizes AVL trees, is proposed. The method is effective to any word length. This paper also includes its application to the lossless compression of gray-scale images, which shows wider applicability of the adaptive compression of numerical data.

Balance in AVL trees and space cost of brother trees

We characterize AVL trees that have, for their heights and weights, the maximum numbers of nodes whose subtrees differ in height by one (imbalanced nodes). We obtain the result from a characterization of brother trees with the maximum space costs for their heights and weights. The proof is based on a novel tree transformation that is of interest in its own right.

An evaluation of self‐adjusting binary search tree techniques

AbstractMuch has been said in praise of self‐adjusting data structures, particularly self‐adjusting binary search trees. Self‐adjusting trees are most suited to skewed key‐access distributions as the techniques attempt to place the most commonly accessed keys near the root of the tree. Theoretical bounds on worst‐case and amortized performance (i.e. performance over a sequence of operations) have been derived which compare well with those for optimal binary search trees. In this paper, we compare the performance of three different techniques for self‐adjusting trees with that of AVL and random binary search trees. Comparisons are made for various tree sizes, levels of key‐access‐frequency skewness and ratios of insertions and deletions to searches. The results show that, because of the high cost of maintaining self‐adjusting trees, in almost all cases the AVL tree outperforms all the self‐adjusting trees and in many cases even a random binary search tree has better performance, in terms of CPU time, than any of the self‐adjusting trees. Self‐adjusting trees seem to perform best in a highly dynamic environment, contrary to intuition.

AVL Trees With Relaxed Balance

<p>AVL trees with relaxed balance were introduced with the aim of improving runtime per formance by allowing a greater degree of concurrency. This is obtained by uncoupling updating from rebalancing. An additional benefit is that rebalancing can be controlled separately. In particular, it can be postponed completely or partially until after peak working hours.</p><p>We define a new collection of rebalancing operations which allows for a significantly greater degree of concurrency than the original proposal. Additionally, in contrast to the original proposal, we prove the complexity of our algorithm.</p><p>If N is the maximum size of the tree, we prove that each insertion gives rise to at most I_ log_Phi(N + 3/2) + log_Phi(squareroot{5}) - 3 _I rebalancing operations and that each deletion gives rise to at most I_ log_Phi(N + 3/2) + log_Phi(squareroot{5}) - 4 _I rebalancing operations, where Phi is the golden ratio.</p>

Improved bounds for the expected behaviour of AVL trees

In this paper we improve previous bounds on expected measures of AVL trees by using fringe analysis. A new way of handling larger tree collections that are not closed is presented. An inherent difficulty posed by the transformations necessary to keep the AVL tree balanced makes its analysis difficult when using fringe analysis methods. We derive a technique to cope with this difficulty obtaining the exact solution for fringe parameters even when unknown probabilities are involved. We show that the probability of a rotation in an insertion is between 0.37 and 0.73 (and seems to be less than 0.56), that the fraction of balanced nodes is between 0.56 and 0.78, and that the expected number of comparisons in a search seems to be at most 12% more than in the complete balanced tree.

A tight upper bound for the path length of AVL trees

We prove that the internal path length of an AVL tree of size N is bounded from above by 1.4404 N( log 2 N- log 2 log 2 N)+ O( N) and show that this bound is achieved by an infinite family of AVL trees, each tree of which is not of maximal height. These results carry over to the comparison cost of brother trees.

Balanced binary tree code for scientific applications

A set of easy-to-use FORTRAN routines for building and accessing data structures of the type commonly encountered in scientific applications is introduced. Fetch and insert times go as ≻ [log ( n)], where n is the number of elements in the list. The routines implement AVL or height-balanced binary tree logic. Each tree is a linear integer array. The first ten elements of a tree array specify its structure and the remaining elements are dedicated to node information. Each node includes key and integer data elements in addition to the necessary linkage information. The keys and data can each be multiple word entries. The routines are generic so even though the structure of any one specific tree is fixed, an application can include several trees that have different structures with no additional code requirements. An example that illustrates how the application can be integrated into an existing code is included.

An editor for revision control

Programming environments support revision control in several guises. Explicitly, revision control software manages the trees of revisions that grow as software is modified. Implicitly, editors retain past versions by automatically saving backup copies and by allowing users to undo commands. This paper describes an editor that offers a uniform solution to these problems by never destroying the old version of the file being edited. It represents files using a generalization of AVL trees called “AVL dags,” which makes it affordable to automatically retain past versions of files. Automatic retention makes revision maintenance transparent to users. The editor also uses the same command language to edit both text and revision trees.

O(1) space complexity deletion for AVL trees

O(1) space complexity deletion for AVL trees

Rebalancing operations for deletions in AVL-trees

Rebalancing operations for deletions in AVL-trees

Stack Algorithm Speech Encoding with Fixed and Variable Symbol Release Rules

Tree codes find wide use in a variety of problems such as source encoding, sequential decoding, pattern recognition, and related fields. Efficient algorithms exist to explore the code trees and are well documented in the literature. All of these algorithms search code trees in an incremental manner, releasing a path map symbol at a time. A recent work has investigated the effect of releasing multiple symbols on the performance of the (M, L) algorithm used with speech. Here we investigate the effect of multiple symbol release rules on the performance of the stack algorithm in the context of speech encoding. We show that significant computational reduction can result with the use of such rules. We use an efficient data structure, the AVL tree data structure, to store code tree paths.

Direct dynamic structures for some line segment problems

Simple direct dynamic binary tree structures for two line segment problems are introduced. Both structures provide for O(log n) updating and querying and can be based on any balanced class of binary search trees, for example, AVL trees. The measure tree solves a nondecomposable searching problem, while the stabbing tree improves the known updating and querying time for its corresponding application.

A comparative study of 2-3 trees and AVL trees

This paper presents an analysis, a survey, and compares the pertinent characteristics of AVL and 2-3 trees. In an attempt to optimize the space complexity of 2-3 trees, it introduces a new space saving and efficient top-down insertion and construction algorithm. The analysis shows that neither data structure totally dominates the other. The decision as to which is cost-wise efficient is a function of the application.

Using linear forms to determine the set of integers realizable by ( g0, g1, …, gn)-trees

A ( g 0, g 1, …, g n )-tree is a tree whose internal nodes have outvalences g 0, g 1, …, g n−1 , or g n and whose leaves are all on the same level. It has been shown that all but a finite set of integers may be realized as the number of leaves on a ( g 0, …, g n )-tree if and only if the gcd ( g 1 - g 0, … g n - g 0)=1 In this paper properties of the set of realizable integers are discussed including upper and lower bounds for the conductor κ (the conductor is the least integer having the property that for all N ⩾ κ, N is realizable). It is also noted that several problems, including finding the set of realizable integers for ( g 0, … g n )-AVL trees and (1, g 1, …, g n )-brother trees, are all equivalent to the problem of Frobenius concerning the assumed values of a linear form in nonnegative integers.

( g0, g1, …, g k)-trees and unary OL systems

In this paper we extend the notion of (2, 3)-trees and AVL trees to ( g 0, g 1,…, g k )-trees and ( g 1, g 2,…, g k )-AVL trees, respectively, where 1⩽ g 0< g 1< g 2<…< g k . Complete characterization of these two classes of trees in terms of their generators g 0, g 1,…, g k is given and the connection between ( g 0, g 1,… g k )-trees and unary OL systems is mentioned.

A Look at Symmetric Binary B-Trees

Symmetric binary B-trees have been proposed as an alternative for AVL trees and B-trees for representing dictionary information. The average costs to search, insert, and delete keys in symmetric bi...

Query costs in HB(1) trees versus 2?3 trees

Query costs in random AVL trees are compared to those in random 2–3 trees. Both data structures are assumed to reside in main storage. Costs are calculated in terms of the number of node visits and key comparisons required to find a match or no match for a given key. The comparison is based upon theoretical concepts and implementation dependent considerations; e.g., data and instruction fetch. It is shown that if the cost of a key comparison is greater than or equal to the cost of a node access, then AVL trees are more advantageous.

Comments on "Concurrent Search and Insertion in AVL Trees"

Ellis' concurrent AVL insertion algorithm <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">1</sup> is discussed in this correspondence. We note that obtaining a block of storage for the new AVL leaf may become a serial bottleneck for the entire insertion algorithm. We indicate a potential solution and refer the reader to another paper [1] in which the full details are given.

Binary search trees in secondary memory

Binary search trees are shown to be reasonable alternatives to multiway trees for files stored in magnetic bubble memory. An algorithm for maintaining AVL trees is shown to be by far the most efficient of eight algorithms considered, when applied to secondary memory. A simplified model for analyzing the AVL algorithm is developed. A practical AVL algorithm for secondary memory is presented. Simulation results showing the performance of the AVL algorithm and a basic nonbalancing algorithm are given.