Archives for

# Data Structures

## simple Implementation of stack using a linked list

Stacks are linear data structures. This means that their contexts are stored in what looks like a line (although vertically). This linear property, however, is not sufficient to discriminate a stack from other linear data structures. For example, an array is a sort of linear data structure in which you can access any element directly. In contrast, in a stack, you can only access the element at its top. In a stack Last thing In is the First thing Out. Thus, we say that a stack enforces LIFO order.

One disadvantage of implementing stack using an array is wastage of space. Most of the times most of the array is left unused. A better way to implement stack is by using a linked list. By using a single linked list to implement a stack there is no wastage of space.

Implementation of stack using a linked list

```/*
A simple implementation of linked list in C plus plus (CPP/C++)
*/
/*
Compiler used: g++
*/
#include<iostream>
using namespace std;
struct node{
int data;
node *next;
};
//This function pushes data(node) to the stack
node * push(node*,node*);
//This function pops data (node) and returns pointer to the poped node
node * pop(node*);
//This function shows the stack
void show_stack(node*);
///These two global variables will help us track the start and end of the list
node *f,*l;
main()
{
int i,ch;
f=l=NULL;
cout<<"\t 1 to push"<<endl;
cout<<"\t 2 to pop"<<endl;
cout<<"\t 3 to show stack"<<endl;
cout<<"\t 0 to exit"<<endl;
while(1)
{
cin>>ch;
switch(ch)
{
case 1:
{
if(f==NULL)
l=f=push(f,l);
else
l=push(f,l);
break;
}
case 2:
{
cout<<"popped:"<<pop(f)->data<<endl;
break;
}

case 3:
{
show_stack(f);
break;
}
case 0:
break;
default:
}
if(ch==0)
break;
}
}
node * push(node *f,node *l)
{
node *n;
n=new node;
cout<<"Enter data:";
cin>>n->data;
n->next=NULL;
if(f==NULL)
{f=l=n;return f;}
else
{
l->next=n;
l=n;return l;
}

}
void show_stack(node *f)
{
cout<<"showing data"<<endl;
node *guest=f;
while(guest!=NULL)
{
cout<<"\t"<<guest->data<<endl;
guest=guest->next;
}
}
node * pop(node *f)
{
node *guest,*lb;
guest=lb=f;
while(guest->next!=NULL)
{
lb=guest;
guest=guest->next;
}
lb->next=NULL;
l=lb;
return guest;
}

```

## Implementation of Singly linked list in C plus plus

The simplest kind of linked list is a singly-linked list , which has one link per node. This link points to the next node in the list, or to a null value or empty list if it is the final node.A singly linked list’s node is divided into two parts. The first part holds or points to information about the node, and second part holds the address of next node. A singly linked list travels one way.

A singly-linked list containing two values: the value of the current node and a link to the next node

```/*

A simple implementation of linked list in C plus plus (CPP/C++)

*/
/*
For any help, post comment here

Compiler used: g++
*/
#include<iostream>
using namespace std;
struct node{
int data;
node *next;
};
/*
This function adds a node at the end of the
list and returns pointer to the added node,
This takes pointer to the first node and
pointer to the last node as argument. By
giving the last node as argument we are saving
some computer labour as it need not travel
from the start to the end to find the last node
*/
/*
This function just takes the first node as
the argument and traverses the entire list
displaying the data in each node.
*/
void shownodes(node*);
/*
This function takes the first node as argument
and traverses the list until it finds the last
node and deletes it and returns pointer to the
new last node.
*/
node * delete_node(node*);
/*
*f and *l are the global variables keeping track
of first and last nodes.
*/
node *f,*l;

main()
{
int i,ch;
f=l=NULL;
cout<<"\t 1 to add a node"<<endl;
cout<<"\t 2 to see the nodes"<<endl;
cout<<"\t 3 to delete a node"<<endl;
cout<<"\t 0 to exit"<<endl;
while(1)
{
cin>>ch;
switch(ch)
{
case 1:
{
if(f==NULL)
l=f=addnode(f,l); //Since first node is the last node
else
break;
}
case 2:
shownodes(f);break;
case 3:
l=delete_node(f);break; // Last node has been changed to the last but one.
case 0:
break;
default:
}
if(ch==0)
break;
}
}
{
node *n;
n=new node;
//Allocating memory for the new node
cout<<"Enter data:";
cin>>n->data;
//This is going to be the last node, so its next point to NULL
n->next=NULL;
//If there is no first node, then the new node is the first and last node.
if(f==NULL)
{f=l=n;return f;}
else
{
// Pointing the last node to the new node
l->next=n;
//Setting the new node as the last node
l=n;return l;
}

}
void shownodes(node *f)
{
cout<<"showing data"<<endl;
node *guest=f;
while(guest!=NULL)
{
cout<<"\t"<<guest->data<<endl;
guest=guest->next;
}
}
node * delete_node(node *f)
{
node *guest,*lb;
guest=lb=f;
while(guest->next!=NULL)
{
lb=guest;
guest=guest->next;
}
lb->next=NULL;
cout<<"node deleted"<<endl;
return lb;
}

```

