Lec 7 Stacks

8/3/2019 Lec 7 Stacks

1/40

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)


3/40

StacksExamples:

Books on a floor

Dishes on a shelf


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.


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


6/40

Push and Pop operations of

Stack


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/40


Problem with this implementation

Every PUSH and POP requires moving the entirearray up and down.

1

1

2

1

2

3

1

2


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.



10/40

A betterImplementation:

First Element

Last Elementmaxlength

top

Second Element

1

2.

.



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


12/40

Implementation//*******************// Constructor *

//*******************IntStack::IntStack(int size)

{stackArray = new int[size];

stackSize = size;top = -1;

}


13/40

Push// Member function push pushes the argumentonto *// the stack. *void IntStack::push(int num){

if (isFull())cout


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


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;

}


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;}


17/40

// This program demonstrates the IntStack class.

#include

#include "intstack.h

void main(void)

{

IntStack stack(5);

int catchVar;

cout


18/40

cout


19/40

Program OutputPushing 5

Pushing 10Pushing 15

Pushing 20

Pushing 25

Popping...

25

20

15

10

5


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


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.


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.


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( )


24/40

Stack Templ

atesThe stack class so far work with integersonly. A stack template can be used to

work with any data type.


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


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();

};


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;

}


28/40

void Stack::IsEmpty()

{

if (top==NULL) return true;

else return false;

}


29/40

Program 3

// This program demonstrates the dynamic stack// class DynIntClass.

#include

#include "dynintstack.h

void main(void){

DynIntStack stack;

int catchVar;

cout


30/40

cout


31/40

Application of StackData Structures using Cand C++,Section 2.3


32/40

INFIX,POSTFIX and PREFIX

Infix: A+B-C

Postfix: AB+C- Prefix: -+ABC

Order ofPrecedence of Operators

Exponentiation

Multiplication/Division

Addition/Subtraction


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)


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.


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


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)


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*+


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;








} /* end while */


39/40

Algorithm to Convert Infix to Postfixopstk = the empty stack;








} /* end while */

Example-3: ( (A-(B+C) ) *D ) $ (

E+F)


40/40

Algorithm to Convert Infix to Postfix

opstk = the empty stack;








} /* 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+$

Lec 7 Stacks

Documents

Transcript of Lec 7 Stacks