PROGRAM 4

AIM: WAP to perform push and pop operations on a stack

implemented using linked list.

THEORY: The other way of implementing the stack is by using linked

list. Push operation is implemented by inserting element at the
beginning of linked list. Pop operation is implemented by deleting
the node from the beginning of the linked list.

ALGORITHM:

a. Push:
1. Initialise the data of temp node with given data.
2. Assign the next of temp node with top.
3. Assign top with temp top.
b. Pop:
1. Check if stack is empty.
2. If yes return -1.
3. Else initialise temp node with top.
4. *top=*top->next;
5. Initialise data with temp->data.
6. Release temp from memory.
7. Return data.

CODE:

#include<iostream>

#include<stdlib.h>

using namespace std;

struct node
{

int data;

struct node* next;

};

struct node* Createstack()

return NULL;

int Isempty(struct node* top)

return top==NULL;

void push(struct node**top,int d)

struct node* temp=(struct node*)malloc(sizeof(struct node));

temp->data=d;

temp->next=*top;

*top=temp;

int pop(struct node**top)

{

int d;

struct node* temp;

if(Isempty(top))

return -1;

temp=*top;

*top=(*top)->next;

d=temp->data;

free(temp);

return d;

int main()

struct node* top=Createstack();

cout<<"Enter the data you want to put in stack\nPress -1 to stop

providing the input\n";

int d;

cin>>d;

while(d!=-1)

push(&top,d);
 cin>>d;

cout<<"After performing pop operation on the stack"<<endl;

while(!Isempty(top))

cout<<pop(&top)<<" ";

return 0;

OUTPUT:

DISCUSSION:

Every operation takes O(1) constant time.

Every operation takes extra space and time to deal with references.

LEARNING:
I learnt that implementation of stack using linked list has extra space
complexity but it is done by dynamic memory allocation which
prevents any waste of memory whatsoever. I also learnt that all the
operations in this implementation take constant time.
 PROGRAM 5
AIM: WAP to perform push and pop operations on a stack
implemented using array .

THEORY: Array implementation of stack using stack ADT uses an

array. In the array, we add elements from left to right and use a
variable to keep track of the index of top element. The array storing
elements may become full. A push operation will then throw a full
stack exception. Similarly if we try deleting an element from an
empty stack it will throw stack empty exception.

ALGORITHM:

a. Push operation
1. Check if stack is full.
2. If yes, print stack overflow.
3. Else increase top by 1 and store the value at top position.

b. Pop operation
1. Check if stack is empty.
2. if yes, print stack underflow.
3. Else remove element from the top of array and reduce top
by 1 .

CODE:

#include<iostream>

#include<stdlib.h>

using namespace std;

struct arraystack
{

int top;

int capacity;

int *arr;

};

struct arraystack* Createstack()

struct arraystack* s=(struct arraystack*)malloc(sizeof(struct

arraystack));

if(!s)

return NULL;

s->capacity=10;

s->top=-1;

s->arr=(int* )malloc((s->capacity*sizeof(int)));

return s;

};

int Isfull(struct arraystack*s)

return (s->top==s->capacity-1);

int Isempty(struct arraystack* s)

