data assignment 4

Abdur Rafay
[Company name] [Company address]
Q1
#include <iostream>
using namespace std;
template <typename T>
class AVLNode
{
public:
T data;
AVLNode<T>* left;
AVLNode<T>* right;
int height;

AVLNode(T data) : data(data), left(nullptr), right(nullptr), height(1) {}

};
template <typename T>
class AVLTree
{
public:
AVLNode<T>* root;
AVLTree() : root(nullptr) {}
void insert(T data)
{
root = insertRecursive(root, data);
}
AVLNode<T>* insertRecursive(AVLNode<T>* node, T data)
{
if (node == nullptr)
{
return new AVLNode<T>(data);
}
if (data < node->data)
{
node->left = insertRecursive(node->left, data);
}
else if (data > node->data)
{
node->right = insertRecursive(node->right, data);
}
else
{
return node;
}
node->height = 1 + max(getHeight(node->left), getHeight(node->right));
int balance = getBalance(node);
if (balance > 1 && data < node->left->data)
{
return rightRotate(node);
}
if (balance < -1 && data > node->right->data)
{
return leftRotate(node);
}
if (balance > 1 && data > node->left->data)
{
node->left = leftRotate(node->left);
return rightRotate(node);
}
if (balance < -1 && data < node->right->data)
{
node->right = rightRotate(node->right);
return leftRotate(node);
}
 return node;
}
int getHeight(AVLNode<T>* node)
{
if (node == nullptr)
{
return 0;
}
return node->height;
}
int getBalance(AVLNode<T>* node)
{
if (node == nullptr)
{
return 0;
}
return getHeight(node->left) - getHeight(node->right);
}
AVLNode<T>* leftRotate(AVLNode<T>* node)
{
AVLNode<T>* rightChild = node->right;
AVLNode<T>* leftGrandchild = rightChild->left;
rightChild->left = node;
node->right = leftGrandchild;

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

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

return rightChild;
}
AVLNode<T>* rightRotate(AVLNode<T>* node)
{
AVLNode<T>* leftChild = node->left;
AVLNode<T>* rightGrandchild = leftChild->right;

leftChild->right = node;
node->left = rightGrandchild;

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

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

return leftChild;
}
void inorder()
{
inorderRecursive(root);
}
void inorderRecursive(AVLNode<T>* node)
{
if (node != nullptr)
{
inorderRecursive(node->left);
cout << node->data << " ";
inorderRecursive(node->right);
}
}
};
int main()
{
AVLTree<int> tree;

tree.insert(10);
tree.insert(20);
 tree.insert(30);
tree.insert(40);
tree.insert(50);
tree.insert(25);

cout << "Inorder traversal of the AVL tree: ";

tree.inorder();

system("pause");
return 0;
}

Q2
#include <iostream>
using namespace std;
template <typename T>
class AVLNode {
public:
T data;
AVLNode<T>* left;
AVLNode<T>* right;
int height;

AVLNode(T data) : data(data), left(nullptr), right(nullptr), height(1) {}

};
template <typename T>
class AVLTree
{
public:
AVLNode<T>* root;

AVLTree() : root(nullptr) {}
void insert(T data)
{
root = insertRecursive(root, data);
}
AVLNode<T>* insertRecursive(AVLNode<T>* node, T data)
{
if (node == nullptr)
{
return new AVLNode<T>(data);
}
if (data < node->data)
 {
node->left = insertRecursive(node->left, data);
}
else if (data > node->data)
{
node->right = insertRecursive(node->right, data);
}
else
{
return node;
}
node->height = 1 + std::max(getHeight(node->left), getHeight(node->right));
int balance = getBalance(node);
if (balance > 1 && data < node->left->data)
{
return rightRotate(node);
}
if (balance < -1 && data > node->right->data)
{
return leftRotate(node);
}
if (balance > 1 && data > node->left->data)
{
node->left = leftRotate(node->left);
return rightRotate(node);
}
if (balance < -1 && data < node->right->data)
{
node->right = rightRotate(node->right);
return leftRotate(node);
}
return node;
}
int getHeight(AVLNode<T>* node)
{
if (node == nullptr)
{
return 0;
}
return node->height;
}
int getBalance(AVLNode<T>* node)
{
if (node == nullptr)
{
return 0;
}
return getHeight(node->left) - getHeight(node->right);
}
AVLNode<T>* leftRotate(AVLNode<T>* node)
{
AVLNode<T>* rightChild = node->right;
AVLNode<T>* leftGrandchild = rightChild->left;

rightChild->left = node;
node->right = leftGrandchild;

node->height = 1 + std::max(getHeight(node->left), getHeight(node->right));

rightChild->height = 1 + std::max(getHeight(rightChild->left), getHeight(rightChild->right));

return rightChild;
}
AVLNode<T>* rightRotate(AVLNode<T>* node)
 {
AVLNode<T>* leftChild = node->left;
AVLNode<T>* rightGrandchild = leftChild->right;

leftChild->right = node;
node->left = rightGrandchild;

node->height = 1 + std::max(getHeight(node->left), getHeight(node->right));

leftChild->height = 1 + std::max(getHeight(leftChild->left), getHeight(leftChild->right));

return leftChild;
}
bool isSubtreeAVL(T min, T max)
{
return isSubtreeAVLRecursive(root, min, max);
}
bool isSubtreeAVLRecursive(AVLNode<T>* node, T min, T max)
{
if (node == nullptr)
{
return true;
}
if (node->data < min || node->data > max)
{
return false;
}
return isSubtreeAVLRecursive(node->left, min, node->data - 1) &&
isSubtreeAVLRecursive(node->right, node->data + 1, max);
}
};
int main()
{
AVLTree<int> tree;

tree.insert(10);
tree.insert(20);
tree.insert(30);
tree.insert(40);
tree.insert(50);
tree.insert(25);

int min = 20;

int max = 40;

if (tree.isSubtreeAVL(min, max))
{
cout << "The subtree between " << min << " and " << max << " is an AVL tree." << endl;
}
else
{
cout << "The subtree between " << min << " and " << max << " is not an AVL tree." << endl;
}

return 0;
}
Q3
#include <iostream>
using namespace std;

