Scribd
Upload
165 views20 pages

(Prog 5)

Uploaded by

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

(Prog 5)

Uploaded by

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

Name – Uddeshya

Roll No- 11813012

Section- IT-1

Part 3
Program 1:
1) Construction of Binary tree and insertion of new node
in binary tree.

Code-
#include <iostream>
using namespace std;

class BST
{ int data; BST
*left, *right;

public:

BST();

BST(int);
BST* Insert(BST*, int);

void Inorder(BST*);
};

BST ::BST()
: data(0)
, left(NULL)
, right(NULL)
{
}

BST ::BST(int value)


{ data = value;
left = right = NULL;
}

BST* BST ::Insert(BST* root, int value)


{ if
(!root) {
return new BST(value);
}

if (value > root->data)


{

root->right = Insert(root->right, value);


}
else
{

root->left = Insert(root->left, value);


}

return root;
}

void BST ::Inorder(BST* root)


{ if (!root)
{
return;
}
Inorder(root->left); cout
<< root->data << endl;
Inorder(root->right);
}

int main()
{
BST b, *root = NULL;
root = b.Insert(root, 40);
b.Insert(root, 30);
b.Insert(root, 20);
b.Insert(root, 50);
b.Insert(root, 70);
b.Insert(root, 60);
b.Insert(root, 10);
b.Insert(root, 15);

b.Inorder(root);
return 0; }

OUTPUT
2)
Find the no of nodes in the longest path

Code-

#include <bits/stdc++.h>

using namespace std;

struct Node {
int data;
Node* left, *right;
};
Node* getNode(int data)
{

Node* newNode = (Node*)malloc(sizeof(Node));

newNode->data = data; newNode->left


= newNode->right = NULL; return
newNode;
}

void sumOfLongRootToLeafPath(Node* root, int sum,


int len, int& maxLen, int& maxSum)
{

if (!root) {

if (maxLen < len) {


maxLen = len;
maxSum = sum;
} else if (maxLen == len && maxSum < sum)
maxSum = sum; return;

}
sumOfLongRootToLeafPath(root->left, sum + root->data,
len + 1, maxLen, maxSum);

sumOfLongRootToLeafPath(root->right, sum + root->data,


len + 1, maxLen, maxSum);
}

int sumOfLongRootToLeafPathUtil(Node* root)


{

if (!root)
return 0;

int maxSum = INT_MIN, maxLen = 0;

sumOfLongRootToLeafPath(root, 0, 0, maxLen, maxSum);

return maxLen;
}
int main()
{
Node* root = getNode(4); root-
>left = getNode(2); root->right =
getNode(5); root->left->left =
getNode(7); root->left->right =
getNode(1); root->right->left =
getNode(2); root->right->right =
getNode(3); root->left->right->left =
getNode(6);

cout << "No of nodes in the longest path = "


<< sumOfLongRootToLeafPathUtil(root);

return 0;
}

OUTPUT
3)
Minimum data value found in the tree.
Code-
#include <bits/stdc++.h>
using namespace std;

struct node
{ int data; struct
node* left; struct
node* right;
};
struct node* newNode(int data)
{
struct node* node = (struct node*)
malloc(sizeof(struct node));
node->data = data; node->left = NULL;
node->right = NULL;

return(node);
}

struct node* insert(struct node* node, int data)


{
if (node == NULL)
return(newNode(data)); else
{

if (data <= node->data) node->left


= insert(node->left, data); else
node->right = insert(node->right, data); return node;
}
}

int minValue(struct node* node)


{
struct node* current = node;

while (current->left != NULL)


{ current = current-
>left;
}
return(current->data);
}

int main()
{
struct node* root = NULL;
root = insert(root, 14);
insert(root, 21);
insert(root, 16);
insert(root, 31);
insert(root, 60);
insert(root, 52);

cout << "\n Minimum value in BST is " << minValue(root);

return 0;
}

OUTPUT

4) Search a given value in bst


Code-
#include <iostream>
using namespace std;

struct Node
{ int
data;
Node *left, *right;
};

Node* newNode(int key)


{
Node* node = new Node; node-
>data = key; node->left = node-
>right = nullptr;

return node;
}

Node* insert(Node* root, int key)


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

if (key < root->data) { root->left


= insert(root->left, key); }

else {
root->right = insert(root->right, key);
}

return root;
}

void searchIterative(Node* root, int key)


{

Node* curr = root;

Node* parent = nullptr;


while (curr != nullptr && curr->data != key)
{

parent = curr;

if (key < curr->data) {


curr = curr->left;
}
else {
curr = curr->right;
}
}

if (curr == nullptr)
{
cout << "Key Not found";
return;
}

if (parent == nullptr) {
cout << "The node with key " << key << " is root node";
}
else if (key < parent->data) {
cout << "The given key is the left node of the node with key "
<< parent->data;
}
else {
cout << "The given key is the right node of the node with key "
<< parent->data;
}
}

int main()
{
int keys[] = { 15, 10, 20, 8, 12, 16, 25 };

Node* root = nullptr;


for (int key: keys) {
root = insert(root, key);
}

searchIterative(root, 25);

return 0;
}

OUTPUT
5) Change a tree so that the roles of the left and right
pointers are swapped at every node
Code-
#include<bits/stdc++.h>
using namespace std;

struct Node
{ int data; struct
Node* left; struct
Node* right;
};
struct Node* newNode(int data)
{
struct Node* node = (struct Node*)
malloc(sizeof(struct Node));
node->data = data; node->left = NULL;
node->right = NULL;

return(node);
}

void mirror(struct Node* node)


{ if (node ==
NULL) return;
else
{
struct Node* temp;

mirror(node->left); mirror(node-
>right); temp = node->left;
node->left = node->right; node->right =
temp;
}
}
void inOrder(struct Node* node)
{ if (node ==
NULL) return;

inOrder(node->left);
cout << node->data << " ";
inOrder(node->right);
}

int main()
{
struct Node *root = newNode(1);
root->left = newNode(2); root-
>right = newNode(3); root->left-
>left = newNode(4); root->left-
>right = newNode(5); cout <<
"Inorder traversal of the constructed"

<< " tree is" << endl;


inOrder(root);

mirror(root);
cout << "\n Inorder traversal of the mirror tree"
<< " is \n";
inOrder(root);

return 0;
}

OUTPUT

You might also like