Scribd
Upload
12 views18 pages

LAB09

The document contains multiple implementations of a Binary Search Tree (BST) in C++. Each section includes functions for inserting, deleting, and finding nodes, as well as performing inorder traversal and calculating the sum of leaf nodes. Additionally, it demonstrates deleting nodes at a specific level and finding the closest value to a given key.

Uploaded by

f230055
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
12 views18 pages

LAB09

The document contains multiple implementations of a Binary Search Tree (BST) in C++. Each section includes functions for inserting, deleting, and finding nodes, as well as performing inorder traversal and calculating the sum of leaf nodes. Additionally, it demonstrates deleting nodes at a specific level and finding the closest value to a given key.

Uploaded by

f230055
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 18

NAME : DANIAL ZAHID

ROLL NO : F23-0055
DATA STRUCTURES
LAB # 09

Q#01
#include <iostream>
using namespace std;

struct Node {
int data;
Node* left;
Node* right;
Node(int val) : data(val), left(nullptr), right(nullptr) {}
};

class BST {
public:
Node* root;
BST() : root(nullptr) {}

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


if (!node) return new Node(key);
if (key < node->data)
node->left = insert(node->left, key);
else if (key > node->data)
node->right = insert(node->right, key);
return node;
}

Node* find(Node* node, int key) {


if (!node || node->data == key) return node;
if (key < node->data) return find(node->left, key);
return find(node->right, key);
}

Node* findMin(Node* node) {


if (!node || !node->left) return node;
return findMin(node->left);
}

Node* deleteNode(Node* node, int key) {


if (!node) return nullptr;
if (key < node->data)
node->left = deleteNode(node->left, key);
else if (key > node->data)
node->right = deleteNode(node->right, key);
else {
if (!node->left) {
Node* temp = node->right;
delete node;
return temp;
}
else if (!node->right) {
Node* temp = node->left;
delete node;
return temp;
}
Node* temp = findMin(node->right);
node->data = temp->data;
node->right = deleteNode(node->right, temp->data);
}
return node;
}

void inorder(Node* node) {


if (!node) return;
inorder(node->left);
cout << node->data << " ";
inorder(node->right);
}
};

int main() {
BST tree;
tree.root = tree.insert(tree.root, 50);
tree.insert(tree.root, 30);
tree.insert(tree.root, 70);
tree.insert(tree.root, 20);
tree.insert(tree.root, 40);
tree.insert(tree.root, 60);
tree.insert(tree.root, 80);

cout << "Inorder traversal: ";


tree.inorder(tree.root);
cout << endl;

cout << "Deleting 50...\n";


tree.root = tree.deleteNode(tree.root, 50);
cout << "Inorder traversal after deletion: ";
tree.inorder(tree.root);
cout << endl;
system("pause");
return 0;
}
Q#02
#include <iostream>
using namespace std;

struct Node {
int data;
Node* left;
Node* right;
Node(int val) : data(val), left(nullptr), right(nullptr) {}
};

class BST {
public:
Node* root;
BST() : root(nullptr) {}

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


if (!node) return new Node(key);
if (key < node->data)
node->left = insert(node->left, key);
else if (key > node->data)
node->right = insert(node->right, key);
return node;
}

Node* find(Node* node, int key) {


if (!node || node->data == key) return node;
if (key < node->data) return find(node->left, key);
return find(node->right, key);
}

Node* findMin(Node* node) {


if (!node || !node->left) return node;
return findMin(node->left);
}

Node* deleteNode(Node* node, int key) {


if (!node) return nullptr;
if (key < node->data)
node->left = deleteNode(node->left, key);
else if (key > node->data)
node->right = deleteNode(node->right, key);
else {
if (!node->left) {
Node* temp = node->right;
delete node;
return temp;
}
else if (!node->right) {
Node* temp = node->left;
delete node;
return temp;
}
Node* temp = findMin(node->right);
node->data = temp->data;
node->right = deleteNode(node->right, temp->data);
}
return node;
}

void inorder(Node* node) {


if (!node) return;
inorder(node->left);
cout << node->data << " ";
inorder(node->right);
}

int sumOfLeafNodes(Node* node) {


if (!node) return 0;
if (!node->left && !node->right) return node->data;
return sumOfLeafNodes(node->left) + sumOfLeafNodes(node->right);
}
};

int main() {
BST tree;
tree.root = tree.insert(tree.root, 50);
tree.insert(tree.root, 30);
tree.insert(tree.root, 70);
tree.insert(tree.root, 20);
tree.insert(tree.root, 40);
tree.insert(tree.root, 60);
tree.insert(tree.root, 80);

cout << "Inorder traversal: ";


tree.inorder(tree.root);
cout << endl;

cout << "Deleting 50...\n";


tree.root = tree.deleteNode(tree.root, 50);
cout << "Inorder traversal after deletion: ";
tree.inorder(tree.root);
cout << endl;

cout << "Sum of leaf nodes: " << tree.sumOfLeafNodes(tree.root) << endl;
system("pause");
return 0;
}

