PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

135
CH APTER 7 Q UEUES AND STACK S

Transcript of PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

Page 1: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

CHAPTER 7

QUEUES AND STACKS

Page 2: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

A QUEUE IS A CONTAINER IN WHICH:

. INSERTIONS ARE MADE ONLY AT THE BACK;

. DELETIONS, RETRIEVALS, ANDMODIFICATIONS ARE MADE ONLYAT THE FRONT.

Page 3: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

PUSH (ALSO CALLED ENQUEUE) -- TOINSERT AN ITEM AT THE BACK

POP (ALSO CALLED DEQUEUE) -- TODELETE THE FRONT ITEM

IN A QUEUE, THE FIRST ITEM

INSERTED WILL BE THE FIRST ITEM

DELETED: FIFO (FIRST-IN, FIRST-OUT)

Page 4: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

PUSH “MATT”

Page 5: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

MATT

FRONT BACK

Page 6: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

PUSH “ANDREW”

Page 7: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

MATT

FRONT

ANDREW

BACK

Page 8: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

PUSH “SAMIRA”

Page 9: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

SAM IRAMATT

FRONT

ANDREW

BACK

Page 10: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

POP

Page 11: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

SAM IRA

FRONT

ANDREW

BACK

Page 12: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

THE queue CLASS IS TEMPLATED:template <class T, class Container = deque<T> >

T IS THE TEMPLATE PARAMETER

FOR THE ITEM TYPE. Container IS THE

TEMPLATE PARAMETER FOR THE

CLASS THAT WILL HOLD THE ITEMS,

WITH THE deque CLASS THE DEFAULT.

Page 13: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

METHOD INTERFACES

FOR THE

queue CLASS

Page 14: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

1. // Precondition: this queue object has been initialized// with a copy of this Container object.explicit queue (const Container& = Container( ));

HERE ARE EQUIVALENT EXAMPLES

FOR A QUEUE OF ITEMS OF TYPE Plane;THE ITEMS ARE STORED IN A DEQUE:

queue<Plane> runWay;queue<Plane, deque<Plane> > runWay;queue<Plane> runWay (deque<Plane>( ));queue<Plane, <deque<Plane> > runWay (deque<Plane>( ));

Page 15: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

2. // Poscondition: true has been returned if this queue object // is empty. Otherwise, false has been // returned.

bool empty( ) const;

3. // Postcondition: the number of items in this queue object// has been returned.unsigned size( ) const;

4. // Postcondition: the item x has been inserted at the back of// this queue.void push (const value_type& x); // Container class has

// typedef T value_type

Page 16: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

5. // Precondition: this queue is not empty.// Postcondition: a reference to the item at the front of// this queue has been returned.T& front( );

6. // Precondition: this queue is not empty.// Postcondition: the item that had been at the front of// this queue before this call has been// deleted from this queue.void pop( );

Page 17: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

THE STANDARD TEMPLATE LIBRARY

ALSO PROVIDES A front METHOD

THAT RETURNS A CONSTANT

REFERENCE AND back METHODS

THAT RETURN A REFERENCE OR

CONSTANT REFERENCE TO THE

BACK ITEM.

Page 18: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

THERE ARE NO ITERATORS!

THE ONLY ACCESSIBLE ITEM IS THE

FRONT ITEM.

Page 19: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

DETERMINE THE OUTPUT FROM THE FOLLOWING:

queue<int> my_queue;

for (int i = 0; i < 10; i++) my_queue.push (i * i);

while (!my_queue.empty()){ cout << my_queue.front() << endl; my_queue.pop();} // while

Page 20: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

THE queue CLASS IS A CONTAINER

ADAPTOR. A CONTAINER ADAPTOR C

CALLS THE METHODS FROM SOME

OTHER CLASS TO DEFINE THE

METHODS IN C.

Page 21: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

SPECIFICALLY, THE queue CLASS

ADAPTS ANY CONTAINER CLASS

THAT HAS push_back, pop_front, front,

back, size, AND empty METHODS.

deque? OK

list? OK

vector? NOT OK: NO pop_front METHOD

Page 22: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

THE STANDARD C++ REQUIRES THAT

THE DEFINITION OF THE queue