struct Node
{
int key;
Node* left;
Node* right;
int height;
};
Node* newNode(int key)
{
Node* node = new Node();
node->key = key;
node->left = nullptr;
node->right = nullptr;
node->height = 1;
return node;
}
int height(Node* N)
{
if (N == nullptr)
return 0;
return N->height;
}
int max(int a, int b)
{
return (a > b) ? a : b;
}
Node* rightRotate(Node* y)
{
Node* x = y->left;
Node* T2 = x->right;
x->right = y;
y->left = T2;
y->height = 1 + max(height(y->left), height(y->right));
x->height = 1 + max(height(x->left), height(x->right));
return x;
}
Node* leftRotate(Node* x)
{
Node* y = x->right;
Node* T2 = y->left;
y->left = x;
x->right = T2;
 x->height = 1 + max(height(x->left), height(x->right));
y->height = 1 + max(height(y->left), height(y->right));
return y;
}
Node* insertNode(Node* node, int key)
{
if (node == nullptr)
return(newNode(key));
if (key < node->key)
node->left = insertNode(node->left, key);
else if (key > node->key)
node->right = insertNode(node->right, key);
else
return node;

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

int balance = height(node->left) - height(node->right);

if (balance > 1 && key < node->left->key)

return rightRotate(node);

if (balance < -1 && key > node->right->key)

return leftRotate(node);

if (balance > 1 && key > node->left->key)

{
node->left = leftRotate(node->left);
return rightRotate(node);
}

if (balance < -1 && key < node->right->key)

{
node->right = rightRotate(node->right);
return leftRotate(node);
}
return node;
}
Node* minValueNode(Node* node)
{
Node* current = node;
while (current->left != nullptr)
current = current->left;
return current;
}
Node* deleteNode(Node* root, int key)
{
if (root == nullptr)
return root;
if (key < root->key)
root->left = deleteNode(root->left, key);
else if (key > root->key)
root->right = deleteNode(root->right, key);
else {
if ((root->left == nullptr) || (root->right == nullptr))
{
Node* temp = root->left ? root->left : root->right;
if (temp == nullptr) {
temp = root;
root = nullptr;
}
else
*root = *temp;
 free(temp);
}
else
{
Node* temp = minValueNode(root->right);
root->key = temp->key;
root->right = deleteNode(root->right, temp->key);
}
}
if (root == nullptr)
return root;

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

int balance = height(root->left) - height(root->right);

if (balance > 1 && height(root->left->left) >= height(root->left->right))

return rightRotate(root);

if (balance > 1 && height(root->left->left) < height(root->left->right))

{
root->left = leftRotate(root->left);
return rightRotate(root);
}

if (balance < -1 && height(root->right->right) >= height(root->right->left))

return leftRotate(root);

if (balance < -1 && height(root->right->right) < height(root->right->left))

{
root->right = rightRotate(root->right);
return leftRotate(root);
}
return root;
}
void preOrder(Node* root)
{
if (root != nullptr)
{
cout << root->key << " ";
preOrder(root->left);
preOrder(root->right);
}
}
void kthLargestUtil(Node* root, int k, int& c)
{
if (root == nullptr || c >= k)
return;
kthLargestUtil(root->right, k, c);
c++;
if (c == k)
{
cout << "K'th largest element is " << root->key << endl;
return;
}
kthLargestUtil(root->left, k, c);
}
void kthLargest(Node* root, int k)
{
int c = 0;
kthLargestUtil(root, k, c);
}
int main()
{
Node* root = nullptr;
int n, k;
cout << "Enter the number of elements: ";
cin >> n;
cout << "Enter the elements: ";
for (int i = 0; i < n; i++)
{
int x;
cin >> x;
root = insertNode(root, x);
}
cout << "Enter the value of k: ";
cin >> k;
kthLargest(root, k);
root = deleteNode(root, k);
cout << "Preorder traversal of the modified AVL tree is \n";
preOrder(root);
return 0;
}

