5 Stack 29 05 2024

Stack
Stack
A stack is a data structure

in which items can be
inserted only from one end
and get items back from the
same end. There , the last
item inserted into stack, is
the the first item to be taken
out from the stack. In short
its also called Last in First
out [LIFO].
Example of Stack (LIFO)
● A Stack of book on table.
● Token stack in Bank.
● Stack of trays and plates.

Stack Operations
● Top: Open end of the stack is called Top, From this end item can
be inserted.
● Push: To insert an item from Top of stack is called push operation.
The push operation change the position of Top in stack.
● POP: To put-off, get or remove some item from top of the stack is
the pop operation, We can POP only only from top of the stack.
● IsEmpty: Stack considered empty when there is no item on Top.
IsEmpty operation return true when no item in stack else false.
● IsFull: Stack considered full if no other element can be inserted on
top of the stack. This condition normally occur when stack
implement ed through array.
Stack Abstract Data Type
ADT/Class Stack {
Data/Attributes/Values:
int size; Top
Type items;
Functions/Operations:
CreateStack (int size); --create stack of size
Void Push(int n); - - if stack is not full
Type Pop(); - - if stack is not empty return top item
Int isEmpty(); - - return true if empty otherwise false
Int isFull(); - - return true if full otherwise false }
Stack Example
Stack Example ...
Stack Implementation using Array
# include <iostream.h>
#include <conio.h>
template <class Type>
Class intstack { private:
int size, top;
Type* Items;
// Functions & Operations
public:
Intstack ( ) { //default constructor
top=0; size=3;
Items = new Type[size]; }
~intstack( ) {
delete[] Items; }
Void Push (Type a) {
if(!IsFul( ))
Items[top++ ] = a;
else
Cout <<”\n stack is full.... push failed”; }
Type POP(void) {
if(!isEmpty( ))
return Items [ --top ];
else
Count <<\n stack is empty .. POP failed”; }
int IsEmpty ( ) { return (top == 0); }
int IsFull( ) { return (top == size); }
Void Display ( ) {
If( isEmpty( ))
Cout<<”Empty”;
Else for (int i=0; i<top; i++)
cout<<Item[i] <<” “;
}
} ; // end stack class
Void main( ) s.Display( );
{ intstack s; s.pop( ); s.pop( ); s.push(45);
s.Display(); s.Display ()
s.POP(); getch();
s.push(6); s.push(5); s.push(2); }
s.push(3);
s.Display( );
s.push(8);
s.pop( ); s.push(8);
s.Display( );
s.pop( ); s.pop ( ); s.push(40);
1. s.Display(); 1. Empty
2. s.POP(); 2. Stack is empty
3. s.push(6); s.push(5); s.push(2); 3.
s.push(3);
4. 6 5 2 3
4. s.Display( );
5. Stack is full
5. s.push(8);
6.
6. s.pop( ); s.push(8);
7. 6 5 2 8
7. s.Display( );
8.
8. s.pop( ); s.pop ( ); s.push(40);
9. 6 5 40
9. s.Display( );
10.s.pop( ); s.pop( ); s.push(45);
10.s.pop( ); s.pop( ); s.push(45);
11. 6 45
11.s.Display( );
Stack Implementation using Array ...
Stack Application
Reversing a string: To reverse a string we can use

following algorithm.
1. Given the sting and a stack
2. While there is not end of string, do the following.
3. Read a character form the string
4. Push it on the stack
5. End while
6. Re-initialize string position
7. While stack is not Empty, do the following.
8. Pop a character from the stack
9. Insert the character popped into next position in string.
10.End While
Reverse String
Void reverse (char* str) { void main( )
Inst i, len; {
len = strlen(str); char str[ ] =”abcdef”;
//Create stack of characters of size = cout<<” Original String is “<<str;
len
reverse(str);
cout<<” Reversed String is “<<str;
Stack<char> s(len);
getch();
for(i=o; i< len; i++ )
}
s.Push(str[i]);
s.Display;
For (j=0; j<len;j++)
str[j] = s.POP[j];
}
Reverse String...
String is a b c d e f
PUSH to SACK
Reverse String...
Reversed String: f e d c b a
POP from SACK
Infix, Postfix and Prefix Expression
Infix Expression: An expression in which the

operator is in between its two operands.
A+B
Prefix Expression: An expression in which operator
precedes its two operands is called an prefix
expression.
+AB
Postfix Expression: An expression in which
operator follows its two operands is called a postfix
expression.
AB+
Infix to Postfix Conversion
Infix expression can be directly evaluated but

the standard practice in CS is that the infix
expression converted to postfix form and then
the expression is evaluated. During both
processes stack is proved to be a useful data
structure.
Infix to Postfix By-Hand Algorithm
1. Given a expression in the infix form.

