8/3/2019 Lec 7 Stacks
1/40
Stacks
8/3/2019 Lec 7 Stacks
2/40
StacksA Stackis a special kind of list in which all insertions
and deletions take place at one end, called the Top
Other Names
Pushdown List
Last In First Out (LIFO)
8/3/2019 Lec 7 Stacks
3/40
StacksExamples:
Books on a floor
Dishes on a shelf
8/3/2019 Lec 7 Stacks
4/40
Common Operations on Stacks1. MAKENULL(S): Make Stack S be an empty
stack.
2. TOP(S): Return the element at the top of stackS.
3. POP(S): Remove the top element of the stack.
4. PUSH(S): Insert the elementxat the top of thestack.
5. EMPTY(S): Return true if S is an empty stack;return false otherwise.
8/3/2019 Lec 7 Stacks
5/40
Static and Dynamic Stacks There are two kinds of stack data structure
-
a) static, i.e. they have a fixed size, and areimplemented as arrays.
b) dynamic, i.e. they grow in size as needed,and implemented as linked lists
8/3/2019 Lec 7 Stacks
6/40
Push and Pop operations of
Stack
8/3/2019 Lec 7 Stacks
7/40
An Array Implementation of Stacks
First Implementation
Elements are stored in contiguous cells of an array.
New elements can be inserted to the top of the list.
Last Element
Second Element
First Element
List
Emptymaxlength
top
8/3/2019 Lec 7 Stacks
8/40
An Array Implementation of Stacks
Problem with this implementation
Every PUSH and POP requires moving the entirearray up and down.
1
1
2
1
2
3
1
2
8/3/2019 Lec 7 Stacks
9/40
Since, in a stack the insertion and deletiontake place only at the top, so
A better Implementation: Anchor the bottom of the stack at the
bottom of the array Let the stack grow towards the top of the
array Top indicates the current position of the
first stack element.
An Array Implementation of Stacks
8/3/2019 Lec 7 Stacks
10/40
A betterImplementation:
First Element
Last Elementmaxlength
top
Second Element
1
2.
.
An Array Implementation of Stacks
8/3/2019 Lec 7 Stacks
11/40
A Stack Class
#ifndefINTSTACK_H#define INTSTACK_H
class IntStack{private:
int *stackArray;
int stackSize;int top;
public:IntStack(int);void push(int);void pop(int &);
bool isFull(void);bool isEmpty(void);};
#endif
8/3/2019 Lec 7 Stacks
12/40
Implementation//*******************// Constructor *
//*******************IntStack::IntStack(int size)
{stackArray = new int[size];
stackSize = size;top = -1;
}
8/3/2019 Lec 7 Stacks
13/40
Push// Member function push pushes the argumentonto *// the stack. *void IntStack::push(int num){
if (isFull())cout
8/3/2019 Lec 7 Stacks
14/40
// Member function pop pops the value at the top
// of the stack off, and copies it into the variable// passed as an argument.
void IntStack::pop(int &num){
if (isEmpty())cout
8/3/2019 Lec 7 Stacks
15/40
//***************************************************
// Member function isFull returns true if the stack *
// is full, or false otherwise. *
//***************************************************
bool IntStack::isFull(void)
{
bool status;
if (top == stackSize - 1)
status = true;
else
status = false;
return status;
}
8/3/2019 Lec 7 Stacks
16/40
//**********************************************
// Member funciton isEmpty returns true if the
//stack *
// is empty, or false otherwise.*
//***********************************************
bool IntStack::isEmpty(void)
{
bool status;
if (top == -1)
status = true;
else
status = false;
return status;}
8/3/2019 Lec 7 Stacks
17/40
// This program demonstrates the IntStack class.
#include
#include "intstack.h
void main(void)
{
IntStack stack(5);
int catchVar;
cout
8/3/2019 Lec 7 Stacks
18/40
cout
8/3/2019 Lec 7 Stacks
19/40
Program OutputPushing 5
Pushing 10Pushing 15
Pushing 20
Pushing 25
Popping...
25
20
15
10
5
8/3/2019 Lec 7 Stacks
20/40
About Program 1
In the program, the constructor is called
with the argument 5. This sets up the
member variables as shown in Figure 1.Since top is set to 1, the stack is empty
8/3/2019 Lec 7 Stacks
21/40
Figure 3 shows the state of the membervariables after all five calls to thepush
function. Now the top of the stack is at
element 4, and the stack is full.
8/3/2019 Lec 7 Stacks
22/40
Notice that the pop function uses a reference
parameter, num.
The value that is popped off the stack is copied into
num so it can be used later in the program.
Figure 4 (on the next slide) depicts the state of
the class members, and the numparameter, justafter the first value is popped off the stack.
8/3/2019 Lec 7 Stacks
23/40
Implementing other Stack Operations
More complex operations can be built on the basic stack class we
have just described, e.g. a class called MathStack.
MathStackhas 2 member functions :- add( ) sub( )
8/3/2019 Lec 7 Stacks
24/40
Stack Templ
atesThe stack class so far work with integersonly. A stack template can be used to
work with any data type.
8/3/2019 Lec 7 Stacks
25/40
A Linked-List Implementation of
Stacks Stack can expandorshrinkwith eachPUSH orPOP operation.
PUSH and POP operate only on theheader cell and the first cell on the list.
x y
.z
Top
8/3/2019 Lec 7 Stacks
26/40
Linked List Implementation of Stack
class Stack{
struct node
{int data;node *next;
}*top;
public:void Push(int newelement);int Pop(void);bool IsEmpty();
};
8/3/2019 Lec 7 Stacks
27/40
void Stack::Push(int newelement){
node *newptr;newptr=new node;newptr->data=newelement;newptr->next=top;top=newptr;
}int Stack:Pop(void){
if (IsEmpty()) { coutnext;delete tempptr;return returnvalue;
}
8/3/2019 Lec 7 Stacks
28/40
void Stack::IsEmpty()
{
if (top==NULL) return true;
else return false;
}
8/3/2019 Lec 7 Stacks
29/40
Program 3
// This program demonstrates the dynamic stack// class DynIntClass.
#include
#include "dynintstack.h
void main(void){
DynIntStack stack;
int catchVar;
cout
8/3/2019 Lec 7 Stacks
30/40
cout
8/3/2019 Lec 7 Stacks
31/40
Application of StackData Structures using Cand C++,Section 2.3
8/3/2019 Lec 7 Stacks
32/40
INFIX,POSTFIX and PREFIX
Infix: A+B-C
Postfix: AB+C- Prefix: -+ABC
Order ofPrecedence of Operators
Exponentiation
Multiplication/Division
Addition/Subtraction
8/3/2019 Lec 7 Stacks
33/40
Infix: ( (A+B)*C-(D-E) ) $ (F+G)
Conversion to Postfix Expression
( (AB+)*C-(DE-) ) $ (FG+)
( (AB+C*)-(DE-) ) $ (FG+) (AB+C*DE--) $ (FG+)
AB+C*DE- -FG+$
Exercise: Convert the following to Postfix
( A + B ) * ( C D)
A $ B * C D + E / F / (G + H)
8/3/2019 Lec 7 Stacks
34/40
Conversion to Prefix Expression
The precedence rules for converting an expression from infix to
prefix are identical. The only change from postfix is that theoperator is placed before the operands rather than after them.
Evaluating a Postfix Expression
Each operator in a postfix string refers to the previous twooperands in the string.
8/3/2019 Lec 7 Stacks
35/40
Algorithm to Evaluate a PostfixExpressionopndstk = the empty stack//scan the input string reading one
element//at a time into symbwhile (not end of input) {
symb = next input character;
if (symb is an operand)push(opndstk, symb)
else {/* symb is an operator */opnd2 = pop(opndstk);opnd1 = pop(opndstk);
value = result of applyingsymb to opnd1 and opnd2;push(opndstk, value);
} /* end else */} /* end while */return (pop(opndstk));
Example:
PostfixExpression: 6 2 3 + - 3 8 2 / + * 2 $ 3 +sym
bopnd
1opnd2 valu
eopndstk
6 6
2 6,2
3 6,2,3
+ 2 3 5 6,5
- 6 5 1 1
3 6 5 1 1,3
8 6 5 1 1,3,8
2 6 5 1 1,3,8,2
/ 8 2 4 1,3,4
+ 3 4 7 1,7
* 1 7 7 7
2 1 7 7 7,2
$ 7 2 49 49
3 7 2 49 49,3
+ 49 3 52 52
8/3/2019 Lec 7 Stacks
36/40
Conversion ofInfix Expression to
postfixA+B*C = ABC*+(A+B)*C = AB+C*There must be a precedence function.
prcd(op1, op2), where op1 and op2 are characters representing operators.
This function returns TRUE if op1 has precendence over op2 when op1appears to the left of op2 in an infix expression without parenthesis.prcd(op1,op2) returns FALSE otherwise.
For example prcd(*,+) and prcd(+,+) are TRUE whereas prcd(+,*) isFALSE.
prcd($,$) = FALSEprcd( ( , op) = FALSE for any operator op
prcd( op, ( ) = FALSE for any operator op other than )prcd( op, ) ) = TRUE for any operator op other than (prcd( ) ,op ) = undefined for any operator op (an error)
8/3/2019 Lec 7 Stacks
37/40
Algorithm to Convert Infix to Postfixopstk = the empty stack;
while (not end of input) {symb = next input character;if (symb is an operand)
add symb to the postfix stringelse {
while (!empty(opstk) &&
prcd(stacktop(opstk),symb) ) {topsymb = pop(opstk);add topsymb to the postfix
string;} /* end while */push(opstk, symb);
} /* end else */} /* end while *//* output any remaining operators */while (!empty(opstk) ) {
topsymb = pop(opstk);add topsymb to the postfix string;
} /* end while */
Example-1: A+B*C
symb
Postfixstring
opstk
A A
+ A +
B AB +
* AB +*
C ABC +*
ABC* +
ABC*+
8/3/2019 Lec 7 Stacks
38/40
Algorithm to Convert Infix to PostfixExample-2: (A+B)*C
symb Postfixstring
opstk
( (
A A (
+ A (+
B AB (+
) AB+
* AB+ *
C AB+C *
AB+C*
opstk = the empty stack;
while (not end of input) {symb = next input character;if (symb is an operand)
add symb to the postfix stringelse {
while (!empty(opstk) &&
prcd(stacktop(opstk),symb) ) {topsymb = pop(opstk);add topsymb to the postfix
string;} /* end while */push(opstk, symb);
} /* end else */} /* end while *//* output any remaining operators */while (!empty(opstk) ) {
topsymb = pop(opstk);add topsymb to the postfix string;
} /* end while */
8/3/2019 Lec 7 Stacks
39/40
Algorithm to Convert Infix to Postfixopstk = the empty stack;
while (not end of input) {symb = next input character;if (symb is an operand)
add symb to the postfix stringelse {
while (!empty(opstk) &&
prcd(stacktop(opstk),symb) ) {topsymb = pop(opstk);add topsymb to the postfix
string;} /* end while */push(opstk, symb);
} /* end else */} /* end while *//* output any remaining operators */while (!empty(opstk) ) {
topsymb = pop(opstk);add topsymb to the postfix string;
} /* end while */
Example-3: ( (A-(B+C) ) *D ) $ (
E+F)
8/3/2019 Lec 7 Stacks
40/40
Algorithm to Convert Infix to Postfix
opstk = the empty stack;
while (not end of input) {symb = next input character;if (symb is an operand)
add symb to the postfix stringelse {
while (!empty(opstk) &&
prcd(stacktop(opstk),symb) ) {topsymb = pop(opstk);add topsymb to the postfix
string;} /* end while */push(opstk, symb);
} /* end else */} /* end while *//* output any remaining operators */while (!empty(opstk) ) {
topsymb = pop(opstk);add topsymb to the postfix string;
} /* end while */
Example-3: ( (A-(B+C) ) *D ) $ (E+F)
symb Postfix string opstk
( (
( ((
A A ((
- A ((-
( A ((-(
B AB ((-(
+ AB ((-(+
C ABC ((-(+
) ABC+ ((-
) ABC+- (
* ABC+- (*
D ABC+-D (*
) ABC+-D*$ ABC+-D* $
( ABC+-D* $(
E ABC+-D*E $(
+ ABC+-D*E $(+
F ABC+-D*EF $(+
) ABC+-D*EF
+ $ABC+-D*EF+$