Q#03
#include <iostream>
using namespace std;

struct Node {
int data;
Node* left;
Node* right;
Node(int val) : data(val), left(nullptr), right(nullptr) {}
};

class BST {
public:
Node* root;
BST() : root(nullptr) {}

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


if (!node) return new Node(key);
if (key < node->data)
node->left = insert(node->left, key);
else if (key > node->data)
node->right = insert(node->right, key);
return node;
}

Node* find(Node* node, int key) {


if (!node || node->data == key) return node;
if (key < node->data) return find(node->left, key);
return find(node->right, key);
}

Node* findMin(Node* node) {


if (!node || !node->left) return node;
return findMin(node->left);
}

Node* deleteNode(Node* node, int key) {


if (!node) return nullptr;
if (key < node->data)
node->left = deleteNode(node->left, key);
else if (key > node->data)
node->right = deleteNode(node->right, key);
else {
if (!node->left) {
Node* temp = node->right;
delete node;
return temp;
}
else if (!node->right) {
Node* temp = node->left;
delete node;
return temp;
}
Node* temp = findMin(node->right);
node->data = temp->data;
node->right = deleteNode(node->right, temp->data);
}
return node;
}

void inorder(Node* node) {


if (!node) return;
inorder(node->left);
cout << node->data << " ";
inorder(node->right);
}

int sumOfLeafNodes(Node* node) {


if (!node) return 0;
if (!node->left && !node->right) return node->data;
return sumOfLeafNodes(node->left) + sumOfLeafNodes(node->right);
}

void printLevel(Node* node, int k) {


if (!node) return;
if (k == 0) {
cout << node->data << " ";
return;
}
printLevel(node->left, k - 1);
printLevel(node->right, k - 1);
}

Node* deleteLevel(Node* node, int k) {


if (!node) return nullptr;
if (k == 0) {
delete node;
return nullptr;
}
node->left = deleteLevel(node->left, k - 1);
node->right = deleteLevel(node->right, k - 1);
return node;
}
};

int main() {
BST tree;
tree.root = tree.insert(tree.root, 50);
tree.insert(tree.root, 30);
tree.insert(tree.root, 70);
tree.insert(tree.root, 20);
tree.insert(tree.root, 40);
tree.insert(tree.root, 60);
tree.insert(tree.root, 80);

cout << "Inorder traversal: ";


tree.inorder(tree.root);
cout << endl;

cout << "Deleting 50...\n";


tree.root = tree.deleteNode(tree.root, 50);
cout << "Inorder traversal after deletion: ";
tree.inorder(tree.root);
cout << endl;

cout << "Sum of leaf nodes: " << tree.sumOfLeafNodes(tree.root) << endl;

int k = 2;
cout << "Nodes at level " << k << ": ";
tree.printLevel(tree.root, k);
cout << endl;

tree.root = tree.deleteLevel(tree.root, k);


cout << "Inorder traversal after deleting level " << k << ": ";
tree.inorder(tree.root);
cout << endl;
system("pause");
return 0;
}
Q#04
#include <iostream>
using namespace std;

struct Node {
int data;
Node* left;
Node* right;
Node(int val) : data(val), left(nullptr), right(nullptr) {}
};

class BST {
public:
Node* root;
BST() : root(nullptr) {}

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


if (!node) return new Node(key);
if (key < node->data)
node->left = insert(node->left, key);
else if (key > node->data)
node->right = insert(node->right, key);
return node;
}

Node* find(Node* node, int key) {


if (!node || node->data == key) return node;
if (key < node->data) return find(node->left, key);
return find(node->right, key);
}

Node* findMin(Node* node) {


if (!node || !node->left) return node;
return findMin(node->left);
}

Node* deleteNode(Node* node, int key) {


if (!node) return nullptr;
if (key < node->data)
node->left = deleteNode(node->left, key);
else if (key > node->data)
node->right = deleteNode(node->right, key);
else {
if (!node->left) {
Node* temp = node->right;
delete node;
return temp;
}
else if (!node->right) {
Node* temp = node->left;
delete node;
return temp;
}
Node* temp = findMin(node->right);
node->data = temp->data;
node->right = deleteNode(node->right, temp->data);
}
return node;
}

void inorder(Node* node) {


if (!node) return;
inorder(node->left);
cout << node->data << " ";
inorder(node->right);
}

