An Optimal Algorithm for Untangling Binary Trees via Rotations

Computing the rotation distance between two binary trees with n internal nodes efficiently (in poly( n) time) is a long standing open question in the study of height balancing in tree data structures. In this paper, we initiate the study of this problem bounding the rank of the trees given at the input (defined in [1] in the context of decision trees). We define the rank-bounded rotation distance between two given full binary trees T1 and T2 (with n internal nodes) of rank at most r = max{rank( T1), rank( T2)}, denoted by dR( T1, T2), as the length of the shortest sequence of rotations that transforms T1 to T2 with the restriction that the intermediate trees must be of rank at most r. We show that the rotation distance problem reduces in polynomial time to the rank bounded rotation distance problem. This motivates the study of the problem in the combinatorial and algorithmic frontiers. Observing that trees with rank 1 coincide exactly with skew trees (full binary trees where every internal node has at least one leaf as a child), we show the following results in this frontier: We present an O( n2) time algorithm for computing dR( T1, T2). That is, when the given full binary trees are skew trees (we call this variant the skew rotation distance problem) - where the intermediate trees are restricted to be skew as well. In particular, our techniques imply that for any two skew trees dR( T1, T2) ≤ n2. We show the following upper bound: for any two full binary trees T1 and T2 of rank r1 and r2 respectively, we have that: dR( T1, T2) ≤ n2(1 + (2 n + 1)( r1 + r2 – 2)) where r = max{ r1, r2}. This bound is asymptotically tight for r = 1. En route to our proof of the above theorems, we associate full binary trees to permutations and relate the rotation operation on trees to transpositions in the corresponding permutations. We give exact combinatorial characterizations of permutations that correspond to full binary trees and full skew binary trees under this association. We also precisely characterize the transpositions that correspond to the set of rotations in full binary trees. We also study bi-variate polynomials associated with binary trees (introduced by [2]), and show characterizations and algorithms for computing rotation distances for the case of full skew trees using them.

The restricted rotation distance d R (S, T) between two binary trees S, T of n vertices is the minimum number of rotations by which S can be transformed into T, where rotations can only take place at the root of the tree, or at the right child of the root. A sharp upper bound d R (S, T) ≤ 4n – 8 is known, based on the word metric of Thompson’s group. We refine this bound to a sharp d R (S, T) ≤ 4n – 8 – ρS – ρT, where ρS and ρT are the numbers of vertices in the rightmost vertex chains of the two trees, by means of a very simple transformation algorithm based on elementary properties of trees. We then generalize the concept of restricted rotation to k-restricted rotation, by allowing rotations to take place at all the vertices of the highest k levels of the tree. For k = 2 we show that not much is gained in the worst case, although the classical problem of rebalancing an AVL tree can be solved efficiently, in particular rebalancing after vertex deletion requires O(log n) rotations as in the standard algorithm. Finding significant bounds and applications for k ≥ 3 is open.

Restricted rotation distance between binary trees

Lower bounds on the rotation distance of binary trees

In the current statistical machine translation (SMT), erroneous word reordering is one of the most serious problems. To resolve this problem, many word-reordering constraint techniques have been proposed. Inversion transduction grammar (ITG) is one of these constraints. In ITG constraints, target-side word order is obtained by rotating nodes of the source-side binary tree. In these node rotations, the source binary tree instance is not considered. Therefore, stronger constraints for word reordering can be obtained by imposing further constraints derived from the source tree on the ITG constraints. For example, for the source word sequence { a b c d }, ITG constraints allow a total of twenty-two target word orderings. However, when the source binary tree instance ((a b) (c d)) is given, our proposed “imposing source tree on ITG” (IST-ITG) constraints allow only eight word orderings. The reduction in the number of word-order permutations by our proposed stronger constraints efficiently suppresses erroneous word orderings. In our experiments with IST-ITG using the NIST MT08 English-to-Chinese translation track's data, the proposed method resulted in a 1.8-points improvement in character BLEU-4 (35.2 to 37.0) and a 6.2% lower CER (74.1 to 67.9%) compared with our baseline condition.

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