Q4
#include <iostream>

using namespace std;

template <typename T>

class AVLNode
{
public:
T data;
AVLNode<T>* left;
AVLNode<T>* right;
int height;
 AVLNode(T data) : data(data), left(nullptr), right(nullptr), height(1) {}
};

template <typename T>

class AVLTree
{
public:
AVLNode<T>* root;

AVLTree() : root(nullptr) {}

void insert(T data)

{
root = insertRecursive(root, data);
}

AVLNode<T>* insertRecursive(AVLNode<T>* node, T data)

{
if (node == nullptr)
{
return new AVLNode<T>(data);
}

if (data < node->data)

{
node->left = insertRecursive(node->left, data);
}
else if (data > node->data)
{
node->right = insertRecursive(node->right, data);
}
else
{
return node;
}

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

int balance = getBalance(node);

if (balance > 1 && data < node->left->data)

{
return rightRotate(node);
}
if (balance < -1 && data > node->right->data)
{
return leftRotate(node);
}
if (balance > 1 && data > node->left->data)
{
node->left = leftRotate(node->left);
return rightRotate(node);
}
if (balance < -1 && data < node->right->data)
{
node->right = rightRotate(node->right);
return leftRotate(node);
}

return node;
}

int getHeight(AVLNode<T>* node)

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

int getBalance(AVLNode<T>* node)

{
if (node == nullptr)
{
return 0;
}
return getHeight(node->left) - getHeight(node->right);
}

AVLNode<T>* leftRotate(AVLNode<T>* node)

{
AVLNode<T>* rightChild = node->right;
AVLNode<T>* leftGrandchild = rightChild->left;

rightChild->left = node;
node->right = leftGrandchild;

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

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

return rightChild;
}

AVLNode<T>* rightRotate(AVLNode<T>* node)

{
AVLNode<T>* leftChild = node->left;
AVLNode<T>* rightGrandchild = leftChild->right;

leftChild->right = node;
node->left = rightGrandchild;

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

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

return leftChild;
}

void reverseInorder(AVLNode<T>* node)

{
if (node == nullptr)
{
return;
}
reverseInorder(node->right);
cout << node->data << " ";
reverseInorder(node->left);
}

void reverseInorder()
{
reverseInorder(root);
cout << endl;
}
};
int max(int a, int b)
{
return (a > b) ? a : b;
}

int main()
{
int n;
cout << "Enter the number of elements: ";
cin >> n;

AVLTree<int> tree;
for (int i = 0; i < n; i++)
{
int value;
cout << "Enter element " << i + 1 << ": ";
cin >> value;
tree.insert(value);
}

cout << "The AVL tree in reverse inorder traversal: " << endl;
tree.reverseInorder();

return 0;
}

Q5
#include <iostream>
#include <string>

using namespace std;

template <typename T>

class AVLNode {
public:
T data;
int frequency;
AVLNode<T>* left;
AVLNode<T>* right;

AVLNode(T data, int frequency) : data(data), frequency(frequency), left(nullptr), right(nullptr) {}

};

template <typename T>

