Name- Soham Kawadkar Div: SY-9 Roll no.

- 22230143 A

ASSIGNMENT 4 ADSL
a) Create an in-order single threaded binary search tree and perform the
traversals.
CODE:
#include <iostream>
using namespace std;

struct Node {
int data;
Node* left;
Node* right;
bool isThreaded;

Node(int val) {
data = val;
left = right = nullptr;
isThreaded = false;
}
};

void insert(Node*& root, int key) {

Node* newNode = new Node(key);
if (root == nullptr) {
root = newNode;
return;
}

Node* current = root;

Node* parent = nullptr;
while (current != nullptr) {
parent = current;
if (key < current->data) {
if (!current->isThreaded)
current = current->left;
else
break;
} else {
if (current->isThreaded)
break;
Name- Soham Kawadkar Div: SY-9 Roll no.- 22230143 A

current = current->right;
}
}

if (key < parent->data) {

newNode->left = parent->left;
newNode->right = parent;
parent->left = newNode;
parent->isThreaded = true;
} else {
newNode->right = parent->right;
parent->right = newNode;
parent->isThreaded = false;
}
}

void inOrderTraversal(Node* root) {

Node* current = leftMost(root);
while (current != nullptr) {
cout << current->data << " ";
if (current->isThreaded)
current = current->right;
else
current = leftMost(current->right);
}
}

Node* leftMost(Node* node) {

if (node == nullptr)
return nullptr;
while (node->left != nullptr)
node = node->left;
return node;
}

int main() {
Node* root = nullptr;
insert(root, 50);
insert(root, 30);
insert(root, 20);
Name- Soham Kawadkar Div: SY-9 Roll no.- 22230143 A

insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);

cout << "In-order traversal of single-threaded BST: ";

inOrderTraversal(root);
cout << endl;

return 0;
}

OUTPUT:

b) Create an in-order Double threaded binary search tree and perform the
traversals.
CODE:
#include <iostream>
using namespace std;

struct Node {
int data;
Node* left;
Node* right;
Node* leftThread;
Node* rightThread;
};

Node* createNode(int data) {

Node* newNode = new Node;
newNode->data = data;
newNode->left = nullptr;
Name- Soham Kawadkar Div: SY-9 Roll no.- 22230143 A

newNode->right = nullptr;
newNode->leftThread = nullptr;
newNode->rightThread = nullptr;
return newNode;
}

Node* insert(Node* root, int data) {

if (root == nullptr)
return createNode(data);
if (data < root->data) {
if (root->leftThread)
root->leftThread = insert(root->leftThread, data);
else {
root->leftThread = insert(root->left, data);
root->leftThread->rightThread = root;
}
} else {
if (root->rightThread)
root->rightThread = insert(root->rightThread, data);
else {
root->rightThread = insert(root->right, data);
root->rightThread->leftThread = root;
}
}
return root;
}

Node* leftMost(Node* node) {

if (node == nullptr)
return nullptr;
while (node->left != nullptr && !node->leftThread)
node = node->left;
return node;
}

void inOrder(Node* root) {

Node* current = leftMost(root);
while (current != nullptr) {
cout << current->data << " ";
if (current->rightThread)
Name- Soham Kawadkar Div: SY-9 Roll no.- 22230143 A

current = current->rightThread;
else
current = leftMost(current->right);
}
}

int main() {
Node* root = nullptr;
root = insert(root, 5);
insert(root, 3);
insert(root, 7);
insert(root, 2);
insert(root, 4);
insert(root, 6);
insert(root, 8);

cout << "In-order traversal of double-threaded BST: ";

inOrder(root);
cout << endl;

return 0;
}

OUTPUT:
Name- Soham Kawadkar Div: SY-9 Roll no.- 22230143 A

c) Create a threaded binary search tree with insert, search and delete leaf node
operations.
CODE:
#include <iostream>
using namespace std;

struct Node {
int data;
Node* left;
Node* right;
bool leftThread;
bool rightThread;
};

Node* createNode(int data) {

Node* newNode = new Node;
newNode->data = data;
newNode->left = nullptr;
newNode->right = nullptr;
newNode->leftThread = false;
newNode->rightThread = false;
return newNode;
}

Node* insert(Node* root, int data) {

if (root == nullptr)
return createNode(data);
if (data < root->data) {
if (root->leftThread)
root->leftThread = false;
root->left = insert(root->left, data);
root->left->right = root;
root->left->rightThread = true;
} else {
if (root->rightThread)
root->rightThread = false;
root->right = insert(root->right, data);
root->right->right = root->right->rightThread ? root : nullptr;
root->right->rightThread = true;
}
Name- Soham Kawadkar Div: SY-9 Roll no.- 22230143 A

return root;
}

Node* search(Node* root, int data) {

while (root != nullptr) {
if (data < root->data) {
if (!root->leftThread)
root = root->left;
else
return nullptr;
} else if (data > root->data) {
if (!root->rightThread)
root = root->right;
else
return nullptr;
} else {
return root;
}
}
return nullptr;
}

Node* deleteLeaf(Node* root, int data) {

Node* nodeToDelete = search(root, data);
if (nodeToDelete == nullptr || nodeToDelete->left != nullptr || nodeToDelete-
>right != nullptr)
return root;

Node* parent = nullptr;

Node* current = root;
while (current != nullptr && current != nodeToDelete) {
parent = current;
if (data < current->data) {
if (!current->leftThread)
current = current->left;
else
current = nullptr;
} else {
if (!current->rightThread)
current = current->right;
Name- Soham Kawadkar Div: SY-9 Roll no.- 22230143 A

else
current = nullptr;
}
}

if (parent != nullptr) {
if (parent->left == nodeToDelete) {
parent->left = nodeToDelete->left;
parent->leftThread = true;
if (nodeToDelete->rightThread)
parent->left->right = parent;
} else {
parent->right = nodeToDelete->right;
parent->rightThread = true;
if (nodeToDelete->leftThread)
parent->right->left = parent;
}
} else {
root = nullptr;
}

delete nodeToDelete;
return root;
}

Node* leftMost(Node* node) {

if (node == nullptr)
return nullptr;
while (node->left != nullptr && !node->leftThread)
node = node->left;
return node;
}

void inOrder(Node* root) {

Node* current = leftMost(root);
while (current != nullptr) {
cout << current->data << " ";
if (current->rightThread)
current = current->right;
else
Name- Soham Kawadkar Div: SY-9 Roll no.- 22230143 A

current = leftMost(current->right);
}
}

int main() {
Node* root = nullptr;
root = insert(root, 5);
insert(root, 3);
insert(root, 7);
insert(root, 2);
insert(root, 4);
insert(root, 6);
insert(root, 8);

cout << "In-order traversal of threaded BST: ";

inOrder(root);
cout << endl;

root = deleteLeaf(root, 2);

root = deleteLeaf(root, 8);

cout << "In-order traversal after deleting nodes: ";

inOrder(root);
cout << endl;

return 0;
}
OUTPUT:
Name- Soham Kawadkar Div: SY-9 Roll no.- 22230143 A

FAQs
Name- Soham Kawadkar Div: SY-9 Roll no.- 22230143 A
Name- Soham Kawadkar Div: SY-9 Roll no.- 22230143 A