CLASS INCLUDE

protected:Container c;

Page 23: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

ALSO, THE METHOD DEFINITIONS

ARE PRESCRIBED. FOR EXAMPLE,

public:void push (const value_type& x) { c.push_back (x)); }

void pop( ) { c.pop_front( ); }

const T& front( ) const { return c.front( ); }

Page 24: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

IF EITHER A DEQUE OR LIST IS THE

UNDERLYING CONTAINER,

worstTime(n) IS CONSTANT FOR EACH

METHOD.

EXCEPTION: FOR THE push METHOD,

IF A DEQUE IS THE UNDERLYING

CONTAINER, worstTime(n) IS LINEAR IN

n, AND averageTime(n) IS CONSTANT

(AND amortizedTime(n) IS CONSTANT).

Page 25: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

APPLICATION OF QUEUES:

COMPUTER SIMULATION

Page 26: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

A SYSTEM IS A COLLECTION OF

INTERACTING PARTS.

Page 27: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

A MODEL IS A SIMPLIFICATION OF

A SYSTEM.

THE PURPOSE OF BUILDING A MODEL

IS TO STUDY THE UNDERLYING

SYSTEM.

Page 28: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

PHYSICAL MODEL: DIFFERS FROM

THE SYSTEM ONLY IN SCALE OR

INTENSITY.

EXAMPLES: WAR GAMES, PRE-SEASON

Page 29: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

MATHEMATICAL MODEL: A SET OF

EQUATIONS, VARIABLES, AND

ASSUMPTIONS

Page 30: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

A 500’ D

? 200’

500’ C

B 400’ E

ASSUMPTIONS: ANGLE ADC = ANGLE BCDBEC FORMS A RIGHT TRIANGLEDCE FORMS A STRAIGHT LINELINE SEGMENT AB PARALLEL TO DC

DISTANCE FROM A TO B?

Page 31: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

IF IT IS INFEASIBLE TO SOLVE THE

MATH MODEL (THAT IS, THE

EQUATIONS) BY HAND, A PROGRAM

IS DEVELOPED.

COMPUTER SIMULATION: THE

DEVELOPMENT OF COMPUTER

PROGRAMS TO SOLVE MATH MODELS

Page 32: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

DEVELOP System Computer Model

VERIFY RUN

Interpretation Output DECIPHER

Page 33: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

IF THE INTERPRETATION DOES NOTCORRESPOND TO THE BEHAVIOR OFTHE SYSTEM, CHANGE THE MODEL!

Page 34: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

FEEDBACK: A PROCESS IN WHICHTHE FACTORS THAT PRODUCE ARESULT ARE THEMSELVESAFFECTED BY THAT RESULT

HERE, THE MODEL IS AFFECTED BYITS OUTPUT.

Page 35: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

QUEUE APPLICATION

A SIMULATED CAR WASH

Page 36: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

PROBLEM:

GIVEN THE ARRIVAL TIMES ATSPEEDY’S CAR WASH, CALCULATE THEAVERAGE WAITING TIME PER CAR.

Page 37: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

ANALYSIS:

ONE WASH STATION

10 MINUTES FOR EACH CAR TO GET

WASHED

AT ANY TIME, AT MOST 5 CARS

WAITING TO BE WASHED; ANY OTHERS

TURNED AWAY AND NOT COUNTED

Page 38: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

AVERAGE WAITING TIME = SUM OF

WAITING TIMES / NUMBER OF CARS

IN A GIVEN MINUTE, A DEPARTURE IS

PROCESSED BEFORE AN ARRIVAL.

Page 39: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

IF A CAR ARRIVES WHEN NO CAR IS

BEING WASHED AND NO CAR IS

WAITING, THE CAR IMMEDIATELY

ENTERS THE WASH STATION.

A CAR STOPS WAITING WHEN IT

ENTERS THE WASH STATION.

SENTINEL IS 999.

Page 40: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

SYSTEM TEST 1:811111314161620999

Page 41: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

TIME EVENT WAITING TIME 8 ARRIVAL11 ARRIVAL11 ARRIVAL13 ARRIVAL14 ARRIVAL16 ARRIVAL16 ARRIVAL (OVERFLOW)

