AVL Tree Data Structure (original) (raw)

Last Updated : 20 Dec, 2025

An AVL tree defined as a self-balancing Binary Search Tree (BST) where the difference between heights of left and right subtrees for any node cannot be more than one.

Balance Factor = left subtree height - right subtree height
For a Balanced Tree(for every node): -1 ≤ Balance Factor ≤ 1

Example of an AVL Tree:

The balance factors for different nodes are: 12 : +1, 8 : +1, 18 : +1, 5 : +1, 11 : 0, 17 : 0 and 4 : 0. Since all differences are lies between -1 to +1, so the tree is an AVL tree.

Example of a BST which is not an AVL Tree:

The Below Tree is **not an AVL Tree as the balance factor for nodes **8 and 12 is more than **1.

Important Points about AVL Tree:

• **Rotations: rotations are designed to restore balance in **O(1) time while ensuring the overall time complexity remains **O(log n). AVL Trees use four cases to rebalance themselves after insertions and deletions: Left-Left (LL), Right-Right (RR), Left-Right (LR) and Right-Left (RL)
• **Insertion and Deletion: While insertion is followed by upward traversals to check balance and apply rotations, deletion can be more complex due to multiple rotations possibly being required. AVL Trees may require multiple rebalancing steps during deletion, unlike Red-Black Trees which limit this better.
• **Use Cases: AVL Trees are particularly useful when you need frequent and efficient lookups, like in database indexing, memory-intensive applications, or where predictable time complexity is crucial.
• **Drawbacks Compared to Other Trees: Although faster in lookups than Red-Black Trees, AVL Trees might incur slightly more overhead on insertions and deletions due to stricter balancing requirements. As a result, Red-Black Trees are more common in standard libraries like TreeMap or TreeSet in Java or map in C++ STL.
• **In-order Traversal: An in-order traversal of an AVL Tree still gives you elements in sorted order, just like any Binary Search Tree.

Operations on an AVL Tree:

• **Searching : It is same as normal Binary Search Tree (BST) as an AVL Tree is always a BST. So we can use the same implementation as BST. The advantage here is time complexity is O(log n)
• **Insertion : It does rotations along with normal BST insertion to make sure that the balance factor of the impacted nodes is less than or equal to 1 after insertion
• **Deletion : It also does rotations along with normal BST deletion to make sure that the balance factor of the impacted nodes is less than or equal to 1 after deletion.

Please refer Insertion in AVL Tree and Deletion in AVL Tree for details.

Rotating the subtrees (Used in Insertion and Deletion)

An AVL tree may rotate in one of the following four ways to keep itself balanced while making sure that the BST properties are maintained.

1. **Left-Left Case:

• Occurs when a node is inserted into the left subtree of the left child, causing the balance factor to become more than +1.
• **Fix: Perform a single right rotation.

**2. **Right-Right Case:

• Occurs when a node is inserted into the right subtree of the right child, making the balance factor **less than -1.
• **Fix: Perform a single **left rotation.

3. **Left-Right Case:

• **Occurs when a node is inserted into the right subtree of the left child, which disturbs the balance factor of an ancestor node, making it **left-heavy.
• **Fix: Perform a left rotation on the left child, followed by a right rotation on the node.

**4. **Right-Left Case:

• Occurs when a node is inserted into the left subtree of the right child, which disturbs the balance factor of an ancestor node, making it **right-heavy.
• **Fix: Perform a right rotation on the right child, followed by a left rotation on the node.

Applications of AVL Tree:

1. AVL Tree is used as a first example self balancing BST in teaching DSA as it is easier to understand and implement compared to Red Black
2. Applications, where insertions and deletions are less common but frequent data lookups along with other operations of BST like sorted traversal, floor, ceil, min and max.
3. Red Black tree is more commonly implemented in language libraries like map in C++, set in C++, TreeMap in Java and TreeSet in Java.
4. AVL Trees can be used in a real time environment where predictable and consistent performance is required.

Advantages of AVL Tree:

1. AVL trees can self-balance themselves and therefore provides time complexity as O(log n) for **search, **insert and **delete.
2. As it is a balanced BST, so items can be traversed in sorted order.
3. Since the balancing rules are strict compared to Red Black Tree, AVL trees in general have relatively less height and hence the search is faster.
4. AVL tree is relatively less complex to understand and implement compared to Red Black Trees.

Disadvantages of AVL Tree:

1. It is difficult to implement compared to normal BST.
2. Less used compared to Red-Black trees. Due to its rather strict balance.
3. AVL trees provide complicated insertion and removal operations as more rotations are performed.

**Related Articles:

• Insertion in an AVL Tree
• Deletion in an AVL Tree
• Red Black Tree