Assignment: DSA Group Task

Binary Search Tree (traversals, insert, delete, search, min and max
value functions)

Submitted to: Prof. Saleem

Submitted By:
o 101- Muhammad Aqib Irshad (Traversals and Search
Function)
o 103- Muhammad Sanan Saleem (Delete Function)
o 99- Muhammad Kaleem (creating tree and Insertion
Function)
o 98- Muhammad Nihal Butt (Max and Min Function)
BSCS- C
Semester-III
Roll#101
Department of Computer Science
Minhaj University Lahore
 Binary Search Tree

#include <iostream>
#include<cmath>
using namespace std;

int noOfNodes = 0;

struct BTree {
int data;
BTree *left;
BTree *right;
};

BTree* createTree(int item);

void preOrder(BTree * root);
void inOrder(BTree * root);
void postOrder(BTree * root);
int search(int dataItem, BTree * root);
BTree* insert(BTree * root, int dataItem);
BTree* deleteNode(BTree* root, int dataItem);
BTree* minValue(BTree* root);
BTree* maxValue(BTree* root);
int main()
{
int data;
BTree * r = NULL;

r = insert(r, 10);
r = insert(r, 20);
r = insert(r, 5);
r = insert(r, 30);
r = insert(r, 15);
r = insert(r, 40);
r = insert(r, 2);

inOrder(r);
data = search(10,r);
cout << endl;
cout << data;
r = deleteNode(r, 30);
cout << endl;
inOrder(r);

r = maxValue(r);
cout << endl;
cout << r->data;
}

BTree* createTree(int item)

{
noOfNodes++;
struct BTree *temp = (struct BTree *)malloc(sizeof(struct BTree));
temp->data = item;
temp->left = temp->right = NULL;
return temp;
}
BTree* minValue(BTree* root)
{
BTree* cur = root;
while (cur->left)
cur = cur->left;

return cur;
}

BTree* maxValue(BTree* root)

{
BTree* cur = root;
while (cur->right)
cur = cur->right;
return cur;
}
//InSertion

BTree* insert(BTree * root, int dataItem)

// root = new BTree;

if(root==NULL)
{

return createTree(dataItem);
}
if(dataItem < root->data)
{

root->left = insert(root->left, dataItem);

}
else
{

root->right = insert(root->right, dataItem);

}
 return root;

//Traversal Methods

void preOrder(BTree * root)

{
if(root == NULL)
{
return;
}
else{
cout << root->data;
preOrder(root->left);
preOrder(root->right);
}

void postOrder(BTree * root)

{
if(root == NULL)
{
return;
 }
else
{
postOrder(root->left);
postOrder(root->right);
cout << root->data;
}

void inOrder(BTree * root)

{
if(root == NULL)
{
return;
}
else
{
inOrder(root->left);
cout << root->data << endl;
inOrder(root->right);
}

}
int search(int dataItem, BTree * root)
{

if(root->data == dataItem){

return root->data;
}
else if(dataItem < root->data)
{

return search(dataItem, root->left);

}
else
{

return search(dataItem, root->right);

}

BTree* deleteNode(BTree* root, int dataItem){

if(root == NULL)
 return root;
if (dataItem < root->data)
{
root->left = deleteNode(root->left, dataItem);
}

else if (dataItem > root->data)

{
root->right = deleteNode(root->right, dataItem);
}

else{
if(root->left == NULL && root->right == NULL)
{
return NULL;
}
else if (root->left == NULL){
BTree *temp = root->right;
delete root;
return temp;
}
else if (root->right == NULL){
BTree *temp = root->left;
delete root;
return temp;
}
 BTree* temp = minValue(root->right);
root->data = temp->data;
root->right = deleteNode(root->right, temp->data);
}
return root;
}

THE END