Scribd
Upload
64 views17 pages

38-Implementation of AVL Tree-12-11-2024

Uploaded by

THE ETERNAL GOD Soul of a legend
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
64 views17 pages

38-Implementation of AVL Tree-12-11-2024

Uploaded by

THE ETERNAL GOD Soul of a legend
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 17

IMPLEMENTATION OF AVL TREES

Dr. Iyappan Perumal


Associate Professor
School of Computer Science & Engineering
VIT,Vellore.
AVL Trees
 AVL tree is a height-balanced binary search
tree
 It is also a binary search tree but it is a
balanced tree.
 What is Balanced Tree?
◦ A binary tree is said to be balanced if, the
difference between the heights of left and right
subtrees of every node in the tree is either -1,
0 or +1
 In an AVL tree, every node maintains an
extra information known as balance factor
Construction of AVL Tree (1 to 8)
Example:
BF=-1
4

BF=0 BF=-1
2 6

BF=0 BF=0 BF=0 BF=-1


1 5 7
3
BF=0
8

TREE is balanced
Node Structure
Struct Node
{
int data;
struct Node *left;
struct Node *right;
int height;
};
LEFT DATA RIGHT HEIGHT

NODE
Height of the Node
Height(Struct Node *Node)
{
if(Node==NULL)
return 0;
return Node->Height;
}

LEFT DATA RIGHT HEIGHT

NODE
Creation of Node
Create newNode(int value)
{
Struct Node *newnode;
newnode= malloc(sizeof(Struct node);
newnode->data=value;
newnode->left=NULL;
newnode->right=NULL;
newnode->height=1;
return newNode;
NULL 10 NULL 1
}
newNODE
Balance Factor of the Node
Balance Factor(Struct Node *Node)
{
if(Node==NULL)
return 0;
return height(Node->left)-height(Node->right) ;
}

LEFT DATA RIGHT HEIGHT

NODE
Left Rotate
Struct Node *Left Rotate( Struct node *x)
{
Struct Node *y= x->right;
Struct Node *T= y->left;
y->left =x;
x->right=T;
x->height= max(height(x->left), height(x->right))+1;
y->height= max(height(y->left), height(y->right))+1;
return y;
}
Right Rotate
Struct Node *Right Rotate( Struct node *y)
{
Struct Node *x= y->left;
Struct Node *T= x->right;
x->right=y;
y->left =T;
y->height= max(height(y->left), height(y->right))+1;
x->height= max(height(x->left), height(x->right))+1;
return x;
}
Finding Max
Max( a,b)
{
return(a>b)? a:b;
}

//Returns which is maximum among a and b


Insertion Operation Node and value to be
insert(struct * node, int value)inserted is passed
every time
{
if(node == NULL)
return newNode(value);
if(value < node->data)
{
node->left = insert(node- >left, value);
else if(value > node->data)
node->right =insert(node->right, value);
else
return node
}

// founds the correct position and inserts node


Insertion Operation
// Update the height & Balance Factor of each node
Node->height =max[height(node->left), height(node->right)]+1;
Balance = Balance Factor(node);
// ROTATIONS
if(balance>1 && value<node>left->value)// RR Rotation
return rightrotate(node);
if(balance <-1&& value>node->right->value)// LL Rotation
return leftrotate(node);
if(balance >1&& value>node->left->value)// LR Rotation
node->left= leftrotate(node->left);
return rightrotate(node);
if(balance <-1&& value<node->right->value)// RL Rotation
node->right= rightrotate(node->right);
return leftrotate(node);
return node;
}
deleteNode(struct node* root, int value)
{
if (root == NULL) // value not found
return root;
// key less than value of root then it lies in left subtree
if (value< root->data)
root->left = deleteNode(root->left, value);
// key greater than value of root then it lies in right subtree
else if (value > root->data)
root->right = deleteNode(root->right, value);
// key is same as value of root, node be deleted is found
else
{
// node with only one child or no child
if (root->left == NULL)
{
struct node* temp = root->right;
free(root);
return temp;
}
else if (root->right == NULL)
{
struct node* temp = root->left;
free(root);
return temp;
}
// node with two children, Get smallest in
the right subtree)
struct node* temp = minValueNode(root->right);
root->value = temp->value;
// Delete the node
root->right = deleteNode(root->right, temp->value);
}
return root;
}
// Update the height & Balance Factor of each node
root->height =max[height(root->left), height(root->right)]+1;
Balance = Balance Factor(root);
// ROTATIONS
if(balance>1 && value<root->left->value)// RR Rotation
return rightrotate(root);
if(balance <-1&& value>root->right->value)// LL Rotation
return leftrotate(root);
if(balance >1&& value>root->left->value)// LR Rotation
root->left= leftrotate(rotate->left);
return rightrotate(root);
if(balance <-1&& value<root->right->value)// RL Rotation
root->right= rightrotate(root->right);
return leftrotate(root);
return root;
}

You might also like