Data structures stacks

D A T A S T R U C T U R E S
STACKS:
It is an ordered group of homogeneous items of elements. Elements are added
to and removed from the top of the stack (the most recently added items are at
the top of the stack). The last element to be added is the first to be removed
(LIFO: Last In, First Out).
A stack is a list of elements in which an element may be inserted or deleted only at
one end, called TOP of the stack. The elements are removed in reverse order of
that in which they were inserted into the stack.
Basic operations:
These are two basic operations associated with stack:
 Push() is the term used to insert/add an element into a stack. 
 Pop() is the term used to delete/remove an element from a stack.
Other names for stacks are piles and push-down lists. 
There are two ways to represent Stack in memory. One is using array and other is
using linked list.
Array representation of stacks:
Usually the stacks are represented in the computer by a linear array. In the following
algorithms/procedures of pushing and popping an item from the stacks, we have
considered, a linear array STACK, a variable TOP which contain the location of the
top element of the stack; and a variable STACKSIZE which gives the maximum
number of elements that can be hold by the stack.
STACK
Data 1 Data 2 Data 3
0 1 2 3 4 5 6 7 8
TOP STACKSIZE2 9

Push Operation
Push an item onto the top of the stack (insert an item)

Pop Operation
Pop an item off the top of the stack (delete an item)
Algorithm for PUSH:
Algorithm: PUSH(STACK, TOP, STACKSIZE, ITEM)
1. [STACK already filled?]
If TOP=STACKSIZE-1, then: Print: OVERFLOW / Stack Full, and Return.
2. Set TOP:=TOP+1. [Increase TOP by 1.]
3. Set STACK[TOP]=ITEM. [Insert ITEM in new TOP position.]
4. RETURN.
Algorithm for POP:
Algorithm: POP(STACK, TOP, ITEM)
This procedure deletes the top element of STACK and assigns it to the
variable ITEM.
1. [STACK has an item to be removed? Check for empty stack] If
TOP=-1, then: Print: UNDERFLOW/ Stack is empty, and Return.
2. Set ITEM=STACK[TOP]. [Assign TOP element to ITEM.]
3. Set TOP=TOP-1. [Decrease TOP by 1.]
4. Return.

