AVL Tree

AVL TREE:
It is one of the types of the binary tree, or we can say that it is a variant of
the binary search tree. AVL tree satisfies the property of the binary tree as well
as of the binary search tree. It is a self-balancing binary search tree that was
invented by Adelson Velsky Lindas. Here, self-balancing means that balancing the
heights of left subtree and right subtree. This balancing is measured in terms of
the balancing factor.
We can consider a tree as an AVL tree if the tree obeys the binary search tree as
well as a balancing factor. The balancing factor can be defined as the difference
between the height of the left subtree and the height of the right subtree. The
balancing factor's value must be either 0, -1, or 1; therefore, each node in the
AVL tree should have the value of the balancing factor either as 0, -1, or 1.
Most of the BST operations (e.g., search, max, min, insert, delete.. etc) take O(h)
time where h is the height of the BST. The cost of these operations may become O(n)
for a skewed Binary tree. If we make sure that height of the tree remains O(Logn)
after every insertion and deletion, then we can guarantee an upper bound of O(Logn)
for all these operations. The height of an AVL tree is always O(Logn) where n is
the number of nodes in the tree (See this video lecture for proof).
Insertion
To make sure that the given tree remains AVL after every insertion, we must augment
the standard BST insert operation to perform some re-balancing. Following are two
basic operations that can be performed to re-balance a BST without violating the
BST property (keys(left) < key(root) < keys(right)).
1) Left Rotation
2) Right Rotation
T1, T2 and T3 are subtrees of the tree

rooted with y (on the left side) or x (on
the right side)
y x
/ \ Right Rotation / \
x T3 - - - - - - - > T1 y
/ \ < - - - - - - - / \
T1 T2 Left Rotation T2 T3
Keys in both of the above trees follow the
following order
keys(T1) < key(x) < keys(T2) < key(y) < keys(T3)
So BST property is not violated anywhere.
Steps to follow for insertion
Let the newly inserted node be w
1) Perform standard BST insert for w.
2) Starting from w, travel up and find the first unbalanced node. Let z be the
first unbalanced node, y be the child of z that comes on the path from w to z and x
be the grandchild of z that comes on the path from w to z.
3) Re-balance the tree by performing appropriate rotations on the subtree rooted
with z. There can be 4 possible cases that needs to be handled as x, y and z can be
arranged in 4 ways. Following are the possible 4 arrangements:
a) y is left child of z and x is left child of y (Left Left Case)
b) y is left child of z and x is right child of y (Left Right Case)
c) y is right child of z and x is right child of y (Right Right Case)
d) y is right child of z and x is left child of y (Right Left Case)
Following are the operations to be performed in above mentioned 4 cases. In all of
the cases, we only need to re-balance the subtree rooted with z and the complete
tree becomes balanced as the height of subtree (After appropriate rotations) rooted
with z becomes same as it was before insertion. (See this video lecture for proof)
a) Left Left Case
T1, T2, T3 and T4 are subtrees.

z y
/ \ / \
y T4 Right Rotate (z) x z
/ \ - - - - - - - - -> / \ / \
x T3 T1 T2 T3 T4
/ \
T1 T2
b) Left Right Case
z z x
/ \ / \ / \
y T4 Left Rotate (y) x T4 Right Rotate(z) y z
/ \ - - - - - - - - -> / \ - - - - - - - -> / \ / \
T1 x y T3 T1 T2 T3 T4
/ \ / \
T2 T3 T1 T2
c) Right Right Case
z y
/ \ / \
T1 y Left Rotate(z) z x
/ \ - - - - - - - -> / \ / \
T2 x T1 T2 T3 T4
/ \
T3 T4
d) Right Left Case
z z x
/ \ / \ / \
T1 y Right Rotate (y) T1 x Left Rotate(z) z y
/ \ - - - - - - - - -> / \ - - - - - - - -> / \ / \
x T4 T2 y T1 T2 T3 T4
/ \ / \
T2 T3 T3 T4
// Java program for insertion in AVL Tree

