EDUCBA

Home Data Science Data Science Tutorials Data Structures Tutorial AVL Tree Rotation

AVL Tree Rotation

AVL Tree Rotation

Introduction to AVL Tree Rotation

The following article provides an outline for AVL Tree Rotation. AVL Tree is a Binary Search Tree and is also known as a self-balancing tree in which each node is connected to a balance factor which is calculated by subtracting the heights of the right subtree from that of the left subtree of a particular node. The tree is defined as a balanced AVL tree when the balance factor of each node is between -1 and 1. On the other hand, when the balance factor is less than -1 or greater than 1, then the tree is known as an unbalanced tree and needs to be balanced to get the perfect AVL tree.

  • If the balance factor obtained is -1 for a particular node, it defines that the node’s left subtree is one level higher than the right subtree.
  • If the balance factor obtained is 0 for a particular node, it defines that the node’s left subtree and right subtree are at an equal level.
  • If the balance factor obtained is 1 for a particular node, it defines that the left subtree is one level lower than the node’s right subtree.

Balanced AVL Tree Example:

AVL Tree Rotation 1

Rotation Operations in AVL Tree

Rotation is performed in AVL Tree to turn the unbalanced tree into a balanced tree by performing various rotation operations.

Start Your Free Data Science Course

Hadoop, Data Science, Statistics & others

In general, there are four types of Rotations in the AVL tree:

  • Left Rotation
  • Right Rotation
  • Left-Right Rotation
  • Right-Left Rotation

The first two rotations are known as single rotations, and the next two are known as double rotations.

1. Left Rotation (LL)

When a node is inserted into the left subtree or deleted from the left subtree, the AVL tree becomes unbalanced, and we need to balance it using LL rotation. This LL rotation is also known as clockwise rotation applied on edge, which has the highest balance factor.

AVL Tree Rotation 2

2. Right Rotation(RR)

When a node gets inserted into the right subtree or deleted from the right subtree, the AVL tree becomes unbalanced, and we need to balance it by rotating the node in the anti-clockwise direction. This rotation technique is applied on the edge of the node which is having the highest balance factor.

Right Rotation(RR)

3. Left-Right Rotation(LR)

Left-Right Rotation is the combination of RR rotation and LL rotation. At first, RR rotation is performed on the subtree then, LL rotation is performed on the part of the full tree from inserted node to the first node

4. Right-Left Rotation(RL)

Right-left Rotation is the combination of LL rotation and RR rotation. In this case, the first LL rotation is performed on the subtree where the change has been made; then, the RR rotation is performed on the part of the full tree from the inserted node to the top of the tree, that is, the first node.

Example of AVL Tree Rotation

Given below is the example of AVL Tree Rotation:

AVL tree in Python.

Code:

import sys
# Create a node
class TreeNode(object):
def __init__(self, key):
self.key = key
self.left = None
self.right = None
self.height = 1
class AVLTree(object):
# Function to insert a node
def insert_node(self, root, key):
# Insert the node at the correct location
if not root:
return TreeNode(key)
elif key < root.key:
root.left = self.insert_node(root.left, key)
else:
root.right = self.insert_node(root.right, key)
root.height = 1 + max(self.getHeight(root.left),
self.getHeight(root.right))
# Balance the tree by updating the balance factor
balanceFactor = self.getBalance(root)
if balanceFactor > 1:
if key < root.left.key:
return self.rightRotate(root)
else:
root.left = self.leftRotate(root.left)
return self.rightRotate(root)
if balanceFactor < -1:
if key > root.right.key:
return self.leftRotate(root)
else:
root.right = self.rightRotate(root.right)
return self.leftRotate(root)
return root
#Function to delete a node
def delete_node(self, root, key):
# Remove the deleted node
if not root:
return root
elif key < root.key:
root.left = self.delete_node(root.left, key)
elif key > root.key:
root.right = self.delete_node(root.right, key)
else:
if root.left is None:
temp = root.right
root = None
return temp
elif root.right is None:
temp=root.left
root = None
return temp
temp = self.getMinValueNode(root.right)
root.key = temp.key
root.right = self.delete_node(root.right,
temp.key)
if root is None:
return root
# Update the nodes balance factor
root.height = 1 + max(self.getHeight(root.left),
self.getHeight(root.right))
balanceFactor = self.getBalance(root)
# Balance the tree
if balanceFactor > 1:
if self.getBalance(root.left) >= 0:
return self.rightRotate(root)
else:
root.left = self.leftRotate(root.left)
return self.rightRotate(root)
if balanceFactor < -1:
if self.getBalance(root.right) <= 0:
return self.leftRotate(root)
else:
root.right = self.rightRotate(root.right)
return self.leftRotate(root)
return root
# Function to perform tree’s left rotation
def leftRotate(self, z):
y = z.right
T2 = y.left
y.left = z
z.right = T2
z.height = 1 + max(self.getHeight(z.left),
self.getHeight(z.right))
y.height = 1 + max(self.getHeight(y.left),
self.getHeight(y.right))
return y
# Function to perform tree’s right rotation
def rightRotate(self, z):
y = z.left
T3 = y.right
y.right = z
z.left = T3
z.height = 1 + max(self.getHeight(z.left),
self.getHeight(z.right))
y.height = 1 + max(self.getHeight(y.left),
self.getHeight(y.right))
return y
# Get the height of the node
def getHeight(self, root):
if not root:
return 0
return root.height
# Get the node balance factor
def getBalance(self, root):
if not root:
return 0
return self.getHeight(root.left) - self.getHeight(root.right)
def getMinValueNode(self, root):
if root is None or root.left is None:
return root
return self.getMinValueNode(root.left)
def preOrder(self, root):
if not root:
return
print("{0} ".format(root.key), end="")
self.preOrder(root.left)
self.preOrder(root.right)
# Print the AVL tree
def printHelper(self, currPtr, indent, last):
if currPtr != None:
sys.stdout.write(indent)
if last:
sys.stdout.write("R----")
indent += " "
else:
sys.stdout.write("L----")
indent += "| "
print(currPtr.key)
self.printHelper(currPtr.left, indent, False)
self.printHelper(currPtr.right, indent, True)
myTree = AVLTree()
root = None
nums = [33, 13, 52, 9, 21, 61, 8, 11] for num in nums:
root = myTree.insert_node(root, num)
myTree.printHelper(root, "", True)
key = 13
root = myTree.delete_node(root, key)
print("After Deletion: ")
myTree.printHelper(root, "", True)

Output:

Python

Conclusion

AVL tree is a self-balancing binary tree in which each node is connected to a balance factor. This tree is named in honor of the inventors GM Adelson-Velsky and EM Landis in 1962. The balance factor is calculated by subtracting the heights of the right subtree from the left subtree of a particular node. There are four types of Rotations in the AVL tree: Left rotation, Right rotation, Left-Right rotation, Right-Left rotation.

Recommended Articles

This is a guide to AVL Tree Rotation. Here we discuss the introduction, rotation operations in AVL tree and example, respectively. You may also have a look at the following articles to learn more –

  1. Splay Tree in Data Structure
  2. AVL Tree in Data Structure
  3. Binary Search Tree Types
  4. Hash Table in Data Structure
0 Shares
Share
Tweet
Share