05 (Stack Queue)

Page 1National University

Stack and

QueueThis lecture prepared by the instructors at the University of Manitoba in Canada and has

been modified by Dr. Ahmad Reza Hadaegh


Abstract Data Types

You have been introduced to some of the benefits of implementing programs with C++ classes such as

– Data and function hiding– Reusability and reliability


Abstract Data Types

A C++ class is often the manner in which an abstract data type (ADT) is implemented– An ADT is a data structure together with a set of

defined operations Data structure is exclusively manipulated by

operations, and operations work exclusively on data structure


Abstract Data Types Two common introductory ADT that worth studying

are:

Stack and Queue

Many problems (or parts of problems) can be thought of as stack problems, queue problems, or other problems that can be solved with the help of another (perhaps user-defined) ADT

– Decide what ADTs you need, build them, test them, then tackle your larger problem


A stack is an ADT with specific properties and operations

Stack ADT


Stack ADT

Stack properties are:– Only one item can be accessed at a time

Always the last item inserted (LIFO)– New items must be inserted at the top– The size of the stack is dynamic

The stack must be able to grow and shrink– Implementation?

– Normally, items stored on the stack are homogeneous


Stack ADT

Stack operations are:– Push - put a new item on the top of the stack– Pop - remove top item from stack

Can’t pop an empty stack– Top - examine top item without modifying stack

Can’t top an empty stack– Init - Set existing stack to empty


Stack ADT

Two more possible operations:– Full - determine if stack has reached capacity

Implementation?– Empty - determine if stack is empty


Stack ADT Many problems can be solved using stacks

– Given a mathematical expression with 3 types of “brackets” ( ) [ ] { }

Determine if the brackets are properly matched

{ 5 * (8-2) } / { [4 * (3+2)] + [5 * 6] }

{ (A+C) * D

[ A + {B+C} )

OK!

Not OK!


Stack ADT

– This is easily solved with a stack– Algorithm:

Scan expression from left to right Each time a left bracket is encountered, push

it onto the stack When a right bracket is encountered,

compare it to the top item on the stack– If it’s a match, pop the stack

– If not, report illegal bracketing


Stack ADT

If the stack is prematurely empty, report illegal bracketing

If there are items left on the stack after the expression has been scanned, report illegal bracketing


Stack ADT

– Assume the following member functions are available for our character stack ADT bool empty (); push (item); // Modifies stack char pop (); // Modifies stack char top ();


Stack ADT// Stack routines included here for stack of characters

void main () {

char curr, temp;bool valid = true; // Assume expression has valid

// bracketingcstack bracket_stack;

Don’t care about stack implementation -can focus attention instead on howto solve the problem


Stack ADT cin >> curr; // Assume no blanks in input expression while (curr != ‘\n’ && valid) { if (curr == ‘(’ || curr == ‘[’ || curr == ‘{’) bracket_stack.push (curr); else if (curr == ‘)’ || curr == ‘]’ || curr == ‘}’) if (bracket_stack.empty() ) then valid = false; else if (bracket_stack.pop() does not mate with curr) valid = false; cin >> curr; } // while


Stack ADT

if (!bracket_stack.empty()) valid = false; if (valid) cout << “Bracketing -- GOOD” << endl; else cout << “Bracketing -- BAD” << endl; } // main


Stack ADT

The recognition that bracket matching is a stack problem results in the solution being trivial– Solution will also have closer consistency cross

programmers– Stack can be reused in other problems– Implementation of stack can change, but

solution to bracket problem remains the same


More Stacks

Consider the problem of evaluating an arithmetic expression using a stack– Traditionally, when we write an arithmetic

expression as follows 2 + 3 * (6 - 5)

– This is known as infix notation Operators are in-between the operands


More Stacks

– When computing arithmetic expressions, it’s sometimes useful to represent them using postfix (operator after) or prefix (operator before) notation


More Stacks

Prefix Infix Postfix

- 6 1* + 4 3 2

/ + 2 3 - 9 4

6 - 1(4 + 3) * 2

(2 + 3) / (9 - 4)

6 1 -4 3 + 2 *

2 3 + 9 4 - /

It’s easy to evaluate postfix and prefix expressionsusing a stack -- in part because no brackets are necessary


More Stacks

– E.g.

prefix postfix

- 6 1

61

6 1 -

16

evaluate

- - 55

(push, push,pop, pop, apply, push,)

(push, push,pop, pop, apply, push,)


More Stacks E.g.

prefix postfix

* + 4 3 2

432

4 3 + 2 *

34

evaluate

1472

+* + 7

27 14*

(push, push, push,pop, pop, apply, push,pop, pop, apply, push)

(push, push,pop, pop, apply, push,push,pop, pop, apply, push)


More Stacks

– Algorithm for evaluating postfix Parse expression from left to right When an operand is encountered, push it

onto the stack When an operator is encountered, pop the

top two operands, apply the operator, and push the result onto the stack

When the expression is completely scanned, the final result will be on the stack

– Code left as an exercise Very straight-forward if stack already exists


More Stacks

– What if we want to convert and expression from infix to postfix?

– 2 + 3 * [(5 - 6) / 2] becomes 2 3 5 6 - 2 / * +– Use the following algorithm:

Scan infix string from left to right Each time an operand is encountered, copy it

to the output When a bracket is encountered, check its

orientation.


More Stacks

– Push left brackets onto the stack– If it’s a right bracket, pop all operators on

the stack and copy them to output until a matching left bracket is encountered. Discard the left bracket.

When an operator is encountered, check the top item of the stack.

– If the priority is >= the current operator, pop the top operator and copy it to output

– Continue until an operator of lesser priority is encountered or until stack is empty


More Stacks

– Assume left brackets have lowest priority– Finally, push current operator onto the

stack– When the end of the expression is

reached, copy the remaining stack contents to output in the order popped


Queues A queue is an ADT with the following

specific properties:– A queue contains zero or more, normally

homogenous, items– Data items are added to the tail (back) of the

queue and are removed from the head (front) of the queue

– The items in the queue are maintained in FIFO (first-in-first-out) order The first item placed on the queue is always

the first one removed


Queues

Data In Data Out

Queue

tail head

. . . .


Queues Possible operations

– Init Initializes a queue so as to be empty

– Insert Adds a new item to the tail of the queue

– Remove Removes the item at the head of the queue

– Empty Tests to see if the queue is empty

– Full Tests to see if the queue is full


Queues

Basic queues are similar to basic stacks– Similar operations– Only allow access to one data item at a time– Dynamic in nature– Have implementation dependencies


Queues

– Can be modified to suit the needs of specific problems Priority queues

– A not quite so democratic queue (more in a bit)

– Are all around us ...


Queues

Cashier


Queues

Queues are common in computing– Scheduling queues

Operating systems support multi-tasking by sharing scarce resources such as CPU time

Each task that requests CPU resources might be put in a queue

Tasks are given cycles of time– If task finishes …. good -- if not, task goes

to back of queue for additional cycles


Queues

– Multiple queues Might have many queues, each of which

have different priority– Before second queue is processed, all

jobs in first queue must be processed– Before third queue is processed, all

jobs in second queue must be processed, etc

The same idea as a priority queue ...


Queues

– UNIX uses a priority queue to schedule processes Priority is based upon many factors

– The “niceness” of the processes– A number from 0-127 (127 being very

nice to other users)– See “man nice”

– Recent CPU usage of process– Time process has been waiting for a cycle

A priority queue is somewhat like a cross between a table and a queue

Date post:	08-Apr-2016
Category:	Documents
Upload:	frankjamison
View:	17 times
Download:	3 times

05 (Stack Queue)

Documents