avl-tree

I'm having the hardest time trying to figure out how to balance an AVL tree for my class. I've got it inserting with this: Node* Tree::insert(int d) { cout << "base insert\t" << d << endl; if (head == NULL) return (head = new Node(d)); else return insert(head, d); } Node* Tree::insert(Node*& current, int d) { cout << "insert\t" << d << endl; if (current == NULL) current = new Node(d); else if (d < current->data) { insert(current->lchild, d); if (height(current->lchild) - height(current->rchild)) { if (d < current->lchild->getData()) rotateLeftOnce(current); else rotateLeftTwice(current); } }

Is there a formula to calculate what the maximum and minimum height for an AVL tree, given a certain number of nodes? For example: Textbook question: What is the maximum/minimum height for an AVL tree of 3 nodes, 5 nodes, and 7 nodes? Textbook answer: The maximum/minimum height for an AVL tree of 3 nodes is 2/2, for 5 nodes is 3/3, for 7 nodes is 4/3 I don't know if they figured it out by some magic formula, or if they draw out the AVL tree for each of the given heights and determined it that way. The solution below is appropriate for working things out by hand and gaining an intuition, please

As a programmer when should I consider using a RB tree, B- tree or an AVL tree? What are the key points that needs to be considered before deciding on the choice? Can someone please explain with a scenario for each tree structure why it is chosen over others with reference to the key points? Take this with a pinch of salt: B-tree when you're managing more than thousands of items and you're paging them from a disk or some slow storage medium. RB tree when you're doing fairly frequent inserts, deletes and retrievals on the tree. AVL tree when your inserts and deletes are infrequent relative to

So I'm given an AVL tree. And im trying to figure out at least the pseudocode to find the key with the minimum data values among all of the keys between two values k1 and k2. This is assuming that the field data stored in each node is an integer. I want to make sure that my pseudocode runs in O(logn) time. I know that I can do it by storing an extra field in the node structure..and showing how this field can be maintained during updates, but I don't know where to go from there. Let's assume that the node structure looks like this (Java). class Node { Node left; Node right; int key; int value;

This question is an exact duplicate of: AVL Tree: Finding the key with the smallest data values in keys between two values in O(logn) time 1 answer I have an AVL tree while each node consists of: Key Value The AVL tree is ordered by the keys . So if I got 2 keys and now I want to find the maximum value between those 2 keys. I've tried adding additional information to each node like the max value in the left subtree and same for the right subtree but I can't get the right algorithm without "losing" some nodes between. Complexity time: O(log n) worst case . What other operations do you need on

My best guess is that one rotation is always enough to balance an AVL tree when you insert or delete ONE element from an already balanced AVL tree. Is one rotation always enough? An example will help where more than one rotations are needed. PS: I count RL/LR rotations as one rotation only. For insert 1 rotation is at most. For delete the number of rotation is bounded by O(log(n)). Log(n) is the height of the tree. More explanation on AVL deletion. When you delete a node from AVL you might cause the tree unbalanced, which you have to trace back to the point where it is unbalanced. If the

Assume that I have two AVL trees and that each element from the first tree is smaller then any element from the second tree. What is the most efficient way to concatenate them into one single AVL tree? I've searched everywhere but haven't found anything useful. Assuming you may destroy the input trees: remove the rightmost element for the left tree, and use it to construct a new root node, whose left child is the left tree, and whose right child is the right tree: O(log n) determine and set that node's balance factor: O(log n). In (temporary) violation of the invariant, the balance factor may