int sumOfLeafNodes(Node* node) {


if (!node) return 0;
if (!node->left && !node->right) return node->data;
return sumOfLeafNodes(node->left) + sumOfLeafNodes(node->right);
}

void printLevel(Node* node, int k) {


if (!node) return;
if (k == 0) {
cout << node->data << " ";
return;
}
printLevel(node->left, k - 1);
printLevel(node->right, k - 1);
}

Node* deleteLevel(Node* node, int k) {


if (!node) return nullptr;
if (k == 0) {
delete node;
return nullptr;
}
node->left = deleteLevel(node->left, k - 1);
node->right = deleteLevel(node->right, k - 1);
return node;
}

int closestValue(Node* node, int key) {


if (!node) return -1;
int closest = node->data;
while (node) {
if (abs(node->data - key) < abs(closest - key))
closest = node->data;
if (key < node->data)
node = node->left;
else if (key > node->data)
node = node->right;
else
break;
}
return closest;
}
};

int main() {
BST tree;
tree.root = tree.insert(tree.root, 50);
tree.insert(tree.root, 30);
tree.insert(tree.root, 70);
tree.insert(tree.root, 20);
tree.insert(tree.root, 40);
tree.insert(tree.root, 60);
tree.insert(tree.root, 80);

cout << "Inorder traversal: ";


tree.inorder(tree.root);
cout << endl;

cout << "Deleting 50...\n";


tree.root = tree.deleteNode(tree.root, 50);
cout << "Inorder traversal after deletion: ";
tree.inorder(tree.root);
cout << endl;

cout << "Sum of leaf nodes: " << tree.sumOfLeafNodes(tree.root) << endl;

int k = 2;
cout << "Nodes at level " << k << ": ";
tree.printLevel(tree.root, k);
cout << endl;

tree.root = tree.deleteLevel(tree.root, k);


cout << "Inorder traversal after deleting level " << k << ": ";
tree.inorder(tree.root);
cout << endl;

int key = 65;


cout << "Closest value to " << key << ": " << tree.closestValue(tree.root, key) << endl;
system("pause");
return 0;
}
Q#05
#include <iostream>
using namespace std;

struct Node {
int data;
Node* left;
Node* right;
Node(int val) : data(val), left(nullptr), right(nullptr) {}
};

class BST {
public:
Node* root;
BST() : root(nullptr) {}

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


if (!node) return new Node(key);
if (key < node->data)
node->left = insert(node->left, key);
else if (key > node->data)
node->right = insert(node->right, key);
return node;
}

Node* find(Node* node, int key) {


if (!node || node->data == key) return node;
if (key < node->data) return find(node->left, key);
return find(node->right, key);
}

Node* findMin(Node* node) {


if (!node || !node->left) return node;
return findMin(node->left);
}

Node* deleteNode(Node* node, int key) {


if (!node) return nullptr;
if (key < node->data)
node->left = deleteNode(node->left, key);
else if (key > node->data)
node->right = deleteNode(node->right, key);
else {
if (!node->left) {
Node* temp = node->right;
delete node;
return temp;
}
else if (!node->right) {
Node* temp = node->left;
delete node;
return temp;
}
Node* temp = findMin(node->right);
node->data = temp->data;
node->right = deleteNode(node->right, temp->data);
}
return node;
}

void inorder(Node* node) {


if (!node) return;
inorder(node->left);
cout << node->data << " ";
inorder(node->right);
}

int sumOfLeafNodes(Node* node) {


if (!node) return 0;
if (!node->left && !node->right) return node->data;
return sumOfLeafNodes(node->left) + sumOfLeafNodes(node->right);
}

void printLevel(Node* node, int k) {


if (!node) return;
if (k == 0) {
cout << node->data << " ";
return;
}
printLevel(node->left, k - 1);
printLevel(node->right, k - 1);
}

Node* deleteLevel(Node* node, int k) {


if (!node) return nullptr;
if (k == 0) {
delete node;
return nullptr;
}
node->left = deleteLevel(node->left, k - 1);
node->right = deleteLevel(node->right, k - 1);
return node;
}

int closestValue(Node* node, int key) {


if (!node) return -1;
int closest = node->data;
while (node) {
if (abs(node->data - key) < abs(closest - key))
closest = node->data;
if (key < node->data)
node = node->left;
else if (key > node->data)
node = node->right;
else
break;
}
return closest;
}

bool isIdentical(Node* root1, Node* root2) {


if (!root1 && !root2) return true;
if (!root1 || !root2) return false;
return (root1->data == root2->data) &&
isIdentical(root1->left, root2->left) &&
isIdentical(root1->right, root2->right);
}
};