class AVLTree
{
public:
AVLNode<T>* root;

AVLTree() : root(nullptr) {}
void insert(T data)
{
int frequency = 1;
root = insertRecursive(root, data, frequency);
}
AVLNode<T>* insertRecursive(AVLNode<T>* node, T data, int& frequency) {
if (node == nullptr)
{
return new AVLNode<T>(data, frequency);
}
if (data < node->data)
{
node->left = insertRecursive(node->left, data, frequency);
}
else if (data > node->data)
{
node->right = insertRecursive(node->right, data, frequency);
}
else
{
frequency++;
node->frequency = frequency;
return node;
}
return node;
}
void playSong(T data)
{
if (root == nullptr)
{
cout << "The tree is empty." << endl;
return;
}
AVLNode<T>* node = root;
while (node != nullptr)
{
if (node->data == data)
{
node->frequency++;
return;
}
if (node->data < data)
{
node = node->right;
}
else
{
 node = node->left;
}
}
cout << "The song is not found." << endl;
}
void display()
{
displayRecursive(root, 0);
cout << endl;
}
void displayRecursive(AVLNode<T>* node, int level)
{
if (node == nullptr)
{
return;
}

displayRecursive(node->right, level + 1);

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

cout << " ";
}

cout << "[" << node->data << "(" << node->frequency << ")]";

displayRecursive(node->left, level + 1);

}
};
int main()
{
AVLTree<string> tree;

tree.insert("Song_A");
tree.insert("Song_B");
tree.insert("Song_C");
tree.insert("Song_D");
tree.insert("Song_E");
tree.insert("Song_F");
tree.insert("Song_G");
tree.insert("Song_H");
tree.insert("Song_I");
tree.insert("Song_J");
tree.insert("Song_K");

cout << "Initial tree:" << endl;

tree.display();
tree.playSong("Song_B");
tree.playSong("Song_C");
tree.playSong("Song_A");

cout << "Updated tree:" << endl;

tree.display();

return 0;
}
Q6
#include <iostream>
#include <fstream>
#include <string>
using namespace std;
struct Meaning
{
string description;
string example;
};
struct WordNode
{
string word;
Meaning* meanings;
int numMeanings;
WordNode* left;
WordNode* right;
};
WordNode* newNode(const string& word)
{
WordNode* node = new WordNode();
node->word = word;
node->meanings = nullptr;
node->numMeanings = 0;
node->left = nullptr;
node->right = nullptr;
return node;
}
WordNode* insertRecursive(WordNode* node, const std::string& word, const Meaning& meaning)
{
if (node == nullptr)
{
node = newNode(word);
node->meanings = new Meaning[1];
node->meanings[0] = meaning;
node->numMeanings = 1;
}
else if (word < node->word)
{
node->left = insertRecursive(node->left, word, meaning);
}
else if (word > node->word)
{
node->right = insertRecursive(node->right, word, meaning);
}
else
 {
Meaning* newMeanings = new Meaning[node->numMeanings + 1];
for (int i = 0; i < node->numMeanings; i++)
{
newMeanings[i] = node->meanings[i];
}
newMeanings[node->numMeanings] = meaning;
delete[] node->meanings;
node->meanings = newMeanings;
node->numMeanings++;
}
return node;
}
void loadDictionary(WordNode*& root, const std::string& filename)
{
ifstream file(filename);
if (!file.is_open())
{
cerr << "Error opening file: " << filename << endl;
return;
}
string word;
Meaning meaning;
while (file >> word)
{
getline(file, meaning.description, '\n');
getline(file, meaning.example, '\n');

word.erase(0, word.find_first_not_of(' '));

word.erase(word.find_last_not_of(' ') + 1);
meaning.description.erase(0, meaning.description.find_first_not_of(' '));
meaning.description.erase(meaning.description.find_last_not_of(' ') + 1);
meaning.example.erase(0, meaning.example.find_first_not_of(' '));
meaning.example.erase(meaning.example.find_last_not_of(' ') + 1);

root = insertRecursive(root, word, meaning);

}
file.close();
}
void suggestAutocomplete(WordNode* root, const string& prefix)
{
if (root == nullptr)
{
return;
}
if (prefix < root->word)
{
suggestAutocomplete(root->left, prefix);
}
else if (prefix > root->word)
{
suggestAutocomplete(root->right, prefix);
}
else
{
cout << root->word << endl;
suggestAutocomplete(root->left, prefix);
suggestAutocomplete(root->right, prefix);
}
}
void findMeanings(WordNode* root, const std::string& word)
{
if (root == nullptr)
 {
cout << "The word is not found." << endl;
return;
}
if (word < root->word)
{
findMeanings(root->left, word);
}
else if (word > root->word)
{
findMeanings(root->right, word);
}
else
{
for (int i = 0; i < root->numMeanings; i++)
{
cout << "Description: " << root->meanings[i].description << endl;
cout << "Example: " << root->meanings[i].example << endl;
cout << endl;
}
}
}
bool checkSpelling(WordNode* root, const std::string& word)
{
if (root == nullptr)
{
return false;
}
if (word < root->word)
{
return checkSpelling(root->left, word);
}
else if (word > root->word)
{
return checkSpelling(root->right, word);
}
else
{
return true;
}
}
int main()
{
WordNode* root = nullptr;
const string filename = "dictionary.txt";

loadDictionary(root, filename);

int choice;
string input;
while (true)
{
cout << "1. Suggest autocomplete options\n";
cout << "2. Find meanings of a word\n";
cout << "3. Check spelling\n";
cout << "4. Exit\n";
cout << "Enter your choice: ";
cin >> choice;
if (choice == 1)
{
cout << "Enter the prefix: ";
cin >> input;
suggestAutocomplete(root, input);
 }
else if (choice == 2)
{
cout << "Enter the word: ";
cin >> input;
findMeanings(root, input);
}
else if (choice == 3)
{
cout << "Enter the word: ";
cin >> input;
if (checkSpelling(root, input))
{
cout << "The word is spelled correctly." << endl;
}
else
{
cout << "The word is spelled incorrectly." << endl;
}
}
else if (choice == 4)
{
break;
}
else
{
cout << "Invalid choice. Please try again." << endl;
}
}
return 0;
}