18 DEPARTURE 020 ARRIVAL28 DEPARTURE 738 DEPARTURE 1748 DEPARTURE 2558 DEPARTURE 3468 DEPARTURE 4278 DEPARTURE 48

Page 42: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

AVERAGE WAITING TIME

= 173 / 7.0 MINUTES

= 24.7 MINUTES

Page 43: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

CAR WASH APPLET

http://www.cs.lafayette.edu/~collinsw/carwash/car.html

Page 44: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

EXERCISE:

GIVEN THE FOLLOWING ARRIVAL

TIMES, DETERMINE THE AVERAGE

WAITING TIME:

4, 8, 12, 16, 23, 999 (the sentinel)

Page 45: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

DESIGN OF CarWash CLASS

Page 46: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

// Postcondition: This CarWash object is empty.CarWash( );

// Postcondition: all of the arrivals and departures have// been processed.void runSimulation( );

// Postcondition: the average waiting time, or an error// message, has been printed.void printResult( );

Page 47: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

FIELDS?

FIRST, WE’LL DECIDE WHAT

VARIABLES WILL BE NEEDED, AND

THEN CHOOSE THE FIELDS FROM

THOSE VARIABLES.

Page 48: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

queue<Car> carQueue;

Page 49: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

EACH ITEM IN carQueue WILL BE OF

TYPE Car. WHAT INFORMATION

ABOUT A CAR DO WE NEED?

Page 50: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

IN THE Car CLASS:

// Postcondition: the arrival time of the car just// dequeued has been returned.int getArrivalTime( );

NOTE: WE HAVE A Car CLASS FOR

THE SAKE OF LATER MODIFICATIONS

TO THE PROBLEM. FOR EXAMPLE,

THE COST OF A WASH MIGHT

DEPEND ON THE NUMBER OF AXLES.

Page 51: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

TO CALCULATE THE AVERAGE

WAITING TIME:

int numberOfCars, sumOfWaitingTimes;

Page 52: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

TO GET THE SUM OF THE WAITINGTIMES:

int waitingTime, // = currentTime – arrivalTimearrivalTime, // of car about to be washedcurrentTime;

Page 53: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

THE SIMULATION WILL BE

EVENT-BASED: IS THE NEXT EVENT AN

ARRIVAL OR A DEPARTURE?

Page 54: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

int nextArrivalTime,nextDepartureTime; // = 10000 if no car being washed

// (so next event will be an arrival)

Page 55: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

A RULE OF THUMB IS THAT A FIELD

SHOULD BE NEEDED IN MOST OF THE

CLASS’S PUBLIC METHODS.

Page 56: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

FIELDS:

int currentTime,sumOfWaitingTimes,numberOfCars,nextDepartureTime; // = 10000 if no car being washed

NOTE: carQueue IS NOT A FIELD

BECAUSE IT IS NEEDED ONLY IN THE

runSimulation METHOD.

Page 57: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

METHOD DEFINITIONS

Page 58: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