Here are the minimal operations we'd need for an abstract stack (and their
typical names):
o Push: Places an element/value on top of the stack.
o Pop: Removes value/element from top of the stack.
o IsEmpty: Reports whether the stack is Empty or not.
o IsFull: Reports whether the stack is Full or not.
1. Run this program and examine its behavior.
// A Program that exercise the operations on Stack Implementing Array
// i.e. (Push, Pop, Traverse)
#include <conio.h>
#include <iostream.h>
#include <process.h>
#define STACKSIZE 10 // int const STACKSIZE = 10;
// global variable and array declaration
int Top=-1;
int Stack[STACKSIZE];
void Push(int); // functions prototyping
int Pop(void);
bool IsEmpty(void);
bool IsFull(void);
void Traverse(void);
int main( )
{ int item, choice;
while( 1 )
{
cout<< "nnnnn";
cout<< " ******* STACK OPERATIONS ********* nn";
cout<< " 1- Push item n 2- Pop Item n";
cout<< " 3- Traverse / Display Stack Items n 4- Exit.";
cout<< " nnt Your choice ---> ";
cin>> choice;
switch(choice)
{ case 1: if(IsFull())cout<< "n Stack Full/Overflown";
else
{ cout<< "n Enter a number: ";
cin>>item;
Push(item); }
break;
case 2: if(IsEmpty())cout<< "n Stack is empty)
n"; else
{item=Pop();
cout<< "n deleted from Stack =
"<<item<<endl;} break;
case 3: if(IsEmpty())cout<< "n Stack is empty)
n"; else
{ cout<< "n List of Item pushed on
Stack:n"; Traverse();
}
break;

case 4: exit(0);
default:
cout<< "nnt Invalid Choice: n";
} // end of switch block
} // end of while loop
} // end of of main() function
void Push(int item)
{
Stack[++Top] = item;
}
int Pop( )
{
return Stack[Top--];
}
bool IsEmpty( )
{ if(Top == -1 ) return true else return false; }
bool IsFull( )
{ if(Top == STACKSIZE-1 ) return true else return false; }
void Traverse( )
{ int TopTemp = Top;
do{ cout<< Stack[TopTemp--]<<endl;} while(TopTemp>= 0);
}
1- Run this program and examine its behavior.
// A Program that exercise the operations on Stack
// Implementing POINTER (Linked Structures) (Dynamic Binding)
// Programed by SHAHID LONE
// This program provides you the concepts that how STACK is
// implemented using Pointer/Linked Structures
#include <iostream.h.h>
#include <process.h>
struct node {
int info;
struct node *next;
};
struct node *TOP = NULL;
void push (int x)
{ struct node *NewNode;
NewNode = new (node); // (struct node *) malloc(sizeof(node));
if(NewNode==NULL) { cout<<"nn Memeory
Crashnn"; return; }
NewNode->info = x;
NewNode->next = NULL;

if(TOP == NULL) TOP =
NewNode; else
{ NewNode->next =
TOP; TOP=NewNode;
}
}
struct node* pop ()
{ struct node *T;
T=TOP;
TOP = TOP->next;
return T;
}
void Traverse()
{ struct node *T;
for( T=TOP ; T!=NULL ;T=T->next) cout<<T->info<<endl;
}
bool IsEmpty()
{ if(TOP == NULL) return true; else return false; }
int main ()
{ struct node *T;
int item, ch;
while(1)
{ cout<<"nnnnnn ***** Stack Operations *****n";
cout<<"nn 1- Push Item n 2- Pop Item n";
cout<<" 3- Traverse/Print stack-valuesn 4- Exitnn";
cout<<"n Your Choice --> ";
cin>>ch;
switch(ch)
{ case 1:
cout<<"nPut a value:
"; cin>>item;
Push(item);
break;
case 2:
if(IsEmpty()) {cout<<"nn Stack is
Emptyn"; break;
}
T= Pop();
cout<< T->info <<"nn has been deleted
n"; break;
case 3:
if(IsEmpty()) {cout<<"nn Stack is
Emptyn"; break;
}
Traverse();
break;
case 4:
exit(0);
} // end of switch
block } // end of loop
return 0;
} // end of main function

Application of the Stack (Arithmetic Expressions)
I N F I X , P O S T F I X A N D P R E F I X N
O T A T I O N S
In f ix , P o s tf ix a n d P r e f ix n o ta tio n s a r e u s e d in m a n y c a
lc u la to r s . T h e e a s ie s t w a y to im p le m e n t th e
P o s tf ix a n d P r e f ix o p e ra tio n s is to u s e s ta c k . In f ix
a n d p r e f ix n o ta tio n s c a n b e c o n v e r te d to p o s tfix
n o ta tio n u s in g s ta c k .
T h e r e a s o n w h y p o s tf ix n o ta tio n is p r e f e r r e d is th a t
y o u d o n ’t n e e d a n y p a re n th e s is a n d th e r e is n o
p r e s c ie n c e p r o b le m .
Stacks are used by compilers to help in the process of converting infix to postfix
arithmetic expressions and also evaluating arithmetic expressions. Arithmetic
expressions consisting variables, constants, arithmetic operators and parentheses.
Humans generally write expressions in which the operator is written between the
operands (3 + 4, for example). This is called infix notation. Computers ―prefer‖
postfix notation in which the operator is written to the right of two operands. The
preceding infix expression would appear in postfix notation as 3 4 +.
To evaluate a complex infix expression, a compiler would first convert the expression
to postfix notation, and then evaluate the postfix version of the expression. We use
the following three levels of precedence for the five binary operations.
Precedence Binary Operations
Highest Exponentiations (^)
Next Highest Multiplication (*), Division (/) and Mod (%)
Lowest Addition (+) and Subtraction (-)
For example:
(66 + 2) * 5 – 567 /
42 to postfix
66 22 + 5 * 567 42 / –
Transforming Infix Expression into Postfix Expression:
The following algorithm transform the infix expression Q into its equivalent
postfix expression P. It uses a stack to temporary hold the operators and left
parenthesis.
The postfix expression will be constructed from left to right using operands from Q
and operators popped from STACK.

Algorithm: Infix_to_PostFix(Q, P)
Suppose Q is an arithmetic expression written in infix notation. This
algorithm finds the equivalent postfix expression P.
1. Push ―(― onto STACK, and add ―)‖ to the end of Q.
2. Scan Q from left to right and repeat Steps 3 to 6 for each element of Q until
the STACK is empty:
3. If an operand is encountered, add it to P.
4. If a left parenthesis is encountered, push it onto STACK.
5. If an operator © is encountered, then:
a) Repeatedly pop from STACK and add to P each operator
(on the top of STACK) which has the same or
higher precedence/priority than ©
b) Add © to STACK.
[End of If structure.]
6. If a right parenthesis is encountered, then:
a) Repeatedly pop from STACK and add to P each operator (on the
top of STACK) until a left parenthesis is encountered.
b) Remove the left parenthesis. [Do not add the left parenthesis to P.]
[End of Step 2
loop.] 7. Exit.
Convert Q: A+( B * C – ( D / E ^ F ) * G ) * H into postfix form showing stack status .
Now add “)” at the end of expression A+( B * C – ( D / E ^ F ) * G ) * H )
and also Push a “(“ on Stack.
Symbol Scanned Stack Expression Y
(
A ( A
+ (+ A
( (+( A
B (+( AB
* (+(* AB
C (+(* ABC
- (+(- ABC*
( (+(-( ABC*
D (+(-( ABC*D
/ (+(-(/ ABC*D
E (+(-(/ ABC*DE
^ (+(-(/^ ABC*DE
F (+(-(/^ ABC*DEF
) (+(- ABC*DEF^/
* (+(-* ABC*DEF^/
G (+(-* ABC*DEF^/G
) (+ ABC*DEF^/G*-
* (+* ABC*DEF^/G*-
H (+* ABC*DEF^/G*-H
) empty ABC*DEF^/G*-H*+

Evaluation of Postfix Expression:
If P is an arithmetic expression written in postfix notation. This algorithm
uses STACK to hold operands, and evaluate P.
Algorithm: This algorithm finds the VALUE of P written in postfix notation.
1. Add a Dollar Sign ‖$‖ at the end of P. [This acts as sentinel.]
2. Scan P from left to right and repeat Steps 3 and 4 for each element of P
until the sentinel ―$‖ is encountered.
3. If an operand is encountered, put it on STACK.
4. If an operator © is encountered, then:
a) Remove the two top elements of STACK, where A is the top
element and B is the next-to—top-element.
b) Evaluate B © A.
c) Place the result of (b) back on STACK.
[End of Step 2 loop.]
5. Set VALUE equal to the top element on STACK.
6. Exit.
For example:
Following is an infix arithmetic expression
(5 + 2) * 3 – 9 / 3
And its postfix is:
5 2 + 3 * 9 3 / –
Now add “$” at the end of expression as a sentinel.
5 2 + 3 * 8 4 / – $
Scanned Elements Stack Action to do _
5 5 Pushed on stack
2 5, 2 Pushed on Stack
+ 7 Remove the two top elements and calculate
5 + 2 and push the result on stack
* 21 Remove the two top elements and calculate
7 * 3 and push the result on stack
4 21, 8, 4 Pushed on Stack
/ 21, 2 Remove the two top elements and calculate
8 / 2 and push the result on stack
- 19 Remove the two top elements and calculate
21 - 2 and push the result on stack
$ 19 Sentinel $ encouter , Result is on top of the STACK

Following code will transform an infix arithmetic expression into Postfix arithmetic
expression. You will also see the Program which evaluates a Postfix expression.
// This program provides you the concepts that how an infix
// arithmetic expression will be converted into post-fix expression
// using STACK
// Conversion Infix Expression into Post-fix
// NOTE: ^ is used for raise-to-the-power
#include<iostream.h>
#include<conio.h>
#include<string.h>
int main()
{ int const null=-1;
char Q[100],P[100],stack[100];// Q is infix and P is postfix array
int n=0; // used to count item inserted in P
int c=0; // used as an index for P
int top=null; // it assign -1 to top
int k,i;
cout<<“Put an arithematic INFIX _Expressionnntt";
cin.getline(Q,99); // reads an infix expression into Q as string
k=strlen(Q); // it calculates the length of Q and store it in k
// following two lines will do initial work with Q and stack
strcat(Q,”)”); // This function add ) at the and of Q
stack[++top]='('; // This statement will push first ( on Stack
while(top!= null)
{
for(i=0;i<=k;i++)
{
switch(Q[i])
{
case '+':
case '-':
for(;;)
{
if(stack[top]!='(' )
{ P[c++]=stack[top--];n++;
} else
break;
}
stack[++top]=Q[i];
break;
case '*':
case '/':
case '%':
for(;;)
{if(stack[top]=='(' || stack[top]=='+'
|| stack[top]=='-') break;
else
{ P[c++]=stack[top--]; n++; }
}

stack[++top]=Q[i];
break;
case '^':
for(;;)
{
if(stack[top]=='(' || stack[top]=='+' ||
stack[top]=='-' || stack[top]=='/' ||
stack[top]=='*' || stack[top]=='%') break;
else
{ P[c++]=stack[top--]; n++; }
}
stack[++top]=Q[i];
break;
case '(':
stack[++top]=Q[i];
break;
case ')':
for(;;)
{
if(stack[top]=='(' ) {top--; break;}
else { P[c++]=stack[top--]; n++;}
}
break;
default : // it means that read item is an operand
P[c++]=Q[i];
n++;
} //END OF SWITCH
} //END OF FOR LOOP
} //END OF WHILE LOOP
P[n]='0'; // this statement will put string terminator at the
// end of P which is Postfix expression
cout<<"nnPOSTFIX EXPRESION IS nntt"<<P<<endl;
} //END OF MAIN FUNCTION

// This program provides you the concepts that how a post-fixed
// expression is evaluated using STACK. In this program you will
// see that linked structures (pointers are used to maintain the stack.
// NOTE: ^ is used for raise-to-the-power
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include<math.h>
#include <stdlib.h>
#include <ctype.h>
struct node {
int info;
struct node
*next; };
struct node *TOP = NULL;
void push (int x)
{ struct node *Q;
// in c++ Q = new node;
Q = (struct node *) malloc(sizeof(node)); // creation of new
node Q->info = x;
Q->next = NULL;
if(TOP == NULL) TOP =
Q; else
{ Q->next =
TOP; TOP=Q;
}
}
struct node* pop ()
{ struct node *Q;
if(TOP==NULL) { cout<<"nStack is emptynn";
exit(0);
}
else
{Q=TOP;
TOP = TOP->next;
return Q;
}
}
int main(void)
{char t;
struct node *Q, *A, *B;
cout<<"nn Put a post-fix arithmatic expression end with $: n ";
while(1)
{ t=getche(); // this will read one character and store it in
t if(isdigit(t)) push(t-'0'); // this will convert char into
int else if(t==' ')continue;
else if(t=='$') break;

else
{ A= pop();
B= pop();
switch (t)
{
case '+':
push(B->info + A->info);
break;
case '-':
push(B->info - A->info);
break;
case '*':
push(B->info * A->info);
break;
case '/': push(B->info / A->info);
break;
case '^': push(pow(B->info, A->info));
break;
default: cout<<"Error unknown operator";
} // end of switch
} // End of if structure
} // end of while loop
Q=pop(); // this will get top value from stack which is result
cout<<"nnnThe result of this expression is = "<<Q->info<<endl;
return 0;
} // end of main function

Data structures stacks

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Data structures stacks (20)

More from maamir farooq (20)

Recently uploaded (20)

Data structures stacks