## Program to convert infix expression to postfix in C | Shunting yard algorithm

This program is a implementation of shunting yard algorithm to convert an infix expression to post fix expression, This is a extension of the stack program published earlier

Algorithm:(Taken from wikipedia)

• While there are tokens to be read:
• If the token is a number, then add it to the output queue.
• If the token is a function token, then push it onto the stack.
• If the token is a function argument separator (e.g., a comma):
• Until the topmost element of the stack is a left parenthesis, pop the element from the stack and push it onto the output queue. If no left parentheses are encountered, either the separator was misplaced or parentheses were mismatched.
• If the token is an operator, o1, then:
• while there is an operator, o2, at the top of the stack, and either
o1 is associative or left-associative and its precedence is less than (lower precedence) or equal to that of o2, or
o1 is right-associative and its precedence is less than (lower precedence) that of o2,
pop o2 off the stack, onto the output queue;
• push o1 onto the stack.
• If the token is a left parenthesis, then push it onto the stack.
• If the token is a right parenthesis:
• Until the token at the top of the stack is a left parenthesis, pop operators off the stack onto the output queue.
• Pop the left parenthesis from the stack, but not onto the output queue.
• If the token at the top of the stack is a function token, pop it and onto the output queue.
• If the stack runs out without finding a left parenthesis, then there are mismatched parentheses.
• When there are no more tokens to read:
• While there are still operator tokens in the stack:
• If the operator token on the top of the stack is a parenthesis, then there are mismatched parenthesis.
• Pop the operator onto the output queue.
• Exit.
```#include <stdio.h>
#define size 10
char stack[size];
int tos=0,ele;
void push();
char pop();
void show();
int isempty();
int isfull();
char infix[30],output[30];
int prec(char);
int main()
{
int i=0,j=0,k=0,length;
char temp;
printf("\nEnter an infix expression:");
scanf("%s",infix);
printf("\nThe infix expresson is %s",infix);
length=strlen(infix);
for(i=0;i<= prec(stack[tos-1])  )
{
temp=pop();
printf("\n the poped element is :%c",temp);
output[j++]=temp;
push(infix[i]);
printf("\n The pushed element is :%c",infix[i]);
show();
}
else
{
push(infix[i]);
printf("\nThe pushed element is:%c",infix[i]);
show();
}
}
else
{
if(infix[i]=='(')
{
push(infix[i]);
printf("\nThe pushed-- element is:%c",infix[i]);
}
if(infix[i]==')')
{
temp=pop();
while(temp!='(')
{output[j++]=temp;
printf("\nThe element added to Q is:%c",temp);
//temp=pop();
printf("\n the poped element is :%c",temp);
temp=pop();}
}
}
}
}
printf("\nthe infix expression is: %s",output);
}
while(tos!=0)
{
output[j++]=pop();
}
printf("the infix expression is: %s\n",output);
}
//Functions for operations on stack
void push(int ele)
{
stack[tos]=ele;
tos++;
}
char pop()
{
tos--;
return(stack[tos]);
}
void show()
{
int x=tos;
printf("--The Stack elements are.....");
while(x!=0)
printf("%c, ",stack[--x]);
}

//Function to get the precedence of an operator
int prec(char symbol)
{
if(symbol== '(')
return 0;
if(symbol== ')')
return 0;
if(symbol=='+' || symbol=='-')
return 1;
if(symbol=='*' || symbol=='/')
return 2;
if(symbol=='^')
return 3;
return 0;
}