300 lines
5.3 KiB
C++
300 lines
5.3 KiB
C++
// WARNING: THIS CODE HAS NOT BEEN TESTED.
|
|
// IT WILL TAKE 1-2 MONTHS TO PERFECT THE CODE.
|
|
// IF YOU FACE ANY ERRORS, UNEXPECTED BEHAVIOUR OR HAVE ANY SUGGESTIONS,
|
|
// LET US KNOW BY CREATING AN ISSUE ON OUR KSKA GIT REPOSITORY.
|
|
|
|
/*
|
|
Problem Statement: A Dictionary stores keywords & its meanings. Provide facility for adding new keywords, deleting keywords, updating values of any entry. Provide facility to display whole data sorted in ascending/ Descending order. Also find how many maximum comparisons may require for finding any keyword. Use Binary Search Tree for implementation.
|
|
|
|
Code from Data Structures and Algorithms (SPPU - Second Year - Computer Engineering - Content) repository on KSKA Git: https://git.kska.io/sppu-se-comp-content/DataStructuresAndAlgorithms/
|
|
*/
|
|
|
|
// BEGINNING OF CODE
|
|
#include <iostream>
|
|
using namespace std;
|
|
class node
|
|
{
|
|
public:
|
|
string word;
|
|
string meaning;
|
|
node* left=NULL;
|
|
node* right=NULL;
|
|
|
|
node(string x, string y)
|
|
{
|
|
word = x;
|
|
meaning = y;
|
|
left = NULL;
|
|
right = NULL;
|
|
}
|
|
friend class Dictionary;
|
|
};
|
|
|
|
class Dictionary
|
|
{
|
|
public:
|
|
node* root, *q; //q is parent here
|
|
Dictionary()
|
|
{
|
|
root = NULL;
|
|
q=NULL;
|
|
}
|
|
|
|
void insert(node*, string, string);
|
|
void display_asc(node *);
|
|
void display_desc(node *);
|
|
void comparisons(node*, string);
|
|
void updateWord(node*, string);
|
|
//void deleteWord(node*, string);
|
|
//node* min_node(node *);
|
|
};
|
|
|
|
void Dictionary::insert(node* p, string key, string keyMeaning)
|
|
{
|
|
if(key < p->word)
|
|
{
|
|
if(p->left != NULL)
|
|
insert(p->left, key, keyMeaning);
|
|
else
|
|
p->left = new node(key, keyMeaning);
|
|
}
|
|
else if(key > p->word)
|
|
{
|
|
if(p->right != NULL)
|
|
insert(p->right, key, keyMeaning);
|
|
else
|
|
p->right = new node(key, keyMeaning);
|
|
}
|
|
}
|
|
|
|
void Dictionary::display_asc(node *p) //inorder
|
|
{
|
|
if(p->left!=NULL)
|
|
display_asc(p->left);
|
|
cout<<"\n" << p->word<<" \t" << p->meaning;
|
|
if(p->right!=NULL)
|
|
display_asc(p->right);
|
|
}
|
|
|
|
void Dictionary::display_desc(node *p)
|
|
{
|
|
if(p->right!=NULL)
|
|
display_desc(p->right);
|
|
cout<<"\n" << p->word<<" \t" << p->meaning;
|
|
if(p->left!=NULL)
|
|
display_desc(p->left);
|
|
}
|
|
|
|
void Dictionary::comparisons(node* p, string key)
|
|
{
|
|
static int count = 0;
|
|
while(p!=NULL)
|
|
{
|
|
if(key < p->word)
|
|
{
|
|
count++;
|
|
p = p->left;
|
|
}
|
|
|
|
else if(key > p->word)
|
|
{
|
|
count++;
|
|
p = p->right;
|
|
}
|
|
|
|
else if(key == p->word)
|
|
{
|
|
count++;
|
|
cout<<"Number of comparisons to find the word: " << count;
|
|
return ;
|
|
}
|
|
}
|
|
|
|
cout<<"\nWord not found!";
|
|
}
|
|
|
|
node* Dictionary::min_node(node *p)
|
|
{
|
|
while(p->left != NULL)
|
|
{
|
|
q = p;
|
|
p = p->left;
|
|
}
|
|
return p;
|
|
}
|
|
|
|
void Dictionary::deleteWord(node* p, string key)
|
|
{
|
|
node *s;
|
|
while(p!=NULL) //searching for word
|
|
{
|
|
if(key < p->word)
|
|
{
|
|
q = p;
|
|
p = p->left;
|
|
}
|
|
|
|
else if(key > p->word)
|
|
{
|
|
q=p;
|
|
p = p->right;
|
|
}
|
|
|
|
else if(key == p->word) //word found
|
|
{
|
|
if(p->left==NULL && p->right==NULL) //no child
|
|
{
|
|
if(q->left==p)
|
|
{
|
|
delete p;
|
|
q->left=NULL;
|
|
return;
|
|
}
|
|
|
|
if(q->right==p)
|
|
{
|
|
delete p;
|
|
q->right=NULL;
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
if(p->right!=NULL && p->left==NULL) //right child only
|
|
{
|
|
if(q->right == p)
|
|
{
|
|
q->right = p->right;
|
|
delete p;
|
|
return;
|
|
}
|
|
|
|
else if(q->left == p)
|
|
{
|
|
q->left = p->right;
|
|
delete p;
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
else if(p->left!=NULL && p->right==NULL) //left child only
|
|
{
|
|
if(q->right == p)
|
|
{
|
|
q->right = p->left;
|
|
delete p;
|
|
return;
|
|
}
|
|
|
|
else if(q->left == p)
|
|
{
|
|
q->left=p->left;
|
|
delete p;
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
else if(p->left!=NULL && p->right!=NULL)
|
|
{
|
|
s = min_node(p->right);
|
|
p->word = s->word;
|
|
p->meaning = s->meaning;
|
|
deleteWord(s, s->word);
|
|
return;
|
|
|
|
}
|
|
}
|
|
}
|
|
cout<<"\nWord NOT found!";
|
|
}
|
|
|
|
void Dictionary::updateWord(node* p, string key)
|
|
{
|
|
while(p!=NULL)
|
|
{
|
|
if(key < p->word)
|
|
p = p->left;
|
|
|
|
else if(key > p->word)
|
|
p = p->right;
|
|
|
|
else if(key == p->word)
|
|
{
|
|
cout<<"\nEnter its new meaning: ";
|
|
cin>>p->meaning;
|
|
return;
|
|
}
|
|
}
|
|
cout<<"\nWord not found!";
|
|
}
|
|
//f b h a d g i c e k j
|
|
|
|
int main()
|
|
{
|
|
int choice, n;
|
|
string newWord, searchWord, newMeaning;
|
|
Dictionary d1;
|
|
menu:
|
|
cout<<"\n\nDICTIONARY: ";
|
|
cout<<"\n\n1. Insert new words";
|
|
cout<<"\n2. Display the dictionary in ascending order";
|
|
cout<<"\n3. Display the dictionary in descending order";
|
|
cout<<"\n4. Search and update a word";
|
|
cout<<"\n5. Delete a word";
|
|
cout<<"\n6. Comparisons";
|
|
cout<<"\n\nEnter your choice: ";
|
|
cin>>choice;
|
|
switch(choice)
|
|
{
|
|
case 1:
|
|
cout<<"\nEnter the number of words to insert: ";
|
|
cin >> n;
|
|
for(int i=0 ; i<n ; i++)
|
|
{
|
|
cout<<"\nEnter the word to be inserted: ";
|
|
cin >> newWord;
|
|
cout<<"\nEnter its meaning: ";
|
|
cin >> newMeaning;
|
|
if(d1.root == NULL)
|
|
d1. root = new node(newWord, newMeaning);
|
|
else
|
|
d1.insert(d1.root, newWord, newMeaning);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
d1.display_asc(d1.root);
|
|
break;
|
|
|
|
case 3:
|
|
d1.display_desc(d1.root);
|
|
break;
|
|
|
|
case 4:
|
|
cout<<"\nEnter the word to search: ";
|
|
cin >> searchWord;
|
|
d1.updateWord(d1.root, searchWord);
|
|
break;
|
|
|
|
case 5:
|
|
cout<<"\nEnter the word to delete: ";
|
|
cin>>searchWord;
|
|
d1.deleteWord(d1.root, searchWord);
|
|
break;
|
|
|
|
case 6:
|
|
cout<<"\nEnter the word to find comparisons: ";
|
|
cin >> searchWord;
|
|
d1.comparisons(d1.root, searchWord);
|
|
|
|
default:
|
|
cout<<"\nInvalid input!";
|
|
}
|
|
if(choice!=7)
|
|
goto menu;
|
|
return 0;
|
|
}
|
|
// END OF CODE
|
|
// EXPERIMENTAL CODE
|