Scribd
Upload
21 views6 pages

AVL Tree - Code.docx

Uploaded by

Zunaira Amjad
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
21 views6 pages

AVL Tree - Code.docx

Uploaded by

Zunaira Amjad
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/ 6

#include <iostream>

#include <algorithm> // for std::max


using namespace std;

//Node class
class Node {
public:
int data, height;
Node* left_node;
Node* right_node;

Node(int val) {
data = val;
height = 1; // Initial height for a leaf node
left_node = right_node = nullptr;
}
};

//AVL class
//create AVL Class
class AVLTree {

//or
/*
// Nested Node struct within AVLTree
struct Node {
int data, height;
Node* left_node;
Node* right_node;
Node(int val) : data(val), height(1), left_node(nullptr), right_node(nullptr) {}
};
*/

public:
Node* root;

AVLTree() {
root = nullptr;
}
//get height of a node

int get_height(Node* node) {


if (node == nullptr)
return 0;
return node->height;
}

//get balance factor

int get_balance_factor(Node* node) {


if (node == nullptr)
return 0;
return get_height(node->left_node) - get_height(node->right_node);
}

//1- Right rotation

Node* LL_rotation(Node* node) {


Node* child = node->left_node;
node->left_node = child->right_node;
child->right_node = node;

node->height = max(get_height(node->left_node), get_height(node->right_node)) + 1;


child->height = max(get_height(child->left_node), get_height(child->right_node)) + 1;

return child;
}

//2- left rotation

Node* RR_rotation(Node* node) {


Node* child = node->right_node;
node->right_node = child->left_node;
child->left_node = node;

node->height = max(get_height(node->left_node), get_height(node->right_node)) + 1;


child->height = max(get_height(child->left_node), get_height(child->right_node)) + 1;

return child;
}

//add a new Node

Node* insert(Node* node, int val) {


if (node == nullptr)
return new Node(val);

if (val < node->data) {


node->left_node = insert(node->left_node, val);
} else if (val > node->data) {
node->right_node = insert(node->right_node, val);
} else {
return node; // Duplicate values not allowed, return the same node
}

node->height = max(get_height(node->left_node), get_height(node->right_node)) + 1;

int balance = get_balance_factor(node);

// Left-Left (LL) case


if (balance > 1 && val < node->left_node->data)
return LL_rotation(node);

// Right-Right (RR) case


if (balance < -1 && val > node->right_node->data)
return RR_rotation(node);

// Left-Right (LR) case


if (balance > 1 && val > node->left_node->data) {
node->left_node = RR_rotation(node->left_node);
return LL_rotation(node);
}

// Right-Left (RL) case


if (balance < -1 && val < node->right_node->data) {
node->right_node = LL_rotation(node->right_node);
return RR_rotation(node);
}

return node;
}

//in order traversal

void in_order(Node* node) {


if (node != nullptr) {
in_order(node->left_node); // Traverse the left subtree
cout << node->data << " "; // Visit the root (current node)
in_order(node->right_node); // Traverse the right subtree
}
}

//inorder successor (smallest value from left subtree)

Node* min_value_node(Node* node) {


Node* current = node;
while (current->left_node != nullptr)
current = current->left_node;
return current;
}

//delete a node

Node* delete_node(Node* root, int key) {


if (root == nullptr)
return root;

if (key < root->data) {


root->left_node = delete_node(root->left_node, key);
} else if (key > root->data) {
root->right_node = delete_node(root->right_node, key);
} else {
if ((root->left_node == nullptr) || (root->right_node == nullptr)) {
Node* temp = root->left_node ? root->left_node : root->right_node;
if (temp == nullptr) {
temp = root;
root = nullptr;
} else {
*root = *temp;
}

delete temp;
} else {
Node* temp = min_value_node(root->right_node);
root->data = temp->data;
root->right_node = delete_node(root->right_node, temp->data);
}
}

if (root == nullptr)
return root;

root->height = max(get_height(root->left_node), get_height(root->right_node)) + 1;


int balance = get_balance_factor(root);

if (balance > 1 && get_balance_factor(root->left_node) >= 0)


return LL_rotation(root);

if (balance > 1 && get_balance_factor(root->left_node) < 0) {


root->left_node = RR_rotation(root->left_node);
return LL_rotation(root);
}

if (balance < -1 && get_balance_factor(root->right_node) <= 0)


return RR_rotation(root);

if (balance < -1 && get_balance_factor(root->right_node) > 0) {


root->right_node = LL_rotation(root->right_node);
return RR_rotation(root);
}

return root;
}

};
int main() {
AVLTree tree;

tree.root = tree.insert(tree.root, 17);


tree.root = tree.insert(tree.root, 18);
tree.root = tree.insert(tree.root, 19);
tree.root = tree.insert(tree.root, 11);
tree.root = tree.insert(tree.root, 10);
tree.root = tree.insert(tree.root, 16);

cout << "in_order Traversal of the AVL Tree before deletion: ";
tree.in_order(tree.root);
cout << endl;

tree.root = tree.delete_node(tree.root, 18);

cout << "in_order Traversal of the AVL Tree after deletion: ";
tree.in_order(tree.root);
cout << endl;

cout << "In-order Traversal of the AVL Tree after deletion: ";
tree.in_order(tree.root);
cout << endl;

return 0;
}

You might also like

pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy