DSA

ASSIGNMENT # 3
SOURCE CODE:
#include <iostream>

#include <fstream>

#include<conio.h>

#include <stdio.h>

#include <string.h>

#include <windows.h>

using namespace std;

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

#include <bits/stdc++.h>

#define C 10

void clearScreen()//function to clear screen in console

// HANDLE is a predefined class

// The handle class stores and manages a pointer to the base //class. The type of the object to which that pointer
points will //vary; it can point at either a base- or a derived-type object. //Users access the operations of the
inheritance hierarchy //through the handle.

HANDLE hStdOut;

CONSOLE_SCREEN_BUFFER_INFO csbi;

DWORD count;

DWORD cellCount;

COORD homeCoords = { 0, 0 };

hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);

if (hStdOut == INVALID_HANDLE_VALUE) return;

/* Get the number of cells in the current buffer */

if (!GetConsoleScreenBufferInfo(hStdOut, &csbi)) return;

/* Fill the entire buffer with spaces */

if (!FillConsoleOutputCharacter(

hStdOut,

(TCHAR)' ',

cellCount,

homeCoords,

&count

)) return;

/* Fill the entire buffer with the current colors and attributes */

if (!FillConsoleOutputAttribute(

hStdOut,

csbi.wAttributes,

cellCount,

homeCoords,

&count

)) return;

/* Move the cursor home */

SetConsoleCursorPosition(hStdOut, homeCoords);

//-----------------------------------------------------------

