Insertion, Searching and Deletion in AVL trees containing a parent node pointer
Last Updated :
21 May, 2024
AVL tree is a self-balancing Binary Search Tree (BST) where the difference between heights of left and right subtrees cannot be more than one for all nodes. The insertion and deletion in AVL trees have been discussed in the previous article. In this article, insert, search, and delete operations are discussed on AVL trees that also have a parent pointer in their structure.
Definition of AVL tree node:
C++
struct AVLwithparent {
// Pointer to the left and the
// right subtree
struct AVLwithparent* left;
struct AVLwithparent* right;
// Stores the data in the node
int key;
// Stores the parent pointer
struct AVLwithparent* par;
// Stores the height of the
// current tree
int height;
}
class AVLwithParent {
// Pointer to the left and the right subtree
AVLwithParent left;
AVLwithParent right;
// Stores the data in the node
int key;
// Stores the parent pointer
AVLwithParent par;
// Stores the height of the current tree
int height;
}
# Python code
class AVLwithParent:
def __init__(self):
# Pointer to the left and the right subtree
self.left = None
self.right = None
# Stores the data in the node
self.key = None
# Stores the parent pointer
self.par = None
# Stores the height of the current tree
self.height = None
# This code is contributed by princekumaras
class AVLwithParent
{
// Pointer to the left and the right subtree
public AVLwithParent left;
public AVLwithParent right;
// Stores the data in the node
public int key;
// Stores the parent pointer
public AVLwithParent par;
// Stores the height of the current tree
public int height;
}
class AVLwithParent {
constructor() {
// Pointer to the left and the right subtree
this.left = null;
this.right = null;
// Stores the data in the node
this.key = null;
// Stores the parent pointer
this.par = null;
// Stores the height of the current tree
this.height = null;
}
}
Representation of the Node:
Below is the example of an AVL tree containing a parent pointer:
Insert Operation: The insertion procedure is similar to that of a normal AVL tree without a parent pointer, but in this case, the parent pointers need to be updated with every insertion and rotation accordingly. Follow the steps below to perform insert operation:
- Perform standard BST insert for the node to be placed at its correct position.
- Increase the height of each node encountered by 1 while finding the correct position for the node to be inserted.
- Update the parent and child pointers of the inserted node and its parent respectively.
- Starting from the inserted node till the root node check if the AVL condition is satisfied for each node on this path.
- If w is the node where the AVL condition is not satisfied then we have 4 cases:
- Left Left Case: (If the left subtree of the left child of w has the inserted node)
- Left Right Case: (If the right subtree of the left child of w has the inserted node)
- Right Left Case: (If the left subtree of the right child of w has the inserted node)
- Right Right Case: (If the right subtree of the right child of w has the inserted node)
Below is the implementation of the above approach:
C++
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// AVL tree node
struct AVLwithparent {
struct AVLwithparent* left;
struct AVLwithparent* right;
int key;
struct AVLwithparent* par;
int height;
};
// Function to update the height of
// a node according to its children's
// node's heights
void Updateheight(
struct AVLwithparent* root)
{
if (root != NULL) {
// Store the height of the
// current node
int val = 1;
// Store the height of the left
// and right subtree
if (root->left != NULL)
val = root->left->height + 1;
if (root->right != NULL)
val = max(
val, root->right->height + 1);
// Update the height of the
// current node
root->height = val;
}
}
// Function to handle Left Left Case
struct AVLwithparent* LLR(
struct AVLwithparent* root)
{
// Create a reference to the
// left child
struct AVLwithparent* tmpnode = root->left;
// Update the left child of the
// root to the right child of the
// current left child of the root
root->left = tmpnode->right;
// Update parent pointer of the
// left child of the root node
if (tmpnode->right != NULL)
tmpnode->right->par = root;
// Update the right child of
// tmpnode to root
tmpnode->right = root;
// Update parent pointer of
// the tmpnode
tmpnode->par = root->par;
// Update the parent pointer
// of the root
root->par = tmpnode;
// Update tmpnode as the left or the
// right child of its parent pointer
// according to its key value
if (tmpnode->par != NULL
&& root->key < tmpnode->par->key) {
tmpnode->par->left = tmpnode;
}
else {
if (tmpnode->par != NULL)
tmpnode->par->right = tmpnode;
}
// Make tmpnode as the new root
root = tmpnode;
// Update the heights
Updateheight(root->left);
Updateheight(root->right);
Updateheight(root);
Updateheight(root->par);
// Return the root node
return root;
}
// Function to handle Right Right Case
struct AVLwithparent* RRR(
struct AVLwithparent* root)
{
// Create a reference to the
// right child
struct AVLwithparent* tmpnode = root->right;
// Update the right child of the
// root as the left child of the
// current right child of the root
root->right = tmpnode->left;
// Update parent pointer of the
// right child of the root node
if (tmpnode->left != NULL)
tmpnode->left->par = root;
// Update the left child of the
// tmpnode to root
tmpnode->left = root;
// Update parent pointer of
// the tmpnode
tmpnode->par = root->par;
// Update the parent pointer
// of the root
root->par = tmpnode;
// Update tmpnode as the left or
// the right child of its parent
// pointer according to its key value
if (tmpnode->par != NULL
&& root->key < tmpnode->par->key) {
tmpnode->par->left = tmpnode;
}
else {
if (tmpnode->par != NULL)
tmpnode->par->right = tmpnode;
}
// Make tmpnode as the new root
root = tmpnode;
// Update the heights
Updateheight(root->left);
Updateheight(root->right);
Updateheight(root);
Updateheight(root->par);
// Return the root node
return root;
}
// Function to handle Left Right Case
struct AVLwithparent* LRR(
struct AVLwithparent* root)
{
root->left = RRR(root->left);
return LLR(root);
}
// Function to handle right left case
struct AVLwithparent* RLR(
struct AVLwithparent* root)
{
root->right = LLR(root->right);
return RRR(root);
}
// Function to insert a node in
// the AVL tree
struct AVLwithparent* Insert(
struct AVLwithparent* root,
struct AVLwithparent* parent,
int key)
{
if (root == NULL) {
// Create and assign values
// to a new node
root = new struct AVLwithparent;
// If the root is NULL
if (root == NULL) {
cout << "Error in memory"
<< endl;
}
// Otherwise
else {
root->height = 1;
root->left = NULL;
root->right = NULL;
root->par = parent;
root->key = key;
}
}
else if (root->key > key) {
// Recur to the left subtree
// to insert the node
root->left = Insert(root->left,
root, key);
// Store the heights of the
// left and right subtree
int firstheight = 0;
int secondheight = 0;
if (root->left != NULL)
firstheight = root->left->height;
if (root->right != NULL)
secondheight = root->right->height;
// Balance the tree if the
// current node is not balanced
if (abs(firstheight
- secondheight)
== 2) {
if (root->left != NULL
&& key < root->left->key) {
// Left Left Case
root = LLR(root);
}
else {
// Left Right Case
root = LRR(root);
}
}
}
else if (root->key < key) {
// Recur to the right subtree
// to insert the node
root->right = Insert(root->right,
root, key);
// Store the heights of the
// left and right subtree
int firstheight = 0;
int secondheight = 0;
if (root->left != NULL)
firstheight
= root->left->height;
if (root->right != NULL)
secondheight = root->right->height;
// Balance the tree if the
// current node is not balanced
if (abs(firstheight - secondheight) == 2) {
if (root->right != NULL
&& key < root->right->key) {
// Right Left Case
root = RLR(root);
}
else {
// Right Right Case
root = RRR(root);
}
}
}
// Case when given key is already
// in the tree
else {
}
// Update the height of the
// root node
Updateheight(root);
// Return the root node
return root;
}
// Function to print the preorder
// traversal of the AVL tree
void printpreorder(
struct AVLwithparent* root)
{
// Print the node's value along
// with its parent value
cout << "Node: " << root->key
<< ", Parent Node: ";
if (root->par != NULL)
cout << root->par->key << endl;
else
cout << "NULL" << endl;
// Recur to the left subtree
if (root->left != NULL) {
printpreorder(root->left);
}
// Recur to the right subtree
if (root->right != NULL) {
printpreorder(root->right);
}
}
// Driver Code
int main()
{
struct AVLwithparent* root;
root = NULL;
// Function Call to insert nodes
root = Insert(root, NULL, 10);
root = Insert(root, NULL, 20);
root = Insert(root, NULL, 30);
root = Insert(root, NULL, 40);
root = Insert(root, NULL, 50);
root = Insert(root, NULL, 25);
// Function call to print the tree
printpreorder(root);
}
class AVLwithparent {
int key;
AVLwithparent left;
AVLwithparent right;
AVLwithparent par;
int height;
public AVLwithparent(int key) {
this.key = key;
this.left = null;
this.right = null;
this.par = null;
this.height = 1;
}
}
public class AVLTreeWithParent {
// Function to update the height of a node based on its children's heights
public static void updateHeight(AVLwithparent root) {
if (root != null) {
int leftHeight = (root.left != null) ? root.left.height : 0;
int rightHeight = (root.right != null) ? root.right.height : 0;
root.height = Math.max(leftHeight, rightHeight) + 1;
}
}
// Left-Left Rotation (LLR) to balance the AVL tree
public static AVLwithparent LLR(AVLwithparent root) {
AVLwithparent tmpnode = root.left;
root.left = tmpnode.right;
if (tmpnode.right != null) {
tmpnode.right.par = root;
}
tmpnode.right = root;
tmpnode.par = root.par;
root.par = tmpnode;
if (tmpnode.par != null) {
if (root.key < tmpnode.par.key) {
tmpnode.par.left = tmpnode;
} else {
tmpnode.par.right = tmpnode;
}
}
updateHeight(root);
updateHeight(tmpnode);
return tmpnode;
}
// Right-Right Rotation (RRR) to balance the AVL tree
public static AVLwithparent RRR(AVLwithparent root) {
AVLwithparent tmpnode = root.right;
root.right = tmpnode.left;
if (tmpnode.left != null) {
tmpnode.left.par = root;
}
tmpnode.left = root;
tmpnode.par = root.par;
root.par = tmpnode;
if (tmpnode.par != null) {
if (root.key < tmpnode.par.key) {
tmpnode.par.left = tmpnode;
} else {
tmpnode.par.right = tmpnode;
}
}
updateHeight(root);
updateHeight(tmpnode);
return tmpnode;
}
// Left-Right Rotation (LRR) to balance the AVL tree
public static AVLwithparent LRR(AVLwithparent root) {
root.left = RRR(root.left);
return LLR(root);
}
// Right-Left Rotation (RLR) to balance the AVL tree
public static AVLwithparent RLR(AVLwithparent root) {
root.right = LLR(root.right);
return RRR(root);
}
// Function to insert a key into the AVL tree and balance the tree if needed
public static AVLwithparent insert(AVLwithparent root, AVLwithparent parent, int key) {
if (root == null) {
root = new AVLwithparent(key);
root.par = parent;
} else if (root.key > key) {
root.left = insert(root.left, root, key);
int leftHeight = (root.left != null) ? root.left.height : 0;
int rightHeight = (root.right != null) ? root.right.height : 0;
if (Math.abs(leftHeight - rightHeight) == 2) {
if (key < root.left.key) {
root = LLR(root);
} else {
root = LRR(root);
}
}
} else if (root.key < key) {
root.right = insert(root.right, root, key);
int leftHeight = (root.left != null) ? root.left.height : 0;
int rightHeight = (root.right != null) ? root.right.height : 0;
if (Math.abs(leftHeight - rightHeight) == 2) {
if (key < root.right.key) {
root = RLR(root);
} else {
root = RRR(root);
}
}
}
updateHeight(root);
return root;
}
// Function to print the nodes of the AVL tree in preorder
public static void printPreorder(AVLwithparent root) {
if (root != null) {
String parentKey = (root.par != null) ? Integer.toString(root.par.key) : "NULL";
System.out.println("Node: " + root.key + ", Parent Node: " + parentKey);
printPreorder(root.left);
printPreorder(root.right);
}
}
public static void main(String[] args) {
AVLwithparent root = null;
root = insert(root, null, 10);
root = insert(root, null, 20);
root = insert(root, null, 30);
root = insert(root, null, 40);
root = insert(root, null, 50);
root = insert(root, null, 25);
printPreorder(root);
}
}
class AVLwithparent:
def __init__(self, key):
# Initialize a node with key, left and right child, parent, and height.
self.left = None
self.right = None
self.key = key
self.par = None
self.height = 1
# Function to update the height of a node based on its children's heights
def update_height(root):
if root is not None:
left_height = root.left.height if root.left else 0 # Get the height of the left child
right_height = root.right.height if root.right else 0 # Get the height of the right child
root.height = max(left_height, right_height) + 1 # Update the height of the current node
# Left-Left Rotation (LLR) to balance the AVL tree
def LLR(root):
# Perform a left rotation and then a right rotation
# to balance the tree when there's an imbalance in the left subtree
tmpnode = root.left
root.left = tmpnode.right
if tmpnode.right:
tmpnode.right.par = root
tmpnode.right = root
tmpnode.par = root.par
root.par = tmpnode
if tmpnode.par:
if root.key < tmpnode.par.key:
tmpnode.par.left = tmpnode
else:
tmpnode.par.right = tmpnode
update_height(root)
update_height(tmpnode)
return tmpnode
# Right-Right Rotation (RRR) to balance the AVL tree
def RRR(root):
# Perform a right rotation and then a left rotation
# to balance the tree when there's an imbalance in the right subtree
tmpnode = root.right
root.right = tmpnode.left
if tmpnode.left:
tmpnode.left.par = root
tmpnode.left = root
tmpnode.par = root.par
root.par = tmpnode
if tmpnode.par:
if root.key < tmpnode.par.key:
tmpnode.par.left = tmpnode
else:
tmpnode.par.right = tmpnode
update_height(root)
update_height(tmpnode)
return tmpnode
# Left-Right Rotation (LRR) to balance the AVL tree
def LRR(root):
# Perform a right rotation on the left child and then a left rotation on the root
root.left = RRR(root.left)
return LLR(root)
# Right-Left Rotation (RLR) to balance the AVL tree
def RLR(root):
# Perform a left rotation on the right child and then a right rotation on the root
root.right = LLR(root.right)
return RRR(root)
# Function to insert a key into the AVL tree and balance the tree if needed
def insert(root, parent, key):
if root is None:
root = AVLwithparent(key) # Create a new node if the current node is None
root.par = parent # Set the parent of the new node
elif root.key > key:
# Insert the key into the left subtree and balance the tree if needed
root.left = insert(root.left, root, key)
left_height = root.left.height if root.left else 0
right_height = root.right.height if root.right else 0
if abs(left_height - right_height) == 2:
if key < root.left.key:
root = LLR(root)
else:
root = LRR(root)
elif root.key < key:
# Insert the key into the right subtree and balance the tree if needed
root.right = insert(root.right, root, key)
left_height = root.left.height if root.left else 0
right_height = root.right.height if root.right else 0
if abs(left_height - right_height) == 2:
if key < root.right.key:
root = RLR(root)
else:
root = RRR(root)
update_height(root) # Update the height of the current node after insertion
return root # Return the root of the updated subtree
# Function to print the nodes of the AVL tree in preorder
def print_preorder(root):
if root:
parent_key = root.par.key if root.par else "NULL" # Get the key of the parent node or "NULL" if it's None
print(f"Node: {root.key}, Parent Node: {parent_key}") # Print the node and its parent
print_preorder(root.left) # Print the left subtree in preorder
print_preorder(root.right) # Print the right subtree in preorder
# Main function to demonstrate AVL tree operations
if __name__ == "__main__":
root = None # Initialize the root of the AVL tree as None
# Insert keys into the AVL tree
root = insert(root, None, 10)
root = insert(root, None, 20)
root = insert(root, None, 30)
root = insert(root, None, 40)
root = insert(root, None, 50)
root = insert(root, None, 25)
# Print the AVL tree in preorder
print_preorder(root)
using System;
public class AVLwithparent
{
public AVLwithparent left;
public AVLwithparent right;
public int key;
public AVLwithparent par;
public int height;
}
public class Program
{
public static void UpdateHeight(AVLwithparent root)
{
if (root != null)
{
int val = 1;
if (root.left != null)
val = root.left.height + 1;
if (root.right != null)
val = Math.Max(val, root.right.height + 1);
root.height = val;
}
}
public static AVLwithparent LLR(AVLwithparent root)
{
AVLwithparent tmpNode = root.left;
root.left = tmpNode.right;
if (tmpNode.right != null)
tmpNode.right.par = root;
tmpNode.right = root;
tmpNode.par = root.par;
root.par = tmpNode;
if (tmpNode.par != null && root.key < tmpNode.par.key)
{
tmpNode.par.left = tmpNode;
}
else
{
if (tmpNode.par != null)
tmpNode.par.right = tmpNode;
}
root = tmpNode;
UpdateHeight(root.left);
UpdateHeight(root.right);
UpdateHeight(root);
UpdateHeight(root.par);
return root;
}
public static AVLwithparent RRR(AVLwithparent root)
{
AVLwithparent tmpNode = root.right;
root.right = tmpNode.left;
if (tmpNode.left != null)
tmpNode.left.par = root;
tmpNode.left = root;
tmpNode.par = root.par;
root.par = tmpNode;
if (tmpNode.par != null && root.key < tmpNode.par.key)
{
tmpNode.par.left = tmpNode;
}
else
{
if (tmpNode.par != null)
tmpNode.par.right = tmpNode;
}
root = tmpNode;
UpdateHeight(root.left);
UpdateHeight(root.right);
UpdateHeight(root);
UpdateHeight(root.par);
return root;
}
public static AVLwithparent LRR(AVLwithparent root)
{
root.left = RRR(root.left);
return LLR(root);
}
public static AVLwithparent RLR(AVLwithparent root)
{
root.right = LLR(root.right);
return RRR(root);
}
public static AVLwithparent Insert(AVLwithparent root, AVLwithparent parent, int key)
{
if (root == null)
{
root = new AVLwithparent
{
height = 1,
left = null,
right = null,
par = parent,
key = key
};
}
else if (root.key > key)
{
root.left = Insert(root.left, root, key);
int firstHeight = 0;
int secondHeight = 0;
if (root.left != null)
firstHeight = root.left.height;
if (root.right != null)
secondHeight = root.right.height;
if (Math.Abs(firstHeight - secondHeight) == 2)
{
if (root.left != null && key < root.left.key)
{
root = LLR(root);
}
else
{
root = LRR(root);
}
}
}
else if (root.key < key)
{
root.right = Insert(root.right, root, key);
int firstHeight = 0;
int secondHeight = 0;
if (root.left != null)
firstHeight = root.left.height;
if (root.right != null)
secondHeight = root.right.height;
if (Math.Abs(firstHeight - secondHeight) == 2)
{
if (root.right != null && key < root.right.key)
{
root = RLR(root);
}
else
{
root = RRR(root);
}
}
}
else
{
// Case when given key is already in the tree
}
UpdateHeight(root);
return root;
}
public static void PrintPreorder(AVLwithparent root)
{
Console.Write("Node: " + root.key + ", Parent Node: ");
if (root.par != null)
Console.WriteLine(root.par.key);
else
Console.WriteLine("NULL");
if (root.left != null)
{
PrintPreorder(root.left);
}
if (root.right != null)
{
PrintPreorder(root.right);
}
}
public static void Main()
{
AVLwithparent root = null;
root = Insert(root, null, 10);
root = Insert(root, null, 20);
root = Insert(root, null, 30);
root = Insert(root, null, 40);
root = Insert(root, null, 50);
root = Insert(root, null, 25);
PrintPreorder(root);
}
}
class AVLwithparent {
constructor(key) {
this.key = key;
this.left = null;
this.right = null;
this.par = null;
this.height = 1;
}
}
// Function to update the height of a node based on its children's heights
function updateHeight(root) {
if (root !== null) {
const leftHeight = (root.left !== null) ? root.left.height : 0;
const rightHeight = (root.right !== null) ? root.right.height : 0;
root.height = Math.max(leftHeight, rightHeight) + 1;
}
}
// Left-Left Rotation (LLR) to balance the AVL tree
function LLR(root) {
const tmpnode = root.left;
root.left = tmpnode.right;
if (tmpnode.right !== null) {
tmpnode.right.par = root;
}
tmpnode.right = root;
tmpnode.par = root.par;
root.par = tmpnode;
if (tmpnode.par !== null) {
if (root.key < tmpnode.par.key) {
tmpnode.par.left = tmpnode;
} else {
tmpnode.par.right = tmpnode;
}
}
updateHeight(root);
updateHeight(tmpnode);
return tmpnode;
}
// Right-Right Rotation (RRR) to balance the AVL tree
function RRR(root) {
const tmpnode = root.right;
root.right = tmpnode.left;
if (tmpnode.left !== null) {
tmpnode.left.par = root;
}
tmpnode.left = root;
tmpnode.par = root.par;
root.par = tmpnode;
if (tmpnode.par !== null) {
if (root.key < tmpnode.par.key) {
tmpnode.par.left = tmpnode;
} else {
tmpnode.par.right = tmpnode;
}
}
updateHeight(root);
updateHeight(tmpnode);
return tmpnode;
}
// Left-Right Rotation (LRR) to balance the AVL tree
function LRR(root) {
root.left = RRR(root.left);
return LLR(root);
}
// Right-Left Rotation (RLR) to balance the AVL tree
function RLR(root) {
root.right = LLR(root.right);
return RRR(root);
}
// Function to insert a key into the AVL tree and balance the tree if needed
function insert(root, parent, key) {
if (root === null) {
root = new AVLwithparent(key);
root.par = parent;
} else if (root.key > key) {
root.left = insert(root.left, root, key);
const leftHeight = (root.left !== null) ? root.left.height : 0;
const rightHeight = (root.right !== null) ? root.right.height : 0;
if (Math.abs(leftHeight - rightHeight) === 2) {
if (key < root.left.key) {
root = LLR(root);
} else {
root = LRR(root);
}
}
} else if (root.key < key) {
root.right = insert(root.right, root, key);
const leftHeight = (root.left !== null) ? root.left.height : 0;
const rightHeight = (root.right !== null) ? root.right.height : 0;
if (Math.abs(leftHeight - rightHeight) === 2) {
if (key < root.right.key) {
root = RLR(root);
} else {
root = RRR(root);
}
}
}
updateHeight(root);
return root;
}
// Function to print the nodes of the AVL tree in preorder
function printPreorder(root) {
if (root !== null) {
const parentKey = (root.par !== null) ? root.par.key : "NULL";
console.log(`Node: ${root.key}, Parent Node: ${parentKey}`);
printPreorder(root.left);
printPreorder(root.right);
}
}
// Example usage
let root = null;
root = insert(root, null, 10);
root = insert(root, null, 20);
root = insert(root, null, 30);
root = insert(root, null, 40);
root = insert(root, null, 50);
root = insert(root, null, 25);
printPreorder(root);
OutputNode: 30, Parent Node: NULL
Node: 20, Parent Node: 30
Node: 10, Parent Node: 20
Node: 25, Parent Node: 20
Node: 40, Parent Node: 30
Node: 50, Parent Node: 40
Time Complexity: O(log N), where N is the number of nodes of the tree.
Auxiliary Space: O(1)
Search Operation: The search operation in an AVL tree with parent pointers is similar to the search operation in a normal Binary Search Tree. Follow the steps below to perform search operation:
- Start from the root node.
- If the root node is NULL, return false.
- Check if the current node’s value is equal to the value of the node to be searched. If yes, return true.
- If the current node’s value is less than searched key then recur to the right subtree.
- If the current node’s value is greater than searched key then recur to the left subtree.
Below is the implementation of the above approach:
C++
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// AVL tree node
struct AVLwithparent {
struct AVLwithparent* left;
struct AVLwithparent* right;
int key;
struct AVLwithparent* par;
int height;
};
// Function to update the height of
// a node according to its children's
// node's heights
void Updateheight(struct AVLwithparent* root)
{
if (root != NULL) {
// Store the height of the
// current node
int val = 1;
// Store the height of the left
// and the right subtree
if (root->left != NULL)
val = root->left->height + 1;
if (root->right != NULL)
val = max(
val, root->right->height + 1);
// Update the height of the
// current node
root->height = val;
}
}
// Function to handle Left Left Case
struct AVLwithparent* LLR(
struct AVLwithparent* root)
{
// Create a reference to the
// left child
struct AVLwithparent* tmpnode = root->left;
// Update the left child of the
// root to the right child of the
// current left child of the root
root->left = tmpnode->right;
// Update parent pointer of the left
// child of the root node
if (tmpnode->right != NULL)
tmpnode->right->par = root;
// Update the right child of
// tmpnode to root
tmpnode->right = root;
// Update parent pointer of tmpnode
tmpnode->par = root->par;
// Update the parent pointer of root
root->par = tmpnode;
// Update tmpnode as the left or
// the right child of its parent
// pointer according to its key value
if (tmpnode->par != NULL
&& root->key < tmpnode->par->key) {
tmpnode->par->left = tmpnode;
}
else {
if (tmpnode->par != NULL)
tmpnode->par->right = tmpnode;
}
// Make tmpnode as the new root
root = tmpnode;
// Update the heights
Updateheight(root->left);
Updateheight(root->right);
Updateheight(root);
Updateheight(root->par);
// Return the root node
return root;
}
// Function to handle Right Right Case
struct AVLwithparent* RRR(
struct AVLwithparent* root)
{
// Create a reference to the
// right child
struct AVLwithparent* tmpnode = root->right;
// Update the right child of the
// root as the left child of the
// current right child of the root
root->right = tmpnode->left;
// Update parent pointer of the right
// child of the root node
if (tmpnode->left != NULL)
tmpnode->left->par = root;
// Update the left child of the
// tmpnode to root
tmpnode->left = root;
// Update parent pointer of tmpnode
tmpnode->par = root->par;
// Update the parent pointer of root
root->par = tmpnode;
// Update tmpnode as the left or
// the right child of its parent
// pointer according to its key value
if (tmpnode->par != NULL
&& root->key < tmpnode->par->key) {
tmpnode->par->left = tmpnode;
}
else {
if (tmpnode->par != NULL)
tmpnode->par->right = tmpnode;
}
// Make tmpnode as the new root
root = tmpnode;
// Update the heights
Updateheight(root->left);
Updateheight(root->right);
Updateheight(root);
Updateheight(root->par);
// Return the root node
return root;
}
// Function to handle Left Right Case
struct AVLwithparent* LRR(
struct AVLwithparent* root)
{
root->left = RRR(root->left);
return LLR(root);
}
// Function to handle right left case
struct AVLwithparent* RLR(
struct AVLwithparent* root)
{
root->right = LLR(root->right);
return RRR(root);
}
// Function to insert a node in
// the AVL tree
struct AVLwithparent* Insert(
struct AVLwithparent* root,
struct AVLwithparent* parent,
int key)
{
if (root == NULL) {
// Create and assign values
// to a new node
root = new struct AVLwithparent;
if (root == NULL) {
cout << "Error in memory" << endl;
}
// Otherwise
else {
root->height = 1;
root->left = NULL;
root->right = NULL;
root->par = parent;
root->key = key;
}
}
else if (root->key > key) {
// Recur to the left subtree
// to insert the node
root->left = Insert(root->left,
root, key);
// Stores the heights of the
// left and right subtree
int firstheight = 0;
int secondheight = 0;
if (root->left != NULL)
firstheight = root->left->height;
if (root->right != NULL)
secondheight = root->right->height;
// Balance the tree if the
// current node is not balanced
if (abs(firstheight
- secondheight)
== 2) {
if (root->left != NULL
&& key < root->left->key) {
// Left Left Case
root = LLR(root);
}
else {
// Left Right Case
root = LRR(root);
}
}
}
else if (root->key < key) {
// Recur to the right subtree
// to insert the node
root->right = Insert(root->right, root, key);
// Store the heights of the left
// and right subtree
int firstheight = 0;
int secondheight = 0;
if (root->left != NULL)
firstheight = root->left->height;
if (root->right != NULL)
secondheight = root->right->height;
// Balance the tree if the
// current node is not balanced
if (abs(firstheight
- secondheight)
== 2) {
if (root->right != NULL
&& key < root->right->key) {
// Right Left Case
root = RLR(root);
}
else {
// Right Right Case
root = RRR(root);
}
}
}
// Case when given key is
// already in tree
else {
}
// Update the height of the
// root node
Updateheight(root);
// Return the root node
return root;
}
// Function to find a key in AVL tree
bool AVLsearch(
struct AVLwithparent* root, int key)
{
// If root is NULL
if (root == NULL)
return false;
// If found, return true
else if (root->key == key)
return true;
// Recur to the left subtree if
// the current node's value is
// greater than key
else if (root->key > key) {
bool val = AVLsearch(root->left, key);
return val;
}
// Otherwise, recur to the
// right subtree
else {
bool val = AVLsearch(root->right, key);
return val;
}
}
// Driver Code
int main()
{
struct AVLwithparent* root;
root = NULL;
// Function call to insert the nodes
root = Insert(root, NULL, 10);
root = Insert(root, NULL, 20);
root = Insert(root, NULL, 30);
root = Insert(root, NULL, 40);
root = Insert(root, NULL, 50);
root = Insert(root, NULL, 25);
// Function call to search for a node
bool found = AVLsearch(root, 40);
if (found)
cout << "value found";
else
cout << "value not found";
return 0;
}
class AVLwithparent {
AVLwithparent left, right, par;
int key;
int height;
// Constructor
public AVLwithparent(int key, AVLwithparent parent) {
this.key = key;
this.par = parent;
this.height = 1;
}
}
public class AVLTree {
// Function to update the height of a node according to its children's node's heights
public static void updateHeight(AVLwithparent root) {
if (root != null) {
int val = 1;
if (root.left != null)
val = root.left.height + 1;
if (root.right != null)
val = Math.max(val, root.right.height + 1);
root.height = val;
}
}
// Function to handle Left Left Case
public static AVLwithparent llr(AVLwithparent root) {
AVLwithparent tmpnode = root.left;
root.left = tmpnode.right;
if (tmpnode.right != null)
tmpnode.right.par = root;
tmpnode.right = root;
tmpnode.par = root.par;
if (tmpnode.par != null && root.key < tmpnode.par.key)
tmpnode.par.left = tmpnode;
else {
if (tmpnode.par != null)
tmpnode.par.right = tmpnode;
}
root = tmpnode;
updateHeight(root.left);
updateHeight(root.right);
updateHeight(root);
updateHeight(root.par);
return root;
}
// Function to handle Right Right Case
public static AVLwithparent rrr(AVLwithparent root) {
AVLwithparent tmpnode = root.right;
root.right = tmpnode.left;
if (tmpnode.left != null)
tmpnode.left.par = root;
tmpnode.left = root;
tmpnode.par = root.par;
if (tmpnode.par != null && root.key < tmpnode.par.key)
tmpnode.par.left = tmpnode;
else {
if (tmpnode.par != null)
tmpnode.par.right = tmpnode;
}
root = tmpnode;
updateHeight(root.left);
updateHeight(root.right);
updateHeight(root);
updateHeight(root.par);
return root;
}
// Function to handle Left Right Case
public static AVLwithparent lrr(AVLwithparent root) {
root.left = rrr(root.left);
return llr(root);
}
// Function to handle right left case
public static AVLwithparent rlr(AVLwithparent root) {
root.right = llr(root.right);
return rrr(root);
}
// Function to insert a node in the AVL tree
public static AVLwithparent insert(AVLwithparent root, AVLwithparent parent, int key) {
if (root == null) {
root = new AVLwithparent(key, parent);
} else if (root.key > key) {
root.left = insert(root.left, root, key);
int firstHeight = (root.left != null) ? root.left.height : 0;
int secondHeight = (root.right != null) ? root.right.height : 0;
if (Math.abs(firstHeight - secondHeight) == 2) {
if (root.left != null && key < root.left.key)
root = llr(root);
else
root = lrr(root);
}
} else if (root.key < key) {
root.right = insert(root.right, root, key);
int firstHeight = (root.left != null) ? root.left.height : 0;
int secondHeight = (root.right != null) ? root.right.height : 0;
if (Math.abs(firstHeight - secondHeight) == 2) {
if (root.right != null && key < root.right.key)
root = rlr(root);
else
root = rrr(root);
}
}
updateHeight(root);
return root;
}
// Function to find a key in AVL tree
public static boolean avlSearch(AVLwithparent root, int key) {
if (root == null)
return false;
else if (root.key == key)
return true;
else if (root.key > key)
return avlSearch(root.left, key);
else
return avlSearch(root.right, key);
}
// Driver Code
public static void main(String[] args) {
AVLwithparent root = null;
root = insert(root, null, 10);
root = insert(root, null, 20);
root = insert(root, null, 30);
root = insert(root, null, 40);
root = insert(root, null, 50);
root = insert(root, null, 25);
boolean found = avlSearch(root, 40);
if (found)
System.out.println("Value found");
else
System.out.println("Value not found");
}
}
# Python program for the above approach
# AVL tree node
class AVLwithparent:
def __init__(self, key, parent=None):
self.left = None
self.right = None
self.key = key
self.par = parent
self.height = 1
# Function to update the height of
# a node according to its children's
# node's heights
def update_height(root):
if root is not None:
# Store the height of the
# current node
val = 1
# Store the height of the left
# and the right subtree
if root.left is not None:
val = root.left.height + 1
if root.right is not None:
val = max(val, root.right.height + 1)
# Update the height of the
# current node
root.height = val
# Function to handle Left Left Case
def llr(root):
# Create a reference to the
# left child
tmp_node = root.left
# Update the left child of the
# root to the right child of the
# current left child of the root
root.left = tmp_node.right
# Update parent pointer of the left
# child of the root node
if tmp_node.right is not None:
tmp_node.right.par = root
# Update the right child of
# tmp_node to root
tmp_node.right = root
# Update parent pointer of tmp_node
tmp_node.par = root.par
# Update the parent pointer of root
root.par = tmp_node
# Update tmp_node as the left or
# the right child of its parent
# pointer according to its key value
if tmp_node.par is not None and root.key < tmp_node.par.key:
tmp_node.par.left = tmp_node
else:
if tmp_node.par is not None:
tmp_node.par.right = tmp_node
# Make tmp_node as the new root
root = tmp_node
# Update the heights
update_height(root.left)
update_height(root.right)
update_height(root)
update_height(root.par)
# Return the root node
return root
# Function to handle Right Right Case
def rrr(root):
# Create a reference to the
# right child
tmp_node = root.right
# Update the right child of the
# root as the left child of the
# current right child of the root
root.right = tmp_node.left
# Update parent pointer of the right
# child of the root node
if tmp_node.left is not None:
tmp_node.left.par = root
# Update the left child of the
# tmp_node to root
tmp_node.left = root
# Update parent pointer of tmp_node
tmp_node.par = root.par
# Update the parent pointer of root
root.par = tmp_node
# Update tmp_node as the left or
# the right child of its parent
# pointer according to its key value
if tmp_node.par is not None and root.key < tmp_node.par.key:
tmp_node.par.left = tmp_node
else:
if tmp_node.par is not None:
tmp_node.par.right = tmp_node
# Make tmp_node as the new root
root = tmp_node
# Update the heights
update_height(root.left)
update_height(root.right)
update_height(root)
update_height(root.par)
# Return the root node
return root
# Function to handle Left Right Case
def lrr(root):
root.left = rrr(root.left)
return llr(root)
# Function to handle Right Left Case
def rlr(root):
root.right = llr(root.right)
return rrr(root)
# Function to insert a node in
# the AVL tree
def insert(root, parent, key):
if root is None:
# Create and assign values
# to a new node
root = AVLwithparent(key, parent)
else:
if root.key > key:
# Recur to the left subtree
# to insert the node
root.left = insert(root.left, root, key)
# Stores the heights of the
# left and right subtree
first_height = 0
second_height = 0
if root.left is not None:
first_height = root.left.height
if root.right is not None:
second_height = root.right.height
# Balance the tree if the
# current node is not balanced
if abs(first_height - second_height) == 2:
if root.left is not None and key < root.left.key:
# Left Left Case
root = llr(root)
else:
# Left Right Case
root = lrr(root)
elif root.key < key:
# Recur to the right subtree
# to insert the node
root.right = insert(root.right, root, key)
# Store the heights of the left
# and right subtree
first_height = 0
second_height = 0
if root.left is not None:
first_height = root.left.height
if root.right is not None:
second_height = root.right.height
# Balance the tree if the
# current node is not balanced
if abs(first_height - second_height) == 2:
if root.right is not None and key < root.right.key:
# Right Left Case
root = rlr(root)
else:
# Right Right Case
root = rrr(root)
# Update the height of the
# root node
update_height(root)
# Return the root node
return root
# Function to find a key in AVL tree
def avl_search(root, key):
# If root is None
if root is None:
return False
# If found, return True
elif root.key == key:
return True
# Recur to the left subtree if
# the current node's value is
# greater than key
elif root.key > key:
return avl_search(root.left, key)
# Otherwise, recur to the
# right subtree
else:
return avl_search(root.right, key)
# Driver Code
if __name__ == "__main__":
root = None
# Function call to insert the nodes
root = insert(root, None, 10)
root = insert(root, None, 20)
root = insert(root, None, 30)
root = insert(root, None, 40)
root = insert(root, None, 50)
root = insert(root, None, 25)
# Function call to search for a node
found = avl_search(root, 40)
if found:
print("Value found")
else:
print("Value not found")
using System;
// AVL tree node
public class AVLwithparent
{
public AVLwithparent left;
public AVLwithparent right;
public int key;
public AVLwithparent par;
public int height;
}
public class AVLTree
{
// Function to update the height of a node according to its children's node's heights
public static void UpdateHeight(AVLwithparent root)
{
if (root != null)
{
int val = 1;
if (root.left != null)
val = root.left.height + 1;
if (root.right != null)
val = Math.Max(val, root.right.height + 1);
root.height = val;
}
}
// Function to handle Left Left Case
public static AVLwithparent LLR(AVLwithparent root)
{
AVLwithparent tmpnode = root.left;
root.left = tmpnode.right;
if (tmpnode.right != null)
tmpnode.right.par = root;
tmpnode.right = root;
tmpnode.par = root.par;
if (tmpnode.par != null && root.key < tmpnode.par.key)
tmpnode.par.left = tmpnode;
else
{
if (tmpnode.par != null)
tmpnode.par.right = tmpnode;
}
root = tmpnode;
UpdateHeight(root.left);
UpdateHeight(root.right);
UpdateHeight(root);
UpdateHeight(root.par);
return root;
}
// Function to handle Right Right Case
public static AVLwithparent RRR(AVLwithparent root)
{
AVLwithparent tmpnode = root.right;
root.right = tmpnode.left;
if (tmpnode.left != null)
tmpnode.left.par = root;
tmpnode.left = root;
tmpnode.par = root.par;
if (tmpnode.par != null && root.key < tmpnode.par.key)
tmpnode.par.left = tmpnode;
else
{
if (tmpnode.par != null)
tmpnode.par.right = tmpnode;
}
root = tmpnode;
UpdateHeight(root.left);
UpdateHeight(root.right);
UpdateHeight(root);
UpdateHeight(root.par);
return root;
}
// Function to handle Left Right Case
public static AVLwithparent LRR(AVLwithparent root)
{
root.left = RRR(root.left);
return LLR(root);
}
// Function to handle right left case
public static AVLwithparent RLR(AVLwithparent root)
{
root.right = LLR(root.right);
return RRR(root);
}
// Function to insert a node in the AVL tree
public static AVLwithparent Insert(AVLwithparent root, AVLwithparent parent, int key)
{
if (root == null)
{
root = new AVLwithparent();
root.height = 1;
root.left = null;
root.right = null;
root.par = parent;
root.key = key;
}
else if (root.key > key)
{
root.left = Insert(root.left, root, key);
int firstHeight = 0;
int secondHeight = 0;
if (root.left != null)
firstHeight = root.left.height;
if (root.right != null)
secondHeight = root.right.height;
if (Math.Abs(firstHeight - secondHeight) == 2)
{
if (root.left != null && key < root.left.key)
root = LLR(root);
else
root = LRR(root);
}
}
else if (root.key < key)
{
root.right = Insert(root.right, root, key);
int firstHeight = 0;
int secondHeight = 0;
if (root.left != null)
firstHeight = root.left.height;
if (root.right != null)
secondHeight = root.right.height;
if (Math.Abs(firstHeight - secondHeight) == 2)
{
if (root.right != null && key < root.right.key)
root = RLR(root);
else
root = RRR(root);
}
}
UpdateHeight(root);
return root;
}
// Function to find a key in AVL tree
public static bool AVLSearch(AVLwithparent root, int key)
{
if (root == null)
return false;
else if (root.key == key)
return true;
else if (root.key > key)
return AVLSearch(root.left, key);
else
return AVLSearch(root.right, key);
}
// Driver Code
public static void Main(string[] args)
{
AVLwithparent root = null;
root = Insert(root, null, 10);
root = Insert(root, null, 20);
root = Insert(root, null, 30);
root = Insert(root, null, 40);
root = Insert(root, null, 50);
root = Insert(root, null, 25);
bool found = AVLSearch(root, 40);
if (found)
Console.WriteLine("Value found");
else
Console.WriteLine("Value not found");
}
}
class AVLwithparent {
constructor(key, parent = null) {
this.left = null;
this.right = null;
this.key = key;
this.par = parent; // 'par' keeps track of the parent node
this.height = 1; // Height of the node initialized to 1
}
}
// Function to update the height of a node
function updateHeight(root) {
if (root !== null) {
let val = 1;
if (root.left !== null) {
val = root.left.height + 1; // Update height considering the left subtree
}
if (root.right !== null) {
val = Math.max(val, root.right.height + 1); // Update height considering the right subtree
}
root.height = val; // Update the height of the current node
}
}
// Left-Left Rotation (LLR)
function llr(root) {
let tmpNode = root.left;
root.left = tmpNode.right;
if (tmpNode.right !== null) {
tmpNode.right.par = root;
}
tmpNode.right = root;
tmpNode.par = root.par;
root.par = tmpNode;
if (tmpNode.par !== null && root.key < tmpNode.par.key) {
tmpNode.par.left = tmpNode;
} else {
if (tmpNode.par !== null) {
tmpNode.par.right = tmpNode;
}
}
root = tmpNode;
// Update heights after rotation
updateHeight(root.left);
updateHeight(root.right);
updateHeight(root);
updateHeight(root.par);
return root;
}
// Right-Right Rotation (RRR)
function rrr(root) {
let tmpNode = root.right;
root.right = tmpNode.left;
if (tmpNode.left !== null) {
tmpNode.left.par = root;
}
tmpNode.left = root;
tmpNode.par = root.par;
root.par = tmpNode;
if (tmpNode.par !== null && root.key < tmpNode.par.key) {
tmpNode.par.left = tmpNode;
} else {
if (tmpNode.par !== null) {
tmpNode.par.right = tmpNode;
}
}
root = tmpNode;
// Update heights after rotation
updateHeight(root.left);
updateHeight(root.right);
updateHeight(root);
updateHeight(root.par);
return root;
}
// Left-Right Rotation (LRR)
function lrr(root) {
root.left = rrr(root.left);
return llr(root);
}
// Right-Left Rotation (RLR)
function rlr(root) {
root.right = llr(root.right);
return rrr(root);
}
// Function to insert a node into the AVL tree
function insert(root, parent, key) {
if (root === null) {
root = new AVLwithparent(key, parent);
} else {
if (root.key > key) {
root.left = insert(root.left, root, key);
// Perform rotations if necessary after insertion
let firstHeight = root.left ? root.left.height : 0;
let secondHeight = root.right ? root.right.height : 0;
if (Math.abs(firstHeight - secondHeight) === 2) {
if (root.left !== null && key < root.left.key) {
root = llr(root);
} else {
root = lrr(root);
}
}
} else if (root.key < key) {
root.right = insert(root.right, root, key);
// Perform rotations if necessary after insertion
let firstHeight = root.left ? root.left.height : 0;
let secondHeight = root.right ? root.right.height : 0;
if (Math.abs(firstHeight - secondHeight) === 2) {
if (root.right !== null && key < root.right.key) {
root = rlr(root);
} else {
root = rrr(root);
}
}
}
}
updateHeight(root); // Update the height of the current node
return root;
}
// Function to search for a node in the AVL tree
function avlSearch(root, key) {
if (root === null) {
return false;
} else if (root.key === key) {
return true;
} else if (root.key > key) {
return avlSearch(root.left, key);
} else {
return avlSearch(root.right, key);
}
}
// Driver Code
let root = null;
// Inserting nodes into the AVL tree
root = insert(root, null, 10);
root = insert(root, null, 20);
root = insert(root, null, 30);
root = insert(root, null, 40);
root = insert(root, null, 50);
root = insert(root, null, 25);
// Searching for a value in the AVL tree
let found = avlSearch(root, 40);
if (found) {
console.log("Value found");
} else {
console.log("Value not found");
}
Time Complexity: O(log N), where N is the number of nodes of the tree
Auxiliary Space: O(1)
Delete Operation: The deletion procedure is similar to that of a normal AVL tree without a parent pointer, but in this case, the references to the parent pointers need to be updated with every deletion and rotation accordingly. Follow the steps below to perform the delete operation:
- Perform the delete procedure as in a normal BST.
- From the node that has been deleted, move towards the root.
- At each node on the path, update the height of the node.
- Check for AVL conditions at each node. Let there be 3 nodes: w, x, y where w is the current node, x is the root of the subtree of w which has greater height and y is the root of the subtree of x which has greater height.
- If the node w is unbalanced, there exists one of the following 4 cases:
- Left Left Case (x is left child of w and y is left child of x)
- Left Right Case (x is left child of w and y is right child of x)
- Right Left Case (x is right child of w and y is left child of x)
- Right Right Case (x is right child of w and y is right child of x)
Below is the implementation of the above approach:
C++
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// AVL tree node
struct AVLwithparent {
struct AVLwithparent* left;
struct AVLwithparent* right;
int key;
struct AVLwithparent* par;
int height;
};
// Function to print the preorder
// traversal of the AVL tree
void printpreorder(struct AVLwithparent* root)
{
// Print the node's value along
// with its parent value
cout << "Node: " << root->key
<< ", Parent Node: ";
if (root->par != NULL)
cout << root->par->key << endl;
else
cout << "NULL" << endl;
// Recur to the left subtree
if (root->left != NULL) {
printpreorder(root->left);
}
// Recur to the right subtree
if (root->right != NULL) {
printpreorder(root->right);
}
}
// Function to update the height of
// a node according to its children's
// node's heights
void Updateheight(
struct AVLwithparent* root)
{
if (root != NULL) {
// Store the height of the
// current node
int val = 1;
// Store the height of the left
// and right subtree
if (root->left != NULL)
val = root->left->height + 1;
if (root->right != NULL)
val = max(
val, root->right->height + 1);
// Update the height of the
// current node
root->height = val;
}
}
// Function to handle Left Left Case
struct AVLwithparent* LLR(
struct AVLwithparent* root)
{
// Create a reference to the
// left child
struct AVLwithparent* tmpnode = root->left;
// Update the left child of the
// root to the right child of the
// current left child of the root
root->left = tmpnode->right;
// Update parent pointer of left
// child of the root node
if (tmpnode->right != NULL)
tmpnode->right->par = root;
// Update the right child of
// tmpnode to root
tmpnode->right = root;
// Update parent pointer of tmpnode
tmpnode->par = root->par;
// Update the parent pointer of root
root->par = tmpnode;
// Update tmpnode as the left or
// the right child of its parent
// pointer according to its key value
if (tmpnode->par != NULL
&& root->key < tmpnode->par->key) {
tmpnode->par->left = tmpnode;
}
else {
if (tmpnode->par != NULL)
tmpnode->par->right = tmpnode;
}
// Make tmpnode as the new root
root = tmpnode;
// Update the heights
Updateheight(root->left);
Updateheight(root->right);
Updateheight(root);
Updateheight(root->par);
// Return the root node
return root;
}
// Function to handle Right Right Case
struct AVLwithparent* RRR(
struct AVLwithparent* root)
{
// Create a reference to the
// right child
struct AVLwithparent* tmpnode = root->right;
// Update the right child of the
// root as the left child of the
// current right child of the root
root->right = tmpnode->left;
// Update parent pointer of the
// right child of the root node
if (tmpnode->left != NULL)
tmpnode->left->par = root;
// Update the left child of the
// tmpnode to root
tmpnode->left = root;
// Update parent pointer of tmpnode
tmpnode->par = root->par;
// Update the parent pointer of root
root->par = tmpnode;
// Update tmpnode as the left or
// the right child of its parent
// pointer according to its key value
if (tmpnode->par != NULL
&& root->key < tmpnode->par->key) {
tmpnode->par->left = tmpnode;
}
else {
if (tmpnode->par != NULL)
tmpnode->par->right = tmpnode;
}
// Make tmpnode as the new root
root = tmpnode;
// Update the heights
Updateheight(root->left);
Updateheight(root->right);
Updateheight(root);
Updateheight(root->par);
// Return the root node
return root;
}
// Function to handle Left Right Case
struct AVLwithparent* LRR(
struct AVLwithparent* root)
{
root->left = RRR(root->left);
return LLR(root);
}
// Function to handle right left case
struct AVLwithparent* RLR(
struct AVLwithparent* root)
{
root->right = LLR(root->right);
return RRR(root);
}
// Function to balance the tree after
// deletion of a node
struct AVLwithparent* Balance(
struct AVLwithparent* root)
{
// Store the current height of
// the left and right subtree
int firstheight = 0;
int secondheight = 0;
if (root->left != NULL)
firstheight = root->left->height;
if (root->right != NULL)
secondheight = root->right->height;
// If current node is not balanced
if (abs(firstheight - secondheight) == 2) {
if (firstheight < secondheight) {
// Store the height of the
// left and right subtree
// of the current node's
// right subtree
int rightheight1 = 0;
int rightheight2 = 0;
if (root->right->right != NULL)
rightheight2 = root->right->right->height;
if (root->right->left != NULL)
rightheight1 = root->right->left->height;
if (rightheight1 > rightheight2) {
// Right Left Case
root = RLR(root);
}
else {
// Right Right Case
root = RRR(root);
}
}
else {
// Store the height of the
// left and right subtree
// of the current node's
// left subtree
int leftheight1 = 0;
int leftheight2 = 0;
if (root->left->right != NULL)
leftheight2 = root->left->right->height;
if (root->left->left != NULL)
leftheight1 = root->left->left->height;
if (leftheight1 > leftheight2) {
// Left Left Case
root = LLR(root);
}
else {
// Left Right Case
root = LRR(root);
}
}
}
// Return the root node
return root;
}
// Function to insert a node in
// the AVL tree
struct AVLwithparent* Insert(
struct AVLwithparent* root,
struct AVLwithparent* parent,
int key)
{
if (root == NULL) {
// Create and assign values
// to a new node
root = new struct AVLwithparent;
if (root == NULL)
cout << "Error in memory" << endl;
else {
root->height = 1;
root->left = NULL;
root->right = NULL;
root->par = parent;
root->key = key;
}
}
else if (root->key > key) {
// Recur to the left subtree
// to insert the node
root->left = Insert(root->left,
root, key);
// Store the heights of the
// left and right subtree
int firstheight = 0;
int secondheight = 0;
if (root->left != NULL)
firstheight = root->left->height;
if (root->right != NULL)
secondheight = root->right->height;
// Balance the tree if the
// current node is not balanced
if (abs(firstheight
- secondheight)
== 2) {
if (root->left != NULL
&& key < root->left->key) {
// Left Left Case
root = LLR(root);
}
else {
// Left Right Case
root = LRR(root);
}
}
}
else if (root->key < key) {
// Recur to the right subtree
// to insert the node
root->right = Insert(root->right,
root, key);
// Store the heights of the left
// and right subtree
int firstheight = 0;
int secondheight = 0;
if (root->left != NULL)
firstheight = root->left->height;
if (root->right != NULL)
secondheight = root->right->height;
// Balance the tree if the
// current node is not balanced
if (abs(firstheight - secondheight) == 2) {
if (root->right != NULL
&& key < root->right->key) {
// Right Left Case
root = RLR(root);
}
else {
// Right Right Case
root = RRR(root);
}
}
}
// Case when given key is
// already in tree
else {
}
// Update the height of the
// root node
Updateheight(root);
// Return the root node
return root;
}
// Function to delete a node from
// the AVL tree
struct AVLwithparent* Delete(
struct AVLwithparent* root,
int key)
{
if (root != NULL) {
// If the node is found
if (root->key == key) {
// Replace root with its
// left child
if (root->right == NULL
&& root->left != NULL) {
if (root->par != NULL) {
if (root->par->key
< root->key)
root->par->right = root->left;
else
root->par->left = root->left;
// Update the height
// of root's parent
Updateheight(root->par);
}
root->left->par = root->par;
// Balance the node
// after deletion
root->left = Balance(
root->left);
return root->left;
}
// Replace root with its
// right child
else if (root->left == NULL
&& root->right != NULL) {
if (root->par != NULL) {
if (root->par->key
< root->key)
root->par->right = root->right;
else
root->par->left = root->right;
// Update the height
// of the root's parent
Updateheight(root->par);
}
root->right->par = root->par;
// Balance the node after
// deletion
root->right = Balance(root->right);
return root->right;
}
// Remove the references of
// the current node
else if (root->left == NULL
&& root->right == NULL) {
if (root->par->key < root->key) {
root->par->right = NULL;
}
else {
root->par->left = NULL;
}
if (root->par != NULL)
Updateheight(root->par);
root = NULL;
return NULL;
}
// Otherwise, replace the
// current node with its
// successor and then
// recursively call Delete()
else {
struct AVLwithparent* tmpnode = root;
tmpnode = tmpnode->right;
while (tmpnode->left != NULL) {
tmpnode = tmpnode->left;
}
int val = tmpnode->key;
root->right
= Delete(root->right, tmpnode->key);
root->key = val;
// Balance the node
// after deletion
root = Balance(root);
}
}
// Recur to the right subtree to
// delete the current node
else if (root->key < key) {
root->right = Delete(root->right, key);
root = Balance(root);
}
// Recur into the right subtree
// to delete the current node
else if (root->key > key) {
root->left = Delete(root->left, key);
root = Balance(root);
}
// Update height of the root
if (root != NULL) {
Updateheight(root);
}
}
// Handle the case when the key to be
// deleted could not be found
else {
cout << "Key to be deleted "
<< "could not be found\n";
}
// Return the root node
return root;
}
// Driver Code
int main()
{
struct AVLwithparent* root;
root = NULL;
// Function call to insert the nodes
root = Insert(root, NULL, 9);
root = Insert(root, NULL, 5);
root = Insert(root, NULL, 10);
root = Insert(root, NULL, 0);
root = Insert(root, NULL, 6);
// Print the tree before deleting node
cout << "Before deletion:\n";
printpreorder(root);
// Function Call to delete node 10
root = Delete(root, 10);
// Print the tree after deleting node
cout << "After deletion:\n";
printpreorder(root);
}
// Java program for the above approach
class AVLwithparent {
AVLwithparent left, right, par;
int key, height;
AVLwithparent(int item) {
key = item;
height = 1;
}
}
public class AVLTreeWithParent {
// Function to print the preorder
// traversal of the AVL tree
static void printPreorder(AVLwithparent root) {
if (root != null) {
// Print the node's value along
// with its parent value
System.out.print("Node: " + root.key + ", Parent Node: ");
if (root.par != null)
System.out.println(root.par.key);
else
System.out.println("NULL");
// Recur to the left subtree
printPreorder(root.left);
// Recur to the right subtree
printPreorder(root.right);
}
}
// Function to update the height of
// a node according to its children's
// node's heights
static void updateHeight(AVLwithparent root) {
if (root != null) {
// Store the height of the
// current node
int val = 1;
// Store the height of the left
// and right subtree
if (root.left != null)
val = root.left.height + 1;
if (root.right != null)
val = Math.max(val, root.right.height + 1);
// Update the height of the
// current node
root.height = val;
}
}
// Function to handle Left Left Case
static AVLwithparent LLR(AVLwithparent root) {
// Create a reference to the
// left child
AVLwithparent tmpnode = root.left;
// Update the left child of the
// root to the right child of the
// current left child of the root
root.left = tmpnode.right;
// Update parent pointer of left
// child of the root node
if (tmpnode.right != null)
tmpnode.right.par = root;
// Update the right child of
// tmpnode to root
tmpnode.right = root;
// Update parent pointer of tmpnode
tmpnode.par = root.par;
// Update the parent pointer of root
if (tmpnode.par != null && root.key < tmpnode.par.key)
tmpnode.par.left = tmpnode;
else {
if (tmpnode.par != null)
tmpnode.par.right = tmpnode;
}
// Make tmpnode as the new root
root = tmpnode;
// Update the heights
updateHeight(root.left);
updateHeight(root.right);
updateHeight(root);
updateHeight(root.par);
// Return the root node
return root;
}
// Function to handle Right Right Case
static AVLwithparent RRR(AVLwithparent root) {
// Create a reference to the
// right child
AVLwithparent tmpnode = root.right;
// Update the right child of the
// root as the left child of the
// current right child of the root
root.right = tmpnode.left;
// Update parent pointer of the
// right child of the root node
if (tmpnode.left != null)
tmpnode.left.par = root;
// Update the left child of the
// tmpnode to root
tmpnode.left = root;
// Update parent pointer of tmpnode
tmpnode.par = root.par;
// Update the parent pointer of root
if (tmpnode.par != null && root.key < tmpnode.par.key)
tmpnode.par.left = tmpnode;
else {
if (tmpnode.par != null)
tmpnode.par.right = tmpnode;
}
// Make tmpnode as the new root
root = tmpnode;
// Update the heights
updateHeight(root.left);
updateHeight(root.right);
updateHeight(root);
updateHeight(root.par);
// Return the root node
return root;
}
// Function to handle Left Right Case
static AVLwithparent LRR(AVLwithparent root) {
root.left = RRR(root.left);
return LLR(root);
}
// Function to handle right left case
static AVLwithparent RLR(AVLwithparent root) {
root.right = LLR(root.right);
return RRR(root);
}
// Function to balance the tree after
// deletion of a node
static AVLwithparent balance(AVLwithparent root) {
// Store the current height of
// the left and right subtree
int firstheight = 0;
int secondheight = 0;
if (root.left != null)
firstheight = root.left.height;
if (root.right != null)
secondheight = root.right.height;
// If current node is not balanced
if (Math.abs(firstheight - secondheight) == 2) {
if (firstheight < secondheight) {
// Store the height of the
// left and right subtree
// of the current node's
// right subtree
int rightheight1 = 0;
int rightheight2 = 0;
if (root.right.right != null)
rightheight2 = root.right.right.height;
if (root.right.left != null)
rightheight1 = root.right.left.height;
if (rightheight1 > rightheight2) {
// Right Left Case
root = RLR(root);
} else {
// Right Right Case
root = RRR(root);
}
} else {
// Store the height of the
// left and right subtree
// of the current node's
// left subtree
int leftheight1 = 0;
int leftheight2 = 0;
if (root.left.right != null)
leftheight2 = root.left.right.height;
if (root.left.left != null)
leftheight1 = root.left.left.height;
if (leftheight1 > leftheight2) {
// Left Left Case
root = LLR(root);
} else {
// Left Right Case
root = LRR(root);
}
}
}
// Return the root node
return root;
}
// Function to insert a node in
// the AVL tree
static AVLwithparent insert(AVLwithparent root, AVLwithparent parent, int key) {
if (root == null) {
// Create and assign values
// to a new node
root = new AVLwithparent(key);
if (root == null)
System.out.println("Error in memory");
else {
root.height = 1;
root.left = null;
root.right = null;
root.par = parent;
}
} else if (root.key > key) {
// Recur to the left subtree
// to insert the node
root.left = insert(root.left, root, key);
// Store the heights of the
// left and right subtree
int firstheight = 0;
int secondheight = 0;
if (root.left != null)
firstheight = root.left.height;
if (root.right != null)
secondheight = root.right.height;
// Balance the tree if the
// current node is not balanced
if (Math.abs(firstheight - secondheight) == 2) {
if (root.left != null && key < root.left.key) {
// Left Left Case
root = LLR(root);
} else {
// Left Right Case
root = LRR(root);
}
}
} else if (root.key < key) {
// Recur to the right subtree
// to insert the node
root.right = insert(root.right, root, key);
// Store the heights of the left
// and right subtree
int firstheight = 0;
int secondheight = 0;
if (root.left != null)
firstheight = root.left.height;
if (root.right != null)
secondheight = root.right.height;
// Balance the tree if the
// current node is not balanced
if (Math.abs(firstheight - secondheight) == 2) {
if (root.right != null && key < root.right.key) {
// Right Left Case
root = RLR(root);
} else {
// Right Right Case
root = RRR(root);
}
}
}
// Case when given key is
// already in tree
// Do nothing
// Update the height of the
// root node
updateHeight(root);
// Return the root node
return root;
}
// Function to delete a node from
// the AVL tree
static AVLwithparent delete(AVLwithparent root, int key) {
if (root != null) {
// If the node is found
if (root.key == key) {
// Replace root with its
// left child
if (root.right == null && root.left != null) {
if (root.par != null) {
if (root.par.key < root.key)
root.par.right = root.left;
else
root.par.left = root.left;
// Update the height
// of root's parent
updateHeight(root.par);
}
root.left.par = root.par;
// Balance the node
// after deletion
root.left = balance(root.left);
return root.left;
}
// Replace root with its
// right child
else if (root.left == null && root.right != null) {
if (root.par != null) {
if (root.par.key < root.key)
root.par.right = root.right;
else
root.par.left = root.right;
// Update the height
// of the root's parent
updateHeight(root.par);
}
root.right.par = root.par;
// Balance the node after
// deletion
root.right = balance(root.right);
return root.right;
}
// Remove the references of
// the current node
else if (root.left == null && root.right == null) {
if (root.par.key < root.key) {
root.par.right = null;
} else {
root.par.left = null;
}
if (root.par != null)
updateHeight(root.par);
root = null;
return null;
}
// Otherwise, replace the
// current node with its
// successor and then
// recursively call delete()
else {
AVLwithparent tmpnode = root;
tmpnode = tmpnode.right;
while (tmpnode.left != null) {
tmpnode = tmpnode.left;
}
int val = tmpnode.key;
root.right = delete(root.right, tmpnode.key);
root.key = val;
// Balance the node
// after deletion
root = balance(root);
}
}
// Recur to the right subtree to
// delete the current node
else if (root.key < key) {
root.right = delete(root.right, key);
root = balance(root);
}
// Recur into the right subtree
// to delete the current node
else if (root.key > key) {
root.left = delete(root.left, key);
root = balance(root);
}
// Update height of the root
if (root != null) {
updateHeight(root);
}
}
// Handle the case when the key to be
// deleted could not be found
else {
System.out.println("Key to be deleted could not be found");
}
// Return the root node
return root;
}
// Driver Code
public static void main(String[] args) {
AVLwithparent root = null;
// Function call to insert the nodes
root = insert(root, null, 9);
root = insert(root, null, 5);
root = insert(root, null, 10);
root = insert(root, null, 0);
root = insert(root, null, 6);
// Print the tree before deleting node
System.out.println("Before deletion:");
printPreorder(root);
// Function Call to delete node 10
root = delete(root, 10);
// Print the tree after deleting node
System.out.println("After deletion:");
printPreorder(root);
}
}
class AVLwithparent:
def __init__(self, key, parent=None):
self.left = None
self.right = None
self.key = key
self.par = parent
self.height = 1
def print_preorder(root):
if root:
print("Node:", root.key, ", Parent Node:", root.par.key if root.par else "NULL")
print_preorder(root.left)
print_preorder(root.right)
def update_height(root):
if root:
val = 1
if root.left:
val = root.left.height + 1
if root.right:
val = max(val, root.right.height + 1)
root.height = val
def llr(root):
tmp_node = root.left
root.left = tmp_node.right
if tmp_node.right:
tmp_node.right.par = root
tmp_node.right = root
tmp_node.par = root.par
root.par = tmp_node
if tmp_node.par and root.key < tmp_node.par.key:
tmp_node.par.left = tmp_node
elif tmp_node.par:
tmp_node.par.right = tmp_node
root = tmp_node
update_height(root.left)
update_height(root.right)
update_height(root)
update_height(root.par)
return root
def rrr(root):
tmp_node = root.right
root.right = tmp_node.left
if tmp_node.left:
tmp_node.left.par = root
tmp_node.left = root
tmp_node.par = root.par
root.par = tmp_node
if tmp_node.par and root.key < tmp_node.par.key:
tmp_node.par.left = tmp_node
elif tmp_node.par:
tmp_node.par.right = tmp_node
root = tmp_node
update_height(root.left)
update_height(root.right)
update_height(root)
update_height(root.par)
return root
def lrr(root):
root.left = rrr(root.left)
return llr(root)
def rlr(root):
root.right = llr(root.right)
return rrr(root)
def balance(root):
first_height = 0
second_height = 0
if root.left:
first_height = root.left.height
if root.right:
second_height = root.right.height
if abs(first_height - second_height) == 2:
if first_height < second_height:
rightheight1 = 0
rightheight2 = 0
if root.right.right:
rightheight2 = root.right.right.height
if root.right.left:
rightheight1 = root.right.left.height
if rightheight1 > rightheight2:
root = rlr(root)
else:
root = rrr(root)
else:
leftheight1 = 0
leftheight2 = 0
if root.left.right:
leftheight2 = root.left.right.height
if root.left.left:
leftheight1 = root.left.left.height
if leftheight1 > leftheight2:
root = llr(root)
else:
root = lrr(root)
return root
def insert(root, parent, key):
if root is None:
root = AVLwithparent(key, parent)
elif root.key > key:
root.left = insert(root.left, root, key)
first_height = 0
second_height = 0
if root.left:
first_height = root.left.height
if root.right:
second_height = root.right.height
if abs(first_height - second_height) == 2:
if root.left and key < root.left.key:
root = llr(root)
else:
root = lrr(root)
elif root.key < key:
root.right = insert(root.right, root, key)
first_height = 0
second_height = 0
if root.left:
first_height = root.left.height
if root.right:
second_height = root.right.height
if abs(first_height - second_height) == 2:
if root.right and key < root.right.key:
root = rlr(root)
else:
root = rrr(root)
update_height(root)
return root
def delete(root, key):
if root:
if root.key == key:
if root.right is None and root.left is not None:
if root.par:
if root.par.key < root.key:
root.par.right = root.left
else:
root.par.left = root.left
update_height(root.par)
root.left.par = root.par
root.left = balance(root.left)
return root.left
elif root.left is None and root.right is not None:
if root.par:
if root.par.key < root.key:
root.par.right = root.right
else:
root.par.left = root.right
update_height(root.par)
root.right.par = root.par
root.right = balance(root.right)
return root.right
elif root.left is None and root.right is None:
if root.par:
if root.par.key < root.key:
root.par.right = None
else:
root.par.left = None
update_height(root.par)
root = None
return None
else:
tmp_node = root
tmp_node = tmp_node.right
while tmp_node.left:
tmp_node = tmp_node.left
val = tmp_node.key
root.right = delete(root.right, tmp_node.key)
root.key = val
root = balance(root)
elif root.key < key:
root.right = delete(root.right, key)
root = balance(root)
elif root.key > key:
root.left = delete(root.left, key)
root = balance(root)
update_height(root)
return root
# Driver Code
if __name__ == "__main__":
root = None
# Function call to insert the nodes
root = insert(root, None, 9)
root = insert(root, None, 5)
root = insert(root, None, 10)
root = insert(root, None, 0)
root = insert(root, None, 6)
# Print the tree before deleting node
print("Before deletion:")
print_preorder(root)
# Function Call to delete node 10
root = delete(root, 10)
# Print the tree after deleting node
print("After deletion:")
print_preorder(root)
using System;
// AVL tree node
public class AVLwithparent
{
public AVLwithparent left;
public AVLwithparent right;
public AVLwithparent par;
public int key;
public int height;
public AVLwithparent(int key)
{
this.key = key;
this.height = 1;
}
}
public class AVLTreeWithParent
{
// Function to print the preorder traversal of the AVL tree
public static void PrintPreorder(AVLwithparent root)
{
if (root != null)
{
// Print the node's value along with its parent value
Console.Write("Node: " + root.key + ", Parent Node: ");
if (root.par != null)
Console.WriteLine(root.par.key);
else
Console.WriteLine("NULL");
// Recur to the left subtree
PrintPreorder(root.left);
// Recur to the right subtree
PrintPreorder(root.right);
}
}
// Function to update the height of a node according to its children's node's heights
public static void UpdateHeight(AVLwithparent root)
{
if (root != null)
{
// Store the height of the current node
int val = 1;
// Store the height of the left and right subtree
if (root.left != null)
val = root.left.height + 1;
if (root.right != null)
val = Math.Max(val, root.right.height + 1);
// Update the height of the current node
root.height = val;
}
}
// Function to handle Left Left Case
public static AVLwithparent LLR(AVLwithparent root)
{
AVLwithparent tmpnode = root.left;
root.left = tmpnode.right;
if (tmpnode.right != null)
tmpnode.right.par = root;
tmpnode.right = root;
tmpnode.par = root.par;
if (tmpnode.par != null && root.key < tmpnode.par.key)
tmpnode.par.left = tmpnode;
else
{
if (tmpnode.par != null)
tmpnode.par.right = tmpnode;
}
root.par = tmpnode;
root = tmpnode;
UpdateHeight(root.left);
UpdateHeight(root.right);
UpdateHeight(root);
UpdateHeight(root.par);
return root;
}
// Function to handle Right Right Case
public static AVLwithparent RRR(AVLwithparent root)
{
AVLwithparent tmpnode = root.right;
root.right = tmpnode.left;
if (tmpnode.left != null)
tmpnode.left.par = root;
tmpnode.left = root;
tmpnode.par = root.par;
if (tmpnode.par != null && root.key < tmpnode.par.key)
tmpnode.par.left = tmpnode;
else
{
if (tmpnode.par != null)
tmpnode.par.right = tmpnode;
}
root.par = tmpnode;
root = tmpnode;
UpdateHeight(root.left);
UpdateHeight(root.right);
UpdateHeight(root);
UpdateHeight(root.par);
return root;
}
// Function to handle Left Right Case
public static AVLwithparent LRR(AVLwithparent root)
{
root.left = RRR(root.left);
return LLR(root);
}
// Function to handle right left case
public static AVLwithparent RLR(AVLwithparent root)
{
root.right = LLR(root.right);
return RRR(root);
}
// Function to balance the tree after deletion of a node
public static AVLwithparent Balance(AVLwithparent root)
{
int firstheight = 0;
int secondheight = 0;
if (root.left != null)
firstheight = root.left.height;
if (root.right != null)
secondheight = root.right.height;
if (Math.Abs(firstheight - secondheight) == 2)
{
if (firstheight < secondheight)
{
int rightheight1 = 0;
int rightheight2 = 0;
if (root.right.right != null)
rightheight2 = root.right.right.height;
if (root.right.left != null)
rightheight1 = root.right.left.height;
if (rightheight1 > rightheight2)
root = RLR(root);
else
root = RRR(root);
}
else
{
int leftheight1 = 0;
int leftheight2 = 0;
if (root.left.right != null)
leftheight2 = root.left.right.height;
if (root.left.left != null)
leftheight1 = root.left.left.height;
if (leftheight1 > leftheight2)
root = LLR(root);
else
root = LRR(root);
}
}
return root;
}
// Function to insert a node in the AVL tree
public static AVLwithparent Insert(AVLwithparent root, AVLwithparent parent, int key)
{
if (root == null)
{
root = new AVLwithparent(key);
root.par = parent;
}
else if (root.key > key)
{
root.left = Insert(root.left, root, key);
if (Math.Abs((root.left != null ? root.left.height : 0) - (root.right != null ? root.right.height : 0)) == 2)
{
if (root.left != null && key < root.left.key)
root = LLR(root);
else
root = LRR(root);
}
}
else if (root.key < key)
{
root.right = Insert(root.right, root, key);
if (Math.Abs((root.left != null ? root.left.height : 0) - (root.right != null ? root.right.height : 0)) == 2)
{
if (root.right != null && key < root.right.key)
root = RLR(root);
else
root = RRR(root);
}
}
UpdateHeight(root);
return root;
}
// Function to delete a node from the AVL tree
public static AVLwithparent Delete(AVLwithparent root, int key)
{
if (root != null)
{
if (root.key == key)
{
if (root.right == null && root.left != null)
{
if (root.par != null)
{
if (root.par.key < root.key)
root.par.right = root.left;
else
root.par.left = root.left;
UpdateHeight(root.par);
}
root.left.par = root.par;
root.left = Balance(root.left);
return root.left;
}
else if (root.left == null && root.right != null)
{
if (root.par != null)
{
if (root.par.key < root.key)
root.par.right = root.right;
else
root.par.left = root.right;
UpdateHeight(root.par);
}
root.right.par = root.par;
root.right = Balance(root.right);
return root.right;
}
else if (root.left == null && root.right == null)
{
if (root.par != null)
{
if (root.par.key < root.key)
root.par.right = null;
else
root.par.left = null;
UpdateHeight(root.par);
}
root = null;
return null;
}
else
{
AVLwithparent tmpnode = root.right;
while (tmpnode.left != null)
tmpnode = tmpnode.left;
int val = tmpnode.key;
root.right = Delete(root.right, tmpnode.key);
root.key = val;
root = Balance(root);
}
}
else if (root.key < key)
{
root.right = Delete(root.right, key);
root = Balance(root);
}
else if (root.key > key)
{
root.left = Delete(root.left, key);
root = Balance(root);
}
UpdateHeight(root);
}
else
Console.WriteLine("Key to be deleted could not be found");
return root;
}
// Driver Code
public static void Main(string[] args)
{
AVLwithparent root = null;
// Function call to insert the nodes
root = Insert(root, null, 9);
root = Insert(root, null, 5);
root = Insert(root, null, 10);
root = Insert(root, null, 0);
root = Insert(root, null, 6);
// Print the tree before deleting node
Console.WriteLine("Before deletion:");
PrintPreorder(root);
// Function Call to delete node 10
root = Delete(root, 10);
// Print the tree after deleting node
Console.WriteLine("After deletion:");
PrintPreorder(root);
}
}
//This code is contributed by Utkarsh
// AVL tree node
class AVLwithparent {
constructor(key) {
this.left = null;
this.right = null;
this.key = key;
this.par = null;
this.height = 1;
}
}
// Function to print the preorder traversal of the AVL tree
function printpreorder(root) {
if (root !== null) {
// Print the node's value along with its parent value
console.log(`Node: ${root.key}, Parent Node: ${root.par ? root.par.key : 'NULL'}`);
// Recur to the left subtree
printpreorder(root.left);
// Recur to the right subtree
printpreorder(root.right);
}
}
// Function to update the height of a node according to its children's node's heights
function Updateheight(root) {
if (root !== null) {
// Store the height of the current node
let val = 1;
// Store the height of the left and right subtree
if (root.left !== null) {
val = root.left.height + 1;
}
if (root.right !== null) {
val = Math.max(val, root.right.height + 1);
}
// Update the height of the current node
root.height = val;
}
}
// Function to handle Left Left Case
function LLR(root) {
// Create a reference to the left child
const tmpnode = root.left;
// Update the left child of the root to the right child of the current left child of the root
root.left = tmpnode.right;
// Update parent pointer of left child of the root node
if (tmpnode.right !== null) {
tmpnode.right.par = root;
}
// Update the right child of tmpnode to root
tmpnode.right = root;
// Update parent pointer of tmpnode
tmpnode.par = root.par;
// Update the parent pointer of root
root.par = tmpnode;
// Update tmpnode as the left or the right child of its parent pointer according to its key value
if (tmpnode.par !== null && root.key < tmpnode.par.key) {
tmpnode.par.left = tmpnode;
} else {
if (tmpnode.par !== null) {
tmpnode.par.right = tmpnode;
}
}
// Make tmpnode as the new root
root = tmpnode;
// Update the heights
Updateheight(root.left);
Updateheight(root.right);
Updateheight(root);
Updateheight(root.par);
// Return the root node
return root;
}
// Function to handle Right Right Case
function RRR(root) {
// Create a reference to the right child
const tmpnode = root.right;
// Update the right child of the root as the left child of the current right child of the root
root.right = tmpnode.left;
// Update parent pointer of the right child of the root node
if (tmpnode.left !== null) {
tmpnode.left.par = root;
}
// Update the left child of the tmpnode to root
tmpnode.left = root;
// Update parent pointer of tmpnode
tmpnode.par = root.par;
// Update the parent pointer of root
root.par = tmpnode;
// Update tmpnode as the left or the right child of its parent pointer according to its key value
if (tmpnode.par !== null && root.key < tmpnode.par.key) {
tmpnode.par.left = tmpnode;
} else {
if (tmpnode.par !== null) {
tmpnode.par.right = tmpnode;
}
}
// Make tmpnode as the new root
root = tmpnode;
// Update the heights
Updateheight(root.left);
Updateheight(root.right);
Updateheight(root);
Updateheight(root.par);
// Return the root node
return root;
}
// Function to handle Left Right Case
function LRR(root) {
root.left = RRR(root.left);
return LLR(root);
}
// Function to handle Right Left Case
function RLR(root) {
root.right = LLR(root.right);
return RRR(root);
}
// Function to Balance the tree after deletion of a node
function Balance(root) {
// Store the current height of the left and right subtree
let firstheight = 0;
let secondheight = 0;
if (root.left !== null) {
firstheight = root.left.height;
}
if (root.right !== null) {
secondheight = root.right.height;
}
// If the current node is not Balanced
if (Math.abs(firstheight - secondheight) === 2) {
if (firstheight < secondheight) {
// Store the height of the left and right subtree of the current node's right subtree
let rightheight1 = 0;
let rightheight2 = 0;
if (root.right.right !== null) {
rightheight2 = root.right.right.height;
}
if (root.right.left !== null) {
rightheight1 = root.right.left.height;
}
if (rightheight1 > rightheight2) {
// Right Left Case
root = RLR(root);
} else {
// Right Right Case
root = RRR(root);
}
} else {
// Store the height of the left and right subtree of the current node's left subtree
let leftheight1 = 0;
let leftheight2 = 0;
if (root.left.right !== null) {
leftheight2 = root.left.right.height;
}
if (root.left.left !== null) {
leftheight1 = root.left.left.height;
}
if (leftheight1 > leftheight2) {
// Left Left Case
root = LLR(root);
} else {
// Left Right Case
root = LRR(root);
}
}
}
// Return the root node
return root;
}
// Function to Insert a node in the AVL tree
function Insert(root, parent, key) {
if (root === null) {
// Create and assign values to a new node
root = new AVLwithparent(key);
if (root === null) {
console.log("Error in memory");
} else {
root.par = parent;
}
} else if (root.key > key) {
// Recur to the left subtree to Insert the node
root.left = Insert(root.left, root, key);
// Store the heights of the left and right subtree
let firstheight = 0;
let secondheight = 0;
if (root.left !== null) {
firstheight = root.left.height;
}
if (root.right !== null) {
secondheight = root.right.height;
}
// Balance the tree if the current node is not Balanced
if (Math.abs(firstheight - secondheight) === 2) {
if (root.left !== null && key < root.left.key) {
// Left Left Case
root = LLR(root);
} else {
// Left Right Case
root = LRR(root);
}
}
} else if (root.key < key) {
// Recur to the right subtree to Insert the node
root.right = Insert(root.right, root, key);
// Store the heights of the left and right subtree
let firstheight = 0;
let secondheight = 0;
if (root.left !== null) {
firstheight = root.left.height;
}
if (root.right !== null) {
secondheight = root.right.height;
}
// Balance the tree if the current node is not Balanced
if (Math.abs(firstheight - secondheight) === 2) {
if (root.right !== null && key < root.right.key) {
// Right Left Case
root = RLR(root);
} else {
// Right Right Case
root = RRR(root);
}
}
}
// Case when given key is already in tree
else {
// Do nothing
}
// Update the height of the root node
Updateheight(root);
// Return the root node
return root;
}
// Function to delete a node from the AVL tree
function Delete(root, key) {
if (root !== null) {
// If the node is found
if (root.key === key) {
// Replace root with its left child
if (root.right === null && root.left !== null) {
if (root.par !== null) {
if (root.par.key < root.key) {
root.par.right = root.left;
} else {
root.par.left = root.left;
}
// Update the height of root's parent
Updateheight(root.par);
}
root.left.par = root.par;
// Balance the node after deletion
root.left = Balance(root.left);
return root.left;
}
// Replace root with its right child
else if (root.left === null && root.right !== null) {
if (root.par !== null) {
if (root.par.key < root.key) {
root.par.right = root.right;
} else {
root.par.left = root.right;
}
// Update the height of the root's parent
Updateheight(root.par);
}
root.right.par = root.par;
// Balance the node after deletion
root.right = Balance(root.right);
return root.right;
}
// Delete the references of the current node
else if (root.left === null && root.right === null) {
if (root.par.key < root.key) {
root.par.right = null;
} else {
root.par.left = null;
}
if (root.par !== null) {
Updateheight(root.par);
}
root = null;
return null;
}
// Otherwise, replace the current node with its successor and then recursively call Delete()
else {
let tmpnode = root;
tmpnode = tmpnode.right;
while (tmpnode.left !== null) {
tmpnode = tmpnode.left;
}
let val = tmpnode.key;
root.right = Delete(root.right, tmpnode.key);
root.key = val;
// Balance the node after deletion
root = Balance(root);
}
}
// Recur to the right subtree to delete the current node
else if (root.key < key) {
root.right = Delete(root.right, key);
root = Balance(root);
}
// Recur into the right subtree to delete the current node
else if (root.key > key) {
root.left = Delete(root.left, key);
root = Balance(root);
}
// Update height of the root
if (root !== null) {
Updateheight(root);
}
}
// Handle the case when the key to be deleted could not be found
else {
console.log("Key to be deleted could not be found");
}
// Return the root node
return root;
}
// Driver Code
let root = null;
// Function call to Insert the nodes
root = Insert(root, null, 9);
root = Insert(root, null, 5);
root = Insert(root, null, 10);
root = Insert(root, null, 0);
root = Insert(root, null, 6);
// Print the tree before deleting node
console.log("Before deletion:");
printpreorder(root);
// Function Call to delete node 10
root = Delete(root, 10);
// Print the tree after deleting node
console.log("After deletion:");
printpreorder(root);
// This Code is contributed by Yash Agarwal(yashagarwal2852002)
OutputBefore deletion:
Node: 9, Parent Node: NULL
Node: 5, Parent Node: 9
Node: 0, Parent Node: 5
Node: 6, Parent Node: 5
Node: 10, Parent Node: 9
After deletion:
Node: 6, Parent Node: NULL
Node: 5, Parent ...
Time Complexity: O(log N), where N is the number of nodes of the tree
Auxiliary Space: O(1)
Similar Reads
AVL Tree Data Structure
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. The absolute difference between the heights of the left subtree and the right subtree for any node is known as the balance factor of
4 min read
What is AVL Tree | AVL Tree meaning
An AVL is a self-balancing Binary Search Tree (BST) where the difference between the heights of left and right subtrees of any node cannot be more than one. KEY POINTSIt is height balanced treeIt is a binary search treeIt is a binary tree in which the height difference between the left subtree and r
2 min read
Insertion in an AVL Tree
AVL tree is a self-balancing Binary Search Tree (BST) where the difference between heights of left and right subtrees cannot be more than one for all nodes. Example of AVL Tree: The above tree is AVL because the differences between the heights of left and right subtrees for every node are less than
15+ min read
Insertion, Searching and Deletion in AVL trees containing a parent node pointer
AVL tree is a self-balancing Binary Search Tree (BST) where the difference between heights of left and right subtrees cannot be more than one for all nodes. The insertion and deletion in AVL trees have been discussed in the previous article. In this article, insert, search, and delete operations are
15+ min read
Deletion in an AVL Tree
We have discussed AVL insertion in the previous post. In this post, we will follow a similar approach for deletion. Steps to follow for deletion. To make sure that the given tree remains AVL after every deletion, we must augment the standard BST delete operation to perform some re-balancing. Followi
15+ min read
How is an AVL tree different from a B-tree?
AVL Trees: AVL tree is a self-balancing binary search tree in which each node maintain an extra factor which is called balance factor whose value is either -1, 0 or 1. B-Tree: A B-tree is a self - balancing tree data structure that keeps data sorted and allows searches, insertions, and deletions in
1 min read
Practice questions on Height balanced/AVL Tree
AVL tree is binary search tree with additional property that difference between height of left sub-tree and right sub-tree of any node can’t be more than 1. Here are some key points about AVL trees: If there are n nodes in AVL tree, minimum height of AVL tree is floor(log 2 n). If there are n nodes
4 min read
AVL with duplicate keys
Please refer below post before reading about AVL tree handling of duplicates. How to handle duplicates in Binary Search Tree?This is to augment AVL tree node to store count together with regular fields like key, left and right pointers. Insertion of keys 12, 10, 20, 9, 11, 10, 12, 12 in an empty Bin
15+ min read
Count greater nodes in AVL tree
In this article we will see that how to calculate number of elements which are greater than given value in AVL tree. Examples: Input : x = 5 Root of below AVL tree 9 / \ 1 10 / \ \ 0 5 11 / / \ -1 2 6 Output : 4 Explanation: there are 4 values which are greater than 5 in AVL tree which are 6, 9, 10
15+ min read
Difference between Binary Search Tree and AVL Tree
Binary Search Tree:A binary Search Tree is a node-based binary tree data structure that has the following properties: The left subtree of a node contains only nodes with keys lesser than the node’s key.The right subtree of a node contains only nodes with keys greater than the node’s key.The left and
2 min read