{
 return (s->top==-1);

void push(struct arraystack*s,int d)

if(Isfull(s))

cout<<"Stack overflow\n";

else

s->arr[++s->top]=d;

int pop(struct arraystack*s)

if(Isempty(s))

cout<<"stack is empty\n";

else

return (s->arr[s->top--]);

int main()
{

struct arraystack* s=Createstack();

int d;

cout<<"Enter the elements to push.\nIn order to stop giving the

input press -1\n";

cin>>d;

int i=1;

while(d!=-1&&i<=10)

push(s,d);

cin>>d;

cout<<endl<<"The value of top index is:"<<s->top<<endl;

cout<<"After performing pop on the stack\n";

i=1;

while(i<=11&&!Isempty(s))

cout<<pop(s)<<" ";

i++;

return 0;

}
OUTPUT:

DISCUSSION:

In this program we created a stack with array implementation. We

performed push and pop on the same.

LEARNING OUTCOME:

Here in this program I learned to perform push, pop, Isempty, Isfull

operations on stack. It improved my understanding of stack data
structure.
 PROGRAM 7

AIM: Write a Program to implement a queue using array and

perform basic queue operations.

THEORY:
is also an abstract data type or a linear data structure, in which the
first element is inserted from one end called the rear(also called tail),
and the removal of existing element takes place from the other end
called as front(also called head).
This makes queue as FIFO(First in First Out) data structure, which
means that element inserted first will be removed first.
The process to add an element into queue is called enqueue and the
process of removal of an element from queue is called dequeue.

ALGORITHM:

Enqueue Operation

 Step 1 − Check if the queue is full.

 Step 2 − If the queue is full, produce overflow error and exit.
 Step 3 − If the queue is not full, increment rear pointer to point
the next empty space.
 Step 4 − Add data element to the queue location, where the rear
is pointing.
  Step 5 − return success.
Dequeue Operation
 Step 1 − Check if the queue is empty.
 Step 2 − If the queue is empty, produce underflow error and
exit.
 Step 3 − If the queue is not empty, access the data
where front is pointing.
 Step 4 − Increment front pointer to point to the next available
data element.
 Step 5 − Return success.

CODE:
#include <iostream>
using namespace std;
int queue[100], n = 100, front = - 1, rear = - 1;
void Insert() {
int val;
if (rear == n - 1)
cout<<"Queue Overflow"<<endl;
else {
if (front == - 1)
front = 0;
cout<<"Insert the element in queue : "<<endl;
cin>>val;
rear++;
 queue[rear] = val;
}
}
void Delete() {
if (front == - 1 || front > rear) {
cout<<"Queue Underflow ";
return ;
} else {
cout<<"Element deleted from queue is : "<< queue[front] <<endl;
front++;;
}
}
void Display() {
if (front == - 1)
cout<<"Queue is empty"<<endl;
else {
cout<<"Queue elements are : ";
for (int i = front; i <= rear; i++)
cout<<queue[i]<<" ";
cout<<endl;
}
}
int main() {
int ch;
cout<<"1) Insert element to queue"<<endl;
cout<<"2) Delete element from queue"<<endl;
 cout<<"3) Display all the elements of queue"<<endl;
cout<<"4) Exit"<<endl;
do {
cout<<"Enter your choice : "<<endl;
cin<<ch;
switch (ch) {
case 1: Insert();
break;
case 2: Delete();
break;
case 3: Display();
break;
case 4: cout<<"Exit"<<endl;
break;
default: cout<<"Invalid choice"<<endl;
}
} while(ch!=4);
return 0;
}

OUTPUT:
DISCUSSION:
In queue, insertion and deletion happen at the opposite ends, so
implementation is not as simple as stack.
From the above program we can conclude that-
Time Complexity of Enqueue : O(1)
Time Complexity of Dequeue : O(n)

LEARNING OUTCOMES:
Students learned to create a Queue using Array. Students also learned
about the various functions like Enqueue(), Dequeue(), Front() and
Rear() that are used in queue.
 PROGRAM 12
AIM: WAP to implement insertion, searching, deletion and traversal
algorithm on Binary search tree.

THEORY: In binary search tree all the left subtree elements should be
less than root data and all the right subtree elements should be
smaller than data. This is called binary search tree property. Note
that this property should be satisfied at every node in the tree.

Since root data is always between left subtree data and right subtree
data performing inorder traversal on binary search tree produces a
sorted list. If we are searching for an element and if left subtree data
is less than the element we want to search then skip it. Same is the
case with right subtree. In other words the binary seach tree
considers either the left or right subtree to search an element but
not both.

ALGORITHM:

a. Insertion:
1. If root == NULL create new node and return the same.
2. If root->data>=d
i. root->left=Insertion(root->left,d)
3. else root->right=Insertion(root->right,d)
b. deletion:
1. If root==NULL return NULL
2. if d<root->data
i. call deletinbst(root->left,d)
ii. return root

3. else if (d==root->d)

i. if (it has no left or right children)

 -delete root

-return NULL

ii. if (it has left child but no right child)

-node* temp=root->right

- delete root

- return temp

iii. if(it has no right child but right chid)

-node* temp=root->right

- delete root

- return temp

iv. if(it has both left and right child)

-traverse using a temporary node to the leftmost

child and then

root->data=rep->data;

root->right=deleteinbst(root->right,rep->data);

return root;

4. else

root->right=deleteinbst(root->right,d);

return root;

c. searching:
1.if(root is NULL)
 return false;

2. if(root->data==key)

return true;

3.else if(key<=root->data)

return searchh(root->left,key);

4. else return searchh(root->right,key);

d. traversal:

(inorder)

1. traverse the right subtree in order

2. visit the root

3. traverse the right subtree in order.

CODE:

#include<iostream>

using namespace std;

/*5 3 7 1 6 8 -1*/

class node

public:

int data;

node* left;

node* right;
 node(int d)

data=d;

left=right=NULL;

};

void printin(node* root)

if(!root)

return;

printin(root->left);

cout<<root->data<<",";

printin(root->right);

node* insertbst(node* root,int d)

if(!root)

return new node(d);

if(root->data>=d)
 root->left=insertbst(root->left,d);

else

root->right=insertbst(root->right,d);

node* build()

int d;

cin>>d;

node* root=NULL;

while(d!=-1)

root=insertbst(root,d);

cin>>d;

return root;

bool searchh(node* root,int key)

if(!root)
 return false;

if(root->data==key)

return true;

if(key<=root->data)

return searchh(root->left,key);

return searchh(root->right,key);

node* deleteinbst(node* root,int d)

if(!root)

return NULL;

if(d<root->data)

root->left=deleteinbst(root->left,d);

return root;

else if(root->data==d)

if(root->left==NULL&&root->right==NULL)
{

delete root;

return NULL;

if(root->left==NULL&&root->right!=NULL)

node* temp=root->right;

delete root;

return temp;

if(root->left!=NULL&&root->right==NULL)

node* temp=root->left;

delete root;

return temp;

node* rep=root->right;

while(rep->left!=NULL)

rep=rep->left;

}
 root->data=rep->data;

root->right=deleteinbst(root->right,rep->data);

return root;

else

root->right=deleteinbst(root->right,d);

return root;

int main()

cout<<"Enter the elements in the binary search tree.\nPress -1 if

current node is NULL."<<endl;

node* root=build();

cout<<"\nThe inorder traversal of BST gives following order:\n";

printin(root);

cout<<"\nEnter the element you want to search\n";

int d;

cin>>d;

if(searchh(root,d))

{
 cout<<"\npresent\n";

else{

cout<<"\nabsent\n";

cout<<"Enter the element you want to delete\n";

cin>>d;

root=deleteinbst(root,d);

cout<<"The inorder traversal of tree after deletion of "<<d<<" is:

\n"<<endl;

printin(root);

return 0;

OUTPUT:
 DISCUSSION:

As we can clearly see from the output figure the inorder traversal
of a binary search tree is always sorted.

LEARNING:

The time complexity of inorder traversal is O(n).

Its space complexity is also O(n).

The basic operations on binary search tree take time proportional to

height of the tree.

Hence there exist variations in time complexities of best case

average case and worst case.