avltree.cpp File Reference

A simple tree implementation using nodes. More...

#include <algorithm>
#include <iostream>
#include <queue>

Include dependency graph for avltree.cpp:

Typedefs
using	node = node { int data
	for std::queue

Functions
node *	createNode (int data)
	creates and returns a new node
int	height (node *root)
int	getBalance (node *root)
node *	rightRotate (node *root)
node *	leftRotate (node *root)
node *	minValue (node *root)
node *	insert (node *root, int item)
	inserts a new element into AVL tree
node *	deleteNode (node *root, int element)
	removes a given element from AVL tree
void	deleteAllNodes (const node *const root)
	calls delete on every node
void	levelOrder (node *root)
	prints given tree in the LevelOrder
int	main ()
	Main function.

Variables
int	height
struct node *	left
struct node *	right

Detailed Description

A simple tree implementation using nodes.

Todo:

update code to use C++ STL library features and OO structure

Warning

This program is a poor implementation and does not utilize any of the C++ STL features.

Typedef Documentation

node

using node = node { int data

for std::queue

for std::max for std::cout

Function Documentation

createNode()

node * createNode

(

int

data

)

creates and returns a new node

Parameters

[in]

data

value stored in the node

Returns

newly created node

                           {
    node *nn = new node();
    nn->data = data;
    nn->height = 0;
    nn->left = nullptr;
    nn->right = nullptr;
    return nn;
}

deleteAllNodes()

void deleteAllNodes

(

const node *const

root

)

calls delete on every node

Parameters

root	of the tree

                                            {
    if (root) {
        deleteAllNodes(root->left);
        deleteAllNodes(root->right);
        delete root;
    }
}

Here is the call graph for this function:

deleteNode()

node * deleteNode	(	node *	root,
		int	element
	)

removes a given element from AVL tree

Parameters

	root	of the tree
[in]	element	the element to be deleted from the tree

Returns

root of the updated tree

                                          {
    if (root == nullptr) {
        return root;
    }
    if (element < root->data) {
        root->left = deleteNode(root->left, element);
    } else if (element > root->data) {
        root->right = deleteNode(root->right, element);
 
    } else {
        // Node to be deleted is leaf node or have only one Child
        if (!root->right || !root->left) {
            node *temp = !root->right ? root->left : root->right;
            delete root;
            return temp;
        }
        // Node to be deleted have both left and right subtrees
        node *temp = minValue(root->right);
        root->data = temp->data;
        root->right = deleteNode(root->right, temp->data);
    }
    // Balancing Tree after deletion
    return root;
}

Here is the call graph for this function:

getBalance()

int getBalance

(

node *

root

)

Parameters

[in]

root

of the tree

Returns

difference between height of left and right subtree

{ return height(root->left) - height(root->right); }

height()

int height

(

node *

root

)

Parameters

[in]

root

the root of the tree

Returns

height of tree

                       {
    if (root == nullptr) {
        return 0;
    }
    return 1 + std::max(height(root->left), height(root->right));
}

Here is the call graph for this function:

insert()

node * insert	(	node *	root,
		int	item
	)

inserts a new element into AVL tree

Parameters

	root	of the tree
[in]	item	the element to be insterted into the tree

Returns

root of the updated tree

                                   {
    if (root == nullptr) {
        return createNode(item);
    }
    if (item < root->data) {
        root->left = insert(root->left, item);
    } else {
        root->right = insert(root->right, item);
    }
    int b = getBalance(root);
    if (b > 1) {
        if (getBalance(root->left) < 0) {
            root->left = leftRotate(root->left);  // Left-Right Case
        }
        return rightRotate(root);  // Left-Left Case
    } else if (b < -1) {
        if (getBalance(root->right) > 0) {
            root->right = rightRotate(root->right);  // Right-Left Case
        }
        return leftRotate(root);  // Right-Right Case
    }
    return root;
}

Here is the call graph for this function:

leftRotate()

node * leftRotate

(

node *

root

)

Parameters

root	of the tree to be rotated

Returns

node after left rotation

                             {
    node *t = root->right;
    node *u = t->left;
    t->left = root;
    root->right = u;
    return t;
}

levelOrder()

void levelOrder

(

node *

root

)

prints given tree in the LevelOrder

Parameters

[in]

root

of the tree

                            {
    std::queue<node *> q;
    q.push(root);
    while (!q.empty()) {
        root = q.front();
        std::cout << root->data << " ";
        q.pop();
        if (root->left) {
            q.push(root->left);
        }
        if (root->right) {
            q.push(root->right);
        }
    }
}

Here is the call graph for this function:

main()

int main

(

void

)

Main function.

Returns

0 on exit

           {
    // Testing AVL Tree
    node *root = nullptr;
    int i = 0;
    for (i = 1; i <= 7; i++) root = insert(root, i);
    std::cout << "LevelOrder: ";
    levelOrder(root);
    root = deleteNode(root, 1);  // Deleting key with value 1
    std::cout << "\nLevelOrder: ";
    levelOrder(root);
    root = deleteNode(root, 4);  // Deletin key with value 4
    std::cout << "\nLevelOrder: ";
    levelOrder(root);
    deleteAllNodes(root);
    return 0;
}

Here is the call graph for this function:

minValue()

node * minValue

(

node *

root

)

Parameters

root	of the tree

Returns

node with minimum value in the tree

                           {
    if (root->left == nullptr) {
        return root;
    }
    return minValue(root->left);
}

Here is the call graph for this function:

rightRotate()

node * rightRotate

(

node *

root

)

Parameters

root	of the tree to be rotated

Returns

node after right rotation

                              {
    node *t = root->left;
    node *u = t->right;
    t->right = root;
    root->left = u;
    return t;
}