Q7
#include <iostream>
#include <string>
using namespace std;

struct Task
{
int priority;
 string name;

Task(int priority, string name) : priority(priority), name(name) {}

};
struct TaskNode
{
Task task;
TaskNode* next;

TaskNode(Task task) : task(task), next(nullptr) {}

};
struct AVLNode
{
int height;
TaskNode* taskNode;
AVLNode* left;
AVLNode* right;

AVLNode(Task task) : height(1), taskNode(new TaskNode(task)), left(nullptr), right(nullptr) {}

};
class AVLTree
{
public:
AVLNode* root;
AVLTree() : root(nullptr) {}

int getHeight(AVLNode* node)

{
if (node == nullptr)
{
return 0;
}
return node->height;
}
int getBalance(AVLNode* node)
{
if (node == nullptr)
{
return 0;
}
return getHeight(node->left) - getHeight(node->right);
}
AVLNode* rightRotate(AVLNode* node)
{
AVLNode* newRoot = node->left;
node->left = newRoot->right;
newRoot->right = node;
node->height = 1 + max(getHeight(node->left), getHeight(node->right));
newRoot->height = 1 + max(getHeight(newRoot->left), getHeight(newRoot->right));
return newRoot;
}
AVLNode* leftRotate(AVLNode* node)
{
AVLNode* newRoot = node->right;
node->right = newRoot->left;
newRoot->left = node;
node->height = 1 + max(getHeight(node->left), getHeight(node->right));
newRoot->height = 1 + max(getHeight(newRoot->left), getHeight(newRoot->right));
return newRoot;
}
AVLNode* insertRecursive(AVLNode* node, Task task)
{
if (node == nullptr)
 {
return new AVLNode(task);
}
if (task.priority < node->taskNode->task.priority)
{
node->left = insertRecursive(node->left, task);
}
else if (task.priority > node->taskNode->task.priority)
{
node->right = insertRecursive(node->right, task);
}
else
{
TaskNode* newNode = new TaskNode(task);
newNode->next = node->taskNode;
node->taskNode = newNode;
}
node->height = 1 + max(getHeight(node->left), getHeight(node->right));
int balance = getBalance(node);

if (balance > 1 && task.priority < node->left->taskNode->task.priority)

{
return rightRotate(node);
}
if (balance < -1 && task.priority > node->right->taskNode->task.priority)
{
return leftRotate(node);
}
if (balance > 1 && task.priority > node->left->taskNode->task.priority)
{
node->left = leftRotate(node->left);
return rightRotate(node);
}
if (balance < -1 && task.priority < node->right->taskNode->task.priority)
{
node->right = rightRotate(node->right);
return leftRotate(node);
}
return node;
}
void executeTasks(AVLNode* node)
{
if (node == nullptr)
{
return;
}
executeTasks(node->left);
TaskNode* current = node->taskNode;
while (current != nullptr)
{
cout << "Executing task: " << current->task.name << ", Priority: " << current->task.priority << endl;
current = current->next;
}
executeTasks(node->right);
}
};
int main()
{
AVLTree tree;

tree.root = tree.insertRecursive(tree.root, Task(1, "Task 1"));

tree.root = tree.insertRecursive(tree.root, Task(2, "Task 2"));
tree.root = tree.insertRecursive(tree.root, Task(3, "Task 3"));
 tree.root = tree.insertRecursive(tree.root, Task(4, "Task 4"));
tree.root = tree.insertRecursive(tree.root, Task(5, "Task 5"));

tree.executeTasks(tree.root);

return 0;
}