2. Find the highest precedence operator
3. If there are more then one operators with the same
precedence check associativity, i.e. pick the left most first.
4. Convert the operator and its operands from infix to postfix
A + B --> A B+
5. Repeat steps 2 to 4, until all the operators in the given
expression are in the postfix form.
Infix to Prefix By-Hand Algorithm
1. Given a expression in the infix form.

2. Find the highest precedence operator
3. If there are more then one operators with the same
precedence check associativity, i.e. pick the left most first.
4. Convert the operator and its operands from infix to prefix
A + B --> +A B
5. Repeat steps 2 to 4, until all the operators in the given
expression are in the postfix form.
C language operators Precedence and
Associativity
Infix to Postfix Step by Step Conversion
● A+B*C-D (Infix) ● (A+B)*C-D (Infix)

● A+BC*-D ● (AB+)*C-D
● ABC*+-D ● AB+C*-D
● ABC*+D- (Postfix) ● AB+C*D- (Postfix)
Exercise:
1. Infix ( (A * B) + (C / D) ) to Postfix
2. Infix ((A * (B + C) ) / D) to Postfix
3. Infix (A * (B + (C / D) ) ) to Postfix
Infix to Prefix Step by Step Conversion
● A*B+C/D (Infix) ● A*(B+C/D)

● *AB+C/D ● A*(B+/CD)
● *AB+/CD ● A*(+B/CD)
● +*AB/CD (Prefix) ● *A+B/CD
Exercise:
1. Infix ( (A * B) + (C / D) ) to Prefix
2.Infix ((A * (B + C) ) / D) to Prefix
3.Infix (A * (B + (C / D) ) ) to Prefix
Infix to Postfix using stack
● Given an expression in the Infix form.
● Create and initialize a stack to hold operators.
● While expression has more token (operator and operands) Do.
● If the next token is an operand, add it to postfix string.
● Else if the next token is end parenthesis ')', then
– Do until the start parenthesis '(' is opened
Pop operator from the stack
●
● Add to postfix string
– END Do
– Discard the Popped start parenthesis '('.
● End If
Infix to Postfix using stack ...
● If the next token is start parenthesis '(', push it on the stack.
● Else If the next token is an operator, Then
– While (Stack is not empty) AND (precedence of operator on top
of the stack is more then the current operator) Do
●Pop operator from the stack
● Add to postfix string
– End While
– Push operator to stack
● End if
● End While
● While stack is not empty
– Pop operator from the stack
– Add to postfix string
● End While
● Postfix is Created
Infix to Postfix using stack
● Example A*B+C become AB*C+
● Example A * (B + C * D) + E becomes A B C D * + * E +
Infix to Postfix using Stack..
1. Print operands as they arrive.

2. If the stack is empty or contains a left parenthesis on top, push the
incoming operator onto the stack.
3. If the incoming symbol is a left parenthesis, push it on the stack.
4. If the incoming symbol is a right parenthesis, pop the stack and print
the operators until you see a left parenthesis. Discard the pair of
parentheses.
5. If the incoming symbol has higher precedence than the top of the
stack, push it on the stack.
6. If the incoming symbol has equal precedence with the top of the
stack, use association. If the association is left to right, pop and print the
top of the stack and then push the incoming operator. If the association
is right to left, push the incoming operator.
Infix to Postfix using Stack..
7. If the incoming symbol has lower precedence than the symbol on the top of
the stack, pop the stack and print the top operator. Then test the incoming
operator against the new top of stack.
8. At the end of the expression, pop and print all operators on the stack. (No
parentheses should remain.)
Evaluating Arithmetic Postfix
Expression
● Expression is available in the postfix form
● Initialize the stack of operands.
● While expression has more token (operators and operands), do
– If the next token is an operand
Push it on the stack
●
– Else the token is an operator

● Pop two operands from the stack
● Apply the operator to the operands
● Push the result back on to the stack
– End If
● End While
● Result of expression is on the operand stack, pop and display.
Evaluating Arithmetic Postfix
Expression
PostFix Expression 2 3 4 + * 5 *
Move Token Stack
1 2 2
2 3 23
3 4 234
4 + 2 7 (3+4=7)
5 * 14 (2*7=14)
6 5 14 5
7 * 70 (14*5=70)

5 Stack 29 05 2024

Uploaded by

Copyright:

Available Formats

5 Stack 29 05 2024

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

5 Stack 29 05 2024

Uploaded by

Copyright:

Available Formats

Stack

A stack is a data structure

● A Stack of book on table.

● Token stack in Bank.

● Stack of trays and plates.

Reversing a string: To reverse a string we can use

Infix Expression: An expression in which the

Infix expression can be directly evaluated but

1. Given a expression in the infix form.

1. Given a expression in the infix form.

● A+BC-D (Infix) ● (A+B)C-D (Infix)

● AB+C/D (Infix) ● A(B+C/D)

● Add to postfix string

1. Print operands as they arrive.

– Else the token is an operator

You might also like