CarWash::CarWash(){ currentTime = 0; numberOfCars = 0; sumOfWaitingTimes = 0; nextDepartureTime = INFINITY; // = 10000} // default constructor

Page 59: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

void CarWash::runSimulation(){ cin >> nextArrivalTime;

while (nextArrivalTime != 999){

// If the next event is an arrival{

// Process that arrivalcin >> nextArrivalTime;

}else

// Process a departure}

// Wash any cars remaining on carQueue. } // runSimulation

Page 60: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

void CarWash::runSimulation(){ const string PROMPT = "\nPlease enter the next arrival time. The sentinel is ";

const int SENTINEL = 999;

queue<Car> carQueue;

int nextArrivalTime;

cout << PROMPT << SENTINEL << endl; cin >> nextArrivalTime;

Page 61: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

while (nextArrivalTime != SENTINEL) { if (nextArrivalTime < nextDepartureTime) { processArrival (nextArrivalTime, carQueue); cout << PROMPT << SENTINEL << endl; cin >> nextArrivalTime; } // if else processDeparture (carQueue); } // while SENTINEL not reached

// Wash any cars remaining on the carQueue. while (nextDepartureTime < INFINITY) processDeparture (carQueue);} // runSimulation

Page 62: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

// Postcondition: the car that arrived at nextArrivalTime has// either been turned away -- if carQueue// was full before this message was sent --// or has entered this CarWash.void processArrival (int nextArrivalTime, queue<Car>& carQueue){ const string OVERFLOW = "Overflow";

currentTime = nextArrivalTime; if (carQueue.size( ) == MAX_SIZE) cout << OVERFLOW << endl; else { numberOfCars++; if (nextDepartureTime == INFINITY) nextDepartureTime = currentTime + WASH_TIME; else carQueue.push (Car (nextArrivalTime)); } // not an overflow} // method processArrival

Page 63: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

// Postcondition: a car has finished getting washed and carQueue,// if non-empty, has been popped.void CarWash::processDeparture (queue<Car>& carQueue){

int waitingTime;

cout << "departure time = " << nextDepartureTime << endl; currentTime = nextDepartureTime; if (!carQueue.empty()) { Car car = carQueue.front(); carQueue.pop(); waitingTime = currentTime - car.getArrivalTime(); sumOfWaitingTimes += waitingTime; nextDepartureTime = currentTime + WASH_TIME; } // carQueue was not empty else nextDepartureTime = INFINITY;} // method processDeparture

Page 64: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

void CarWash::printResult( ){ const string NO_CARS_MESSAGE =

"There were no cars in the car wash.";

const string AVERAGE_WAITING_TIME_MESSAGE = "\nThe average waiting time, in minutes, was ";

if (numberOfCars == 0) cout << NO_CARS_MESSAGE << endl; else cout << AVERAGE_WAITING_TIME_MESSAGE << ((double)sumOfWaitingTimes / numberOfCars) << endl;} // method printResult

Page 65: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

RANDOMIZING THE ARRIVAL TIMES

Page 66: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

IF THE VALUES FOR nextArrivalTime

ARE READ IN, THE RESULTS ARE NOT

GENERALIZABLE. INSTEAD, WE

WILL READ IN

int meanArrivalTime; // the average time between arrivals

Page 67: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

THEN WE CALCULATE:

double randomDouble = rand ( ) / double (RAND_MAX + 1);

int timeTillNext = -meanArrivalTime * log (1 - randomDouble) + 0.5;

THEN currentTime IS INCREMENTED BY

timeTillNext.

Page 68: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

FOR EXAMPLE, ASSUME THAT

meanArrivalTime IS 3. IF

log (1 – randomDouble) = –0.6 AND

currentTime = 25,

WHEN WILL THE NEXT ARRIVAL

OCCUR?

Page 69: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

timeTillNext = -meanArrivalTime * log (1 - randomDouble) +0.5;

= (-3 * -0.6) + 0.5;

= 2.3

SO timeTillNext GETS THE VALUE 2, AND

THE NEXT ARRIVAL WILL OCCUR AT

TIME 25 + 2 = 27 MINUTES.

Page 70: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

STACKS

Page 71: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

A STACK IS A CONTAINER IN WHICH

IN WHICH THE ONLY ITEM THAT

CAN BE REMOVED, ACCESSED, OR

MODIFIED IS THE ITEM THAT WAS

MOST RECENTLY INSERTED.

Page 72: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

THE LAST ITEM INSERTED IS THEFIRST ITEM TO BE REMOVED. LAST-IN, FIRST-OUT (LIFO).

COMPARE WITH A QUEUE: FIRST-IN,FIRST-OUT (FIFO).

Page 73: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

TOP – THE MOST RECENTLY INSERTED

ITEM

PUSH - TO INSERT ONTO THE TOP OF A

STACK

POP - TO REMOVE THE TOP ITEM IN A

STACK

Page 74: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

START WITH AN EMPTY STACK.

PUSH “CLAYTON”.

Page 75: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

TOP CLAYTON

Page 76: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

PUSH “ERIC”.

Page 77: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

TOP ERIC

CLAYTON

Page 78: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

POP.

Page 79: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

TOP CLAYTON

Page 80: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

THE stack CLASS IS TEMPLATED:

template <class T, class Container = deque<T> >

T IS THE TEMPLATE PARAMETER

FOR THE ITEM TYPE. Container IS THE

TEMPLATE PARAMETER FOR THE

CLASS THAT WILL HOLD THE ITEMS.

Page 81: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

METHOD INTERFACES

FOR THE

stack CLASS

Page 82: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

1. // Postcondition: This stack object is empty, that is, it// contains no items.explicit stack (const Container& = Container( ));

2. // Postcondition: True has been returned if this stack // object is empty. Otherwise, false has

// been returned.bool empty( );

3. // Postcondition: The number of items in this stack // object has been returned.

unsigned size( );

Page 83: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

4. // Postcondition: x has been inserted at the top of// this stack object.void push (const T& x);

5. // Precondition: This stack object is not empty.// Postcondition: A reference to the top item on this// stack object has been returned.

T& top( );

Page 84: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

6. // Precondition: This stack object is not empty.// Postcondition: A constant reference to the top item// on this stack object has been// returned.const T& top( ) const;

7. // Precondition: This stack object is not empty.// Postcondition: The item that had been at the top of

// this stack object before this method// was called has been removed.void pop( );

Page 85: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

THERE ARE NO ITERATORS!

THE ONLY ACCESSIBLE ITEM IS THE

FRONT ITEM.

Page 86: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

DETERMINE THE OUTPUT FROM THE FOLLOWING:

stack<int> my_stack;

for (int i = 0; i < 10; i++) my_stack.push (i * i);

while (!my_stack.empty()){ cout << my_stack.top() << endl; my_stack.pop();} // while

Page 87: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

LIKE THE queue CLASS, THE stack

CLASS IS A CONTAINER ADAPTER.

THE UNDERLYING CLASS MUST HAVE

empty, size, push_back, pop_back, AND

back METHODS.

Page 88: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

SO THE vector, deque, AND list CLASSES

CAN SERVE AS THE UNDERLYING

CONTAINER CLASS.

NOTE: THE TOP ITEM ON THE

STACK IS AT THE BACK OF THE

UNDERLYING CONTAINER!

Page 89: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

HERE IS PART OF THE DEFINITION OF

THE stack CLASS:

template <class T, class Container = deque<T> >class stack{ protected: Container c;

public:

void push (const value_type& x) { c.push_back (x); }}

Page 90: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

STACK APPLICATION 1

HOW COMPILERS IMPLEMENT

RECURSION

Page 91: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

WHENEVER A FUNCTION IS CALLED,

INFORMATION IS SAVED TO

PREVENT OVERLAYING OF THAT

INFO IN CASE THE METHOD IS

RECURSIVE. THIS INFORMATION IS

COLLECTIVELY REFERRED TO AS AN

ACTIVATION RECORD OR STACK

FRAME.

Page 92: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

 

         

         

         

EACH ACTIVATION RECORD CONTAINS:

1. A VARIABLE THAT CONTAINS THE RETURN ADDRESSIN THE CALLING METHOD;

2. FOR EACH VALUE FORMAL PARAMETER, A VARIABLE THAT CONTAINS A COPY OF THE ARGUMENT;

3. FOR EACH REFERENCE FORMAL PARAMETER, A VARIABLE THAT CONTAINS THE ADDRESS OF THE ARGUMENT;

4. FOR EACH VARIABLE DEFINED IN THE METHOD’S BLOCK, A VARIABLE THAT CONTAINS A COPY OF THATDEFINED VARIABLE. 

      

Page 93: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

       

THERE IS A RUN-TIME STACK TO

HANDLE THESE ACTIVATION

RECORDS.

PUSH: WHEN FUNCTION IS CALLED

POP: WHEN EXECUTION OF FUNCTION

IS COMPLETED       

Page 94: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

AN ACTIVATION RECORD IS SIMILAR

TO AN EXECUTION FRAME, EXCEPT

THAT AN ACTIVATION RECORD HAS

VARIABLES ONLY, NO CODE.

YOU CAN REPLACE RECURSION WITH

ITERATION BY CREATING YOUR OWN

STACK.

Page 95: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

RECALL FROM CHAPTER 4: DECIMALTO BINARY:

// Precondition: n >= 0.// Postcondition: The binary equivalent of n has been// printed. The worstTime(n) is O(log n).void writeBinary (int n){ if (n == 0 || n == 1) cout << n; else { writeBinary (n / 2); cout << n % 2; } // else} // writeBinary

Page 96: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

HERE IS A STACK-BASED VERSION:

void writeBinary (int n){ stack<int> myStack; myStack.push (n); while (n > 1)

{ n = n / 2; myStack.push (n); } // pushing while (!myStack.empty())

{ n = myStack.top(); myStack.pop(); cout << (n % 2); } // popping cout << endl << endl;} // method writeBinary

Page 97: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

EXERCISE: TRACE THE EXECUTION

OF THE ABOVE FUNCTION AFTER

AN INITIAL CALL OF

writeBinary (20);

SHOW THE CONTENTS OF myStack.

Page 98: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

STACK APPLICATION 2

CONVERTING FROM

INFIX TO POSTFIX

Page 99: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

IN INFIX NOTATION, AN OPERATOR IS

PLACED BETWEEN ITS OPERANDS.

a + b

c – d + (e * f – g * h) / i

Page 100: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

OLD COMPILERS:

INFIX MACHINE LANGUAGE

THIS GETS MESSY BECAUSE OF PARENTHESES.

NEWER COMPILERS:

INFIX POSTFIX MACHINE LANGUAGE

Page 101: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

IN POSTFIX NOTATION, AN OPERATOR IS PLACED IMMEDIATELY AFTER ITS OPERANDS.

INFIX

POSTFIX

a + b

ab+

a + b * c

abc*+

a * b + c

ab*c+

(a + b) * c

ab+c*

Page 102: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

PARENTHESES ARE NOT NEEDED,

AND NOT USED, IN POSTFIX.

Page 103: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

LET’S CONVERT AN INFIX STRING TO

A POSTFIX STRING. 

   x – y * z   

Page 104: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

POSTFIX PRESERVES THE ORDER OF

OPERANDS, SO AN OPERAND CAN BE

APPENDED TO POSTFIX AS SOON AS

THAT OPERAND IS ENCOUNTERED IN

INFIX.

Page 105: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

INFIX POSTFIX

x – y * z x

Page 106: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

INFIX POSTFIX

x – y * z x

THE OPERANDS FOR ‘-’ ARE NOT YET

IN POSTFIX, SO ‘-’ MUST BE

TEMPORARILY SAVED SOMEWHERE.

Page 107: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

INFIX POSTFIX

x – y * z xy

Page 108: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

INFIX POSTFIX

x – y * z xy

THE OPERANDS FOR ‘*’ ARE NOT YET

IN POSTFIX, SO ‘*’ MUST BE

TEMPORARILY SAVED SOMEWHERE,

AND RESTORED BEFORE ‘-’.

Page 109: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

INFIX POSTFIX

x – y * z xyz

Page 110: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

INFIX POSTFIX

x – y * z xyz* –

Page 111: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

SUPPOSE, INSTEAD, WE STARTED WITH

x*y-z. AFTER MOVING ‘x’ TO POSTFIX,

‘*’ IS TEMPORARILY SAVED, AND THEN

‘y’ IS APPENDED TO POSTFIX. WHAT

HAPPENS WHEN ‘-’ IS ACCESSED?

INFIX POSTFIX

x * y – z xy

Page 112: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

THE ‘*’ MUST BE MOVED TO POSTFIX

NOW, BECAUSE BOTH OF THE

OPERANDS FOR ‘*’ ARE ON POSTFIX.

THEN THE ‘-’ MUST BE SAVED

TEMPORARILY. AFTER ‘z’ IS MOVED

TO POSTFIX, ‘-’ IS MOVED TO

POSTFIX, AND WE ARE DONE.

INFIX POSTFIXx * y – z xy*z–

Page 113: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

THE TEMPORARY STORAGE FACILITY

IS A STACK.

HERE IS THE STRATEGY FOR

MAINTAINING THE STACK:

Page 114: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

FOR EACH OPERATOR IN INFIX: LOOP UNTIL OPERATOR PUSHED: IF OPERATOR STACK IS EMPTY,

PUSH ELSE IF INFIX OPERATOR HAS GREATER PRECEDENCE

THAN TOP OPERATORON STACK,

PUSH ELSE

POP AND APPEND TO POSTFIX

Page 115: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

INFIX GREATER, PUSH

Page 116: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

CONVERT FROM INFIX TO POSTFIX:

INFIX POSTFIX

a + b * c / d - e

Page 117: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

INFIX POSTFIX

a + b * c / d – e abc*d/+e –

-

/

*

+

OPERATOR STACK

Page 118: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

WHAT ABOUT PARENTHESES?

LEFT PARENTHESIS: PUSH, BUT

WITH LOWEST PRECEDENCE.

RIGHT PARENTHESIS:KEEP POPPING

AND APPENDING TO POSTFIX UNTIL

‘(‘ POPPED; PITCH ‘(‘ AND PROCEED.

Page 119: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

CONVERT TO POSTFIX:

x * (y + z)

Page 120: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

INFIX POSTFIXx * (y + z) xyz+*

+ ( *

OPERATOR STACK

Page 121: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

INFIX POSTFIXx * (y + z – (a / b + c) * d) / e

OPERATOR STACK

Page 122: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

TO DECIDE WHAT ACTION TO TAKE IN

CONVERTING FROM INFIX TO

POSTFIX, ALL WE NEED TO KNOW IS

THE CURRENT CHARACTER IN INFIX

AND THE TOP CHARACTER ON

OPERATOR STACK.

Page 123: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

THE FOLLOWING TRANSITION

MATRIX SPECIFIES THE TRANSITION

FROM INFIX NOTATION TO POSTFIX

NOTATION:

Page 124: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

TOP CHARACTER ON STACK ( +,- *,/ emptyI

N identifierF

I )X ( +,-C

H *,/A

R empty

APPEND APPEND APPEND APPEND TO TO TO TOPOSTFIX POSTFIX POSTFIX POSTFIX

POP; POP TO POP TO ERRORPITCH ‘(‘ POSTFIX POSTFIXPUSH PUSH PUSH PUSH

PUSH POP TO POP TO PUSH POSTFIX POSTFIX

PUSH PUSH POP TO PUSH POSTFIXERROR POP TO POP TO DONE POSTFIX POSTFIX

Page 125: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

TOKENS

Page 126: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

A TOKEN IS THE SMALLEST

MEANINGFUL UNIT IN A PROGRAM.

EACH TOKEN HAS TWO PARTS:

A GENERIC PART, FOR THE

CATEGORY OF THE TOKEN;

A SPECIFIC PART, TO ACCESS

THE CHARACTERS IN THE TOKEN.

Page 127: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

FOR EXAMPLE:

// index 35 in symbol table

add_op +, -

identifier 35

Page 128: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

INFIX-TO-POSTFIX APPLET

http://www.cs.lafayette.edu/~collinsw/infix/infix.html

Page 129: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

IN PREFIX NOTATION, AN OPERATOR

IMMEDIATELY PRECEDES ITS

OPERANDS.

Page 130: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

INFIX PREFIXa + b +ab

a * (b + c) *a+bc

a * b + c +*abc

IN PREFIX NOTATION, AS IN POSTFIX,

THERE ARE NO PARENTHESES.

Page 131: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

TWO STACKS ARE USED:

OPERATOR STACK: SAME RULES AS

FOR POSTFIX STACK

OPERAND STACK: TO HOLD THE

OPERANDS

Page 132: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

WHENEVER opt IS POPPED FROM

OPERATOR STACK, opd1 AND THEN

opd2 ARE POPPED FROM OPERAND

STACK. THE STRING opt + opd2 + opd1

IS PUSHED ONTO OPERAND STACK.

NOTE: opd2 WAS PUSHED BEFORE opd1.

Page 133: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

CONVERT FROM INFIX TO PREFIX:

INFIXa + (b * c – d) / e

Page 134: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

INFIX PREFIXa + (b * c – d) / e +a/– *bcde

+a/– *bcde /– *bcde e –*bcd d / *bc – c * b (

a + OPERAND OPERATOR

STACK STACK

Page 135: PUSH “MATT” MATT FRONTBACK PUSH “ANDREW” MATT FRONT ANDREW BACK.

EXERCISE: CONVERT TO PREFIX

a – b + c * (d / e – (f + g))