class Node {
int key, height;
Node left, right;
Node(int d) {
key = d;
height = 1;
}
}
class AVLTree {
Node root;
// A utility function to get the height of the tree

int height(Node N) {
if (N == null)
return 0;
return N.height;
}
// A utility function to get maximum of two integers

int max(int a, int b) {
return (a > b) ? a : b;
}
// A utility function to right rotate subtree rooted with y

// See the diagram given above.
Node rightRotate(Node y) {
Node x = y.left;
Node T2 = x.right;
// Perform rotation
x.right = y;
y.left = T2;
// Update heights
y.height = max(height(y.left), height(y.right)) + 1;
x.height = max(height(x.left), height(x.right)) + 1;
// Return new root

return x;
}
// A utility function to left rotate subtree rooted with x

// See the diagram given above.
Node leftRotate(Node x) {
Node y = x.right;
Node T2 = y.left;
// Perform rotation
y.left = x;
x.right = T2;
// Update heights
x.height = max(height(x.left), height(x.right)) + 1;
y.height = max(height(y.left), height(y.right)) + 1;
// Return new root

return y;
}
// Get Balance factor of node N

int getBalance(Node N) {
if (N == null)
return 0;
return height(N.left) - height(N.right);

}
Node insert(Node node, int key) {
/* 1. Perform the normal BST insertion */

if (node == null)
return (new Node(key));
if (key < node.key)

node.left = insert(node.left, key);
else if (key > node.key)
node.right = insert(node.right, key);
else // Duplicate keys not allowed
return node;
/* 2. Update height of this ancestor node */

node.height = 1 + max(height(node.left),
height(node.right));
/* 3. Get the balance factor of this ancestor

node to check whether this node became
unbalanced */
int balance = getBalance(node);
// If this node becomes unbalanced, then there

// are 4 cases Left Left Case
if (balance > 1 && key < node.left.key)
return rightRotate(node);
// Right Right Case

if (balance < -1 && key > node.right.key)
return leftRotate(node);
// Left Right Case

if (balance > 1 && key > node.left.key) {
node.left = leftRotate(node.left);
return rightRotate(node);
}
// Right Left Case

if (balance < -1 && key < node.right.key) {
node.right = rightRotate(node.right);
return leftRotate(node);
}
/* return the (unchanged) node pointer */

return node;
}
// A utility function to print preorder traversal

// of the tree.
// The function also prints height of every node
void preOrder(Node node) {
if (node != null) {
System.out.print(node.key + " ");
preOrder(node.left);
preOrder(node.right);
}
}
public static void main(String[] args) {

AVLTree tree = new AVLTree();
/* Constructing tree given in the above figure */

tree.root = tree.insert(tree.root, 10);
/* The constructed AVL Tree would be

30
/ \
20 40
/ \ \
10 25 50
*/
System.out.println("Preorder traversal" +
" of constructed tree is : ");
tree.preOrder(tree.root);
}
}
// This code has been contributed by Mayank Jaiswal

AVL Tree

Uploaded by

Copyright:

Available Formats

AVL Tree

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

AVL Tree

Uploaded by

Copyright:

Available Formats

AVL TREE:

T1, T2 and T3 are subtrees of the tree

T1, T2, T3 and T4 are subtrees.

// Java program for insertion in AVL Tree

// A utility function to get the height of the tree

// A utility function to get maximum of two integers

// A utility function to right rotate subtree rooted with y

// Return new root

// A utility function to left rotate subtree rooted with x

// Return new root

// Get Balance factor of node N

return height(N.left) - height(N.right);

Node insert(Node node, int key) {

/* 1. Perform the normal BST insertion */

if (key < node.key)

/* 2. Update height of this ancestor node */

/* 3. Get the balance factor of this ancestor

// If this node becomes unbalanced, then there

// Right Right Case

// Left Right Case

// Right Left Case

/* return the (unchanged) node pointer */

// A utility function to print preorder traversal

public static void main(String[] args) {

/* Constructing tree given in the above figure */

/* The constructed AVL Tree would be

You might also like