int main() {
BST tree;
tree.root = tree.insert(tree.root, 50);
tree.insert(tree.root, 30);
tree.insert(tree.root, 70);
tree.insert(tree.root, 20);
tree.insert(tree.root, 40);
tree.insert(tree.root, 60);
tree.insert(tree.root, 80);

cout << "Inorder traversal: ";


tree.inorder(tree.root);
cout << endl;

cout << "Deleting 50...\n";


tree.root = tree.deleteNode(tree.root, 50);
cout << "Inorder traversal after deletion: ";
tree.inorder(tree.root);
cout << endl;

cout << "Sum of leaf nodes: " << tree.sumOfLeafNodes(tree.root) << endl;

int k = 2;
cout << "Nodes at level " << k << ": ";
tree.printLevel(tree.root, k);
cout << endl;

tree.root = tree.deleteLevel(tree.root, k);


cout << "Inorder traversal after deleting level " << k << ": ";
tree.inorder(tree.root);
cout << endl;

int key = 65;


cout << "Closest value to " << key << ": " << tree.closestValue(tree.root, key) << endl;

BST tree2;
tree2.root = tree2.insert(tree2.root, 50);
tree2.insert(tree2.root, 30);
tree2.insert(tree2.root, 70);
tree2.insert(tree2.root, 20);
tree2.insert(tree2.root, 40);
tree2.insert(tree2.root, 60);
tree2.insert(tree2.root, 80);

cout << "Trees are " << (tree.isIdentical(tree.root, tree2.root) ? "identical" : "not identical")
<< endl;
system("pause");
return 0;
}

Q#06
#include <iostream>
using namespace std;

struct Node {
int data;
Node* children[3];
Node(int val) : data(val) {
children[0] = children[1] = children[2] = nullptr;
}
};

class EvolutionaryTree {
public:
Node* root;
EvolutionaryTree(int rootVal, int maxHeight) {
root = generateTree(rootVal, maxHeight);
}

Node* generateTree(int val, int height) {


if (height == 0) return nullptr;
Node* node = new Node(val);
int numChildren = val % 4;
if (numChildren >= 1) node->children[0] = generateTree(val + 1, height - 1);
if (numChildren >= 2) node->children[1] = generateTree(val + 3, height - 1);
if (numChildren == 3) node->children[2] = generateTree(val + 4, height - 1);
return node;
}

bool search(Node* node, int key) {


if (!node) return false;
if (node->data == key) return true;
for (int i = 0; i < 3; i++) {
if (search(node->children[i], key)) return true;
}
return false;
}
};

int main() {
int rootVal, maxHeight, searchKey;
cout << "Enter root node value: ";
cin >> rootVal;
cout << "Enter maximum height: ";
cin >> maxHeight;
cout << "Enter search key: ";
cin >> searchKey;

EvolutionaryTree tree(rootVal, maxHeight);


cout << (tree.search(tree.root, searchKey) ? "True" : "False") << endl;

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

struct Node {
int data;
Node* children[3];
Node(int val) : data(val) {
children[0] = children[1] = children[2] = nullptr;
}
};

class EvolutionaryTree {
public:
Node* root;
EvolutionaryTree(int rootVal, int maxHeight) {
root = generateTree(rootVal, maxHeight);
}

Node* generateTree(int val, int height) {


if (height == 0) return nullptr;
Node* node = new Node(val);
int numChildren = val % 4;
if (numChildren >= 1) node->children[0] = generateTree(val + 1, height - 1);
if (numChildren >= 2) node->children[1] = generateTree(val + 3, height - 1);
if (numChildren == 3) node->children[2] = generateTree(val + 4, height - 1);
return node;
}

bool search(Node* node, int key) {


if (!node) return false;
if (node->data == key) return true;
for (int i = 0; i < 3; i++) {
if (search(node->children[i], key)) return true;
}
return false;
}

void deleteDescendants(Node* node) {


if (!node) return;
for (int i = 0; i < 3; i++) {
deleteDescendants(node->children[i]);
delete node->children[i];
node->children[i] = nullptr;
}
}

void deleteDescendantsOfKey(Node* node, int key) {


if (!node) return;
if (node->data == key) {
deleteDescendants(node);
return;
}
for (int i = 0; i < 3; i++) {
deleteDescendantsOfKey(node->children[i], key);
}
}
};

int main() {
int rootVal, maxHeight, searchKey;
cout << "Enter root node value: ";
cin >> rootVal;
cout << "Enter maximum height: ";
cin >> maxHeight;
cout << "Enter search key: ";
cin >> searchKey;

EvolutionaryTree tree(rootVal, maxHeight);


cout << (tree.search(tree.root, searchKey) ? "True" : "False") << endl;

int deleteKey;
cout << "Enter node value to delete descendants: ";
cin >> deleteKey;
tree.deleteDescendantsOfKey(tree.root, deleteKey);
system("pause");
return 0;
}

You might also like