struct node{

string data;

int height;

struct node *left;

struct node *right;

};
int max(int n1, int n2){//function to get max of two numbers

if(n1 > n2){

return n1;

return n2;

void printTree(node *root, int s){

if(root == NULL){

return;

s += C;

printTree(root->right,s);

cout<<root->data<<"->"<<endl;

printTree(root->left, s);

void output(node *root, int i){

cout<<"<<"<<i<<">>"<<endl;

printTree(root,0);

int getIndex(string name){

string s1 = bitset<8>(name[0]).to_string();

s1 = s1.substr(s1.length() - 3);
 int n = 0;

int s = s1.size();

for(int i = 0; i < s; i++){

if(s1[i] == '1'){

n += pow(2.0, i);

}else if(s1[i] == '1' && i != 0){

n += pow(0.0, i);

return n;

//-----------------------------------------------------------------------------

//-------------------------------------------------------------------------------

class AvlTree{

public:

struct node *root;

AvlTree(){

this->root = NULL;

node *rotateRight(node *currentNode){

node *leftNode = currentNode->left;

leftNode->right = currentNode;

currentNode->left = rightNode;

currentNode->height = max(getHeight(currentNode->left),getHeight(currentNode-
>right)) + 1;

leftNode->height = max(getHeight(leftNode->left),getHeight(leftNode->right)) + 1;

return leftNode;

node *rotateLeft(node *currentNode){

node *leftNode = currentNode->left;

node *rightNode = currentNode->right;

rightNode->left = currentNode;

currentNode->right = leftNode;

currentNode->height = max(getHeight(currentNode->left),getHeight(currentNode-
>right)) + 1;

leftNode->height = max(getHeight(rightNode->left),getHeight(rightNode->right)) + 1;

return rightNode;

node *minimumValueNode(node *currentNode){

node *temp = currentNode;

while(temp->left != NULL){

temp = temp->left;
 }

return temp;

int calculateHeight(struct node *currentNode){

if(currentNode->left && currentNode->right){

if(currentNode->left->height < currentNode->right->height){

return currentNode->right->height + 1;

}else return currentNode->left->height +1;

}else if(currentNode->left && currentNode->right == NULL){

return currentNode->left->height + 1;

}else if(currentNode->left == NULL && currentNode->right){

return currentNode->right->height + 1;

}return 0;

int getHeight(node *currentNode){

if(currentNode == NULL){

return 0;

return currentNode->height;

int calculateBalance(node *currentNode){

if(currentNode == NULL){

return 0;

int balance = getHeight(currentNode->left)-getHeight(currentNode->right);

return balance;

}
node *insertNode(node *root, string data){

if(root == NULL){

struct node *currentNode;

currentNode = new struct node;

currentNode->data = data;

root = currentNode;

root->left = root->right = NULL;

root->height = 1;

return root;

}else{

if(data < root->data){

root->left = insertNode(root->left,data);

}else if(data > root->data){

root->right = insertNode(root->right, data);

}else{

return root;

root->height = calculateHeight(root);

int balance = calculateBalance(root);

if(balance > 1 && data < root->left->data){

return rotateRight(root);

if(balance < -1 && data > root->right->data){

root->left = rotateLeft(root->left);

return rotateRight(root);

}
 if(balance > 1 && data > root->left->data){

root->left = rotateLeft(root->left);

return rotateRight(root);

if(balance < -1 && data < root->right->data){

root->right = rotateRight(root->right);

return rotateLeft(root);

return root;

node *deleteNode(node *root, string data){

if(root == NULL){

return root;

if(data < root->data){

root->left = deleteNode(root->left, data);

}else if(data > root->data){

root->right = deleteNode(root->right, data);

}else{

if((root->left == NULL) || (root->right == NULL)){

node *temp;

if(root->left){

temp = root->left;

}else{

temp = root->right;
 }

if( temp == NULL){

temp = root;

root == NULL;

}else{

*root = *temp;

free(temp);

}else{

node *temp = minimumValueNode(root->right);

root->data = temp->data;

root->right = deleteNode(root->right, temp->data);

if(root == NULL){

return root;

root->height = max(getHeight(root->left), getHeight(root->right)) + 1;

int balance = calculateBalance(root);

if(balance > 1 && calculateBalance(root->left) >= 0){

return rotateRight(root);

if(balance > 1 && calculateBalance(root->left) > 0){

root->left = rotateLeft(root->left);
 return rotateRight(root);

if(balance < -1 && calculateBalance(root->right) <= 0){

return rotateLeft(root);

if(balance < -1 && calculateBalance(root->right) > 0){

root->right = rotateRight(root->right);

return rotateLeft(root);

return root;

};

//-----------------------------------------------------------------

class HashTable{

int size;

AvlTree *tree;

public:

int hasher(string name){

return getIndex(name);

HashTable(int size){

this->size = size;

tree = new AvlTree[size];

}
 void insertItem(string data){

int i = hasher(data);

tree[i].root = tree[i].insertNode(tree[i].root, data);

int getHashHeight(int i){

return tree[i].root->height;

deleteItem(string data){

int i = hasher(data);

tree[i].root = tree[i].deleteNode(tree[i].root, data);

void insertItm(string data){

int i = hasher(data);

tree[i].root = tree[i].insertNode(tree[i].root, data);

void displayHash(){

for(int i = 0; i < size; i++){

output(tree[i].root, i);

};
int main(int argc, char** argv) {

string arr[91];

int c = 0;//counter for while loop

string l;//string to store lines from text file temporarily

ifstream file;//creating an instance of ifstream class

string data;

int i;

file.open("C:/Users/hp/Desktop/New folder/NamesToHash.txt");//opening file from location

if(file.is_open()){

while (getline (file, l)){//while end of file is not reached

//get each line from the text file and store in the variable l

arr[c] = l;//assign l to each index position in array

c++;//increment c

if(file.eof()) break;

file.close();//closing the file

int n = sizeof(arr)/sizeof(arr[0]);//size of array

HashTable hash(8);

for(int j = 0; j<n;j++){//inserting data in the hashtable

hash.insertItem(arr[j]);

}
int choice = 0;//user choice

string choice2;

while(choice != 4){//loop breaks when user enters 4

clearScreen();

cout<<"Wh do you want to do?"<< endl;

cout<<"1. Insert a name."<<endl;

cout<<"2. Delete a name."<<endl;

cout<<"3. View names."<<endl;

cout<<"4. Exit"<<endl;

cin>>choice;

switch(choice){

case 1:

cout<<"Enter name to be inserted:"<<endl;

getline(cin, data);

getline(cin, data);

hash.insertItem(data);

cout<<"press any key to continue:";

cin>>choice2;

break;

case 2:

cout<<"Enter name to be deleted:"<<endl;

getline(cin, data);

getline(cin, data);

hash.deleteItem(data);

cout<<"press any key to continue:";

break;

case 3:

hash.displayHash();

cout<<"press any key to continue:";

cin>>choice2;

break;