On subtrees of trees

In several areas like Global Optimization using branch-and-bound methods, the unit n-simplex is refined by bisecting the longest edge such that a binary search tree appears. This process generates simplices belonging to different shape classes. Having less simplex shapes facilitates the prediction of the further workload from a node in the binary tree, because the same shape leads to the same sub-tree. Irregular sub-simplices generated in the refinement process may have more than one longest edge when n≥3 . The question is how to choose the longest edge to be bisected such that the number of shape classes is as small as possible. We develop a Branch-and-Bound (B&amp;B) algorithm to find the minimum number of classes in the refinement process. The developed B&amp;B algorithm provides a minimum number of eight classes for a regular 3-simplex. Due to the high computational cost of solving this combinatorial problem, future research focuses on using high performance computing to derive the minimum number of shapes in higher dimensions.

In this paper, a new representation of a binary tree is introduced, called the Catalan Cipher Vector, which is a vector of elements with certain properties. It can be ranked using a special form of the Catalan Triangle designed for this purpose. It is shown that the vector coincides with the level-order traversal of the binary tree and how it can be used to generate a binary tree from it. Streamlined algorithms for directly obtaining the rank from a binary tree and vice versa, using the Catalan Cipher Vector during the processes, are given. The algorithms are analyzed for time and space complexity and shown to be linear for both.The Catalan Cipher Vector enables a straightforward determination of the position and linking for every node of the binary tree, since it contains information for both every node’s ancestor and the direction of linking from the ancestor to that node. Thus, it is especially well suited for binary tree generation. Using another structure, called a canonical state-space tableau, the relationship between the Catalan Cipher Vector and the level-order traversal of the binary tree is explained.

We describe algorithms for constructing optimal binary search trees, in which the access cost of a key depends on the k preceding keys, which were reached in the path to it. This problem has applications to searching on secondary memory and robotics. Two kinds of optimal trees are considered, namely optimal worst case trees and weighted average case trees. The time and space complexity of both algorithms are O(n k+2) and O(n k+1), respectively. The algorithms are based on a convenient decomposition and characterizations of sequences of keys, which are paths of special kinds in binary search trees. Finally, using generating functions, the exact number of steps performed by the algorithms has been calculated. The subject will be introduced by a general discussion on the construction of optimal binary search trees.

Generalized Huffman coding for binary trees with choosable edge lengths

Constructing a binary tree from its traversals by reversible recursion and iteration

On Rotations and the Generation of Binary Trees

Indexing technology is hardly studied when data access is skew in real time system. On one hand indexing considers the probability of data accessed, on the other hand indexing needs to satisfy data real-time constraints, and meanwhile, the time complexity of arithmetic computing for indexing must be low. The nearly optimal binary index tree NOBIT is based on the idea of static optimal search tree. We introduce real-time weight when it deals with nodes probabilities weight so as to quickly construct a binary index tree with nearly optimal performance. The search process of NOBIT is similar to binary search, and its average time complexity is O(logN). The NOBIT considers the probability of accessed data and data which are accessed frequently are put into the front part of broadcast sequence so that average tuning time is shortened. Meanwhile, the NOBIT takes the real-time constraints of accessed data into account and data with rigid time constraints also are put into the front part of broadcast sequence so that success rate of data requested is improved.

We study the weighted vertex coloring problem (WVCP) in binary trees and a restricted class of cactus graphs we called cactus paths. WVCP is a generalization of the vertex coloring problem where a color class of a feasible coloring is assigned a cost equal to the largest weight of a vertex from the color class. The objective is to find a feasible coloring which minimizes the sum of the color costs assigned to each color class. We improve the exact algorithms for solving WVCP on binary trees and propose new and efficient algorithms for WVCP on cycles and cactus paths with maximum degree three. Our work extends the results of Kavitha and Mestre [8]. Our algorithms have a time complexity of \(O(n \log ^2 n)\) for cactus paths and \(O(n^2 \log n)\) for binary trees.