unit 4: stacks and queues · 1 stacks 1 stacks in stl 1 case study: exiting a maze 1 queues engi...

Unit 4: Stacks and Queues

Engineering 4892:Data Structures

Faculty of Engineering & Applied ScienceMemorial University of Newfoundland

June 1, 2011

ENGI 4892 (MUN) Unit 4 June 1, 2011 1 / 24

1 Stacks

1 Stacks in STL

1 Case study: exiting a maze

1 Queues

Stacks

A stack is a list of items accessed only through one end of the list.

It issometimes referred to as a LIFO structure, meaning last in / first out.

A stack is sometimes visualized as growing upwards, like a real “stack” oftrays in a cafeteria. Hence, the accessible end of the stack is referred to asthe top of the stack.

Stack operations:

clear() Emptys the stack.

isEmpty() Checks to see if the stack is empty.

push(el) Puts the element el on top of the stack.

pop() Takes the top-most element off the stack.

topEl() Returns the top-most element, without removing it.

Stacks

A stack is a list of items accessed only through one end of the list. It issometimes referred to as a LIFO structure, meaning last in / first out.

Stack operations:

Stacks

A stack is sometimes visualized as growing upwards, like a real “stack” oftrays in a cafeteria.

Hence, the accessible end of the stack is referred to asthe top of the stack.

Stack operations:

Stacks

Stack operations:

Stacks

Stack operations:

Stacks

Stack operations:

Stacks

Stack operations:

Stacks

Stack operations:

Stacks

Stack operations:

Stacks

Stack operations:

Demonstration of stack operations:

Stacks are useful when we need to store data and then access it again inreverse order.

e.g. Matching delimiters in C++. In C++ the following delimeters mustexist in matched pairs: ( ) [ ] { }

Matching pairs of delimeters can be nested within each other. We canmatch a pair only after all the delimeters between them have been dealtwith.

e.g. Matching delimiters in C++.

In C++ the following delimeters mustexist in matched pairs: ( ) [ ] { }

Matching pairs of delimeters can be nested within each other.

We canmatch a pair only after all the delimeters between them have been dealtwith.

The following algorithm (given in pseudocode) matches delimeters using astack to store each delimeter until its mate is found:

delimeterMatching(file)

while not end-of-file

read character ch from file;

if ch is ‘(’, ‘[’, or ‘{’push(ch);

else if ch is ‘)’, ‘]‘, or ‘}’if stack is empty

failure;

mate = pop();

if ch and mate do not match

failure;

if stack is empty

success;

failure;

(Note that this algorithm does not handle comments appropriately.)

failure;

mate = pop();

failure;

if stack is empty

success;

failure;

mate = pop();

failure;

if stack is empty

success;

failure;

mate = pop();

failure;

if stack is empty

success;

failure;

if ch is ‘(’, ‘[’, or ‘{’

push(ch);

failure;

mate = pop();

failure;

if stack is empty

success;

failure;

mate = pop();

failure;

if stack is empty

success;

failure;

else if ch is ‘)’, ‘]‘, or ‘}’

if stack is empty

failure;

mate = pop();

failure;

if stack is empty

success;

failure;

mate = pop();

failure;

if stack is empty

success;

failure;

mate = pop();

failure;

if stack is empty

success;

failure;

mate = pop();

failure;

if stack is empty

success;

failure;

mate = pop();

failure;

if stack is empty

success;

failure;

mate = pop();

failure;

if stack is empty

success;

failure;

mate = pop();

failure;

if stack is empty

success;

failure;

mate = pop();

failure;

if stack is empty

success;

failure;

mate = pop();

failure;

if stack is empty

success;

failure;

mate = pop();

failure;

if stack is empty

success;

failure;

mate = pop();

failure;

if stack is empty

success;

failure;

e.g. s=t[5]+u/(v∗(w+y));

Another example application of stacks involves the addition of very largenumbers. The sum,

234,123,574,345,123,050,433 + 1,122,344,556,413,666,990,000,121

...does not fit in an int. This can be addressed by breaking each numberinto its numerals and putting these numerals on a stack.

Addition then involves an operation on two stacks with one stack as anoutput (representing the result).

First, each number is broken into numerals and these are pushed onto thestack in order of decreasing significance.

234,123,574,345,123,050,433 + 1,122,344,556,413,666,990,000,121

...does not fit in an int.

This can be addressed by breaking each numberinto its numerals and putting these numerals on a stack.

234,123,574,345,123,050,433 + 1,122,344,556,413,666,990,000,121

addingLargeNumbers()

read the first number and push onto stack1;

read the second number and push onto stack2;

result = 0;

while at least one stack is not empty

if stack1 is not empty

result += stack1.pop();

push the unit part of result onto output stack ;

result = the 10’s part of result;

push result onto output stack if non-zero ;

pop numerals from output stack and display them ;

The application of addingLargeNumbers to the addition of 592 and 3784is shown on the following slide...

result = 0;

Stacks in STL

STL defines a generic stack class called stack.

By default, it is anadaptation of the doubly-ended queue class deque. However, it can becustomized to use a DLL (represented in STL as a list) or an array(represented in STL as a vector) as its underlying implementation:

stack<int> stack1 ; // deque by d e f a u l tstack<int , vector<int> > stack2 ; // v e c t o r ( i . e . a r r a y )stack<int , list<int> > stack3 ; // l i s t ( i . e . DLL)

Stacks in STL

STL defines a generic stack class called stack. By default, it is anadaptation of the doubly-ended queue class deque.

However, it can becustomized to use a DLL (represented in STL as a list) or an array(represented in STL as a vector) as its underlying implementation:

Stacks in STL

STL defines a generic stack class called stack. By default, it is anadaptation of the doubly-ended queue class deque. However, it can becustomized to use a DLL (represented in STL as a list) or an array(represented in STL as a vector) as its underlying implementation:

Stacks in STL

stack<int> stack1 ; // deque by d e f a u l t

stack<int , vector<int> > stack2 ; // v e c t o r ( i . e . a r r a y )stack<int , list<int> > stack3 ; // l i s t ( i . e . DLL)

Stacks in STL

stack<int> stack1 ; // deque by d e f a u l tstack<int , vector<int> > stack2 ; // v e c t o r ( i . e . a r r a y )

stack<int , list<int> > stack3 ; // l i s t ( i . e . DLL)

Stacks in STL

STL defines all of the expected stack operations.

However, pop onlyremoves the top element—it does not return it. The following Stack classcan be used to obtain the usual popping behaviour:

template<class T>class Stack : public stack<T> {public :

T pop ( ) {T tmp = stack<T> : : top ( ) ;stack<T> : : pop ( ) ;return tmp ;

STL defines all of the expected stack operations. However, pop onlyremoves the top element—it does not return it.

The following Stack classcan be used to obtain the usual popping behaviour:

STL defines all of the expected stack operations. However, pop onlyremoves the top element—it does not return it. The following Stack classcan be used to obtain the usual popping behaviour:

template<class T>class Stack : public stack<T> {

public :T pop ( ) {

T tmp = stack<T> : : top ( ) ;stack<T> : : pop ( ) ;return tmp ;

T pop ( ) {T tmp = stack<T> : : top ( ) ;

stack<T> : : pop ( ) ;return tmp ;

T pop ( ) {T tmp = stack<T> : : top ( ) ;stack<T> : : pop ( ) ;

return tmp ;}

Case study: exiting a mazeConsider a mouse trapped in a maze, trying to find the exit:

This mouse can only move right, left, down, or up—one step at a time. Itapplies the following procedure:

Try moving right, left, down, and up

If a route beginning with any one of these fails, try a new route thatstarts in an untried direction

A stack is used to remember untried positions and to organize the order inwhich these positions are attempted.

This mouse can only move right, left, down, or up—one step at a time.

Itapplies the following procedure:

The maze is implemented as a 2D array of char’s

1 = wall

0 = open

m = mouse’s initial position

e = exit (could be anywhere)

. = visited location

We assume the boundaries of the array are either walls or the exit.

1 = wall

0 = open

1 = wall

0 = open

1 = wall

0 = open

1 = wall

0 = open

1 = wall

0 = open

1 = wall

0 = open

The following is the pseudocode for the mouse’s stack-based solution:

exitMaze()

initialize stack;

currentCell = entryCell;

while currentCell != exitCell

mark currentCell as visited ;

push onto stack currentCell’s unvisited neighbours;

if stack is empty

failure;

currentCell = stack.pop();

success;

Unvisited neighbours are pushed in the following order: up, down, left, andright. The order in which neighbours are visited will be opposite: right,left, down, and up.

The stack stores the row and column of each cell that remains to beexplored.

exitMaze()

initialize stack;

if stack is empty

failure;

success;

exitMaze()

initialize stack;

if stack is empty

failure;

success;

exitMaze()

initialize stack;

if stack is empty

failure;

success;

exitMaze()

initialize stack;

if stack is empty

failure;

success;

exitMaze()

initialize stack;

if stack is empty

failure;

success;

exitMaze()

initialize stack;

if stack is empty

failure;

success;

exitMaze()

initialize stack;

if stack is empty

failure;

success;

exitMaze()

initialize stack;

if stack is empty

failure;

success;

exitMaze()

initialize stack;

if stack is empty

failure;

success;

exitMaze()

initialize stack;

if stack is empty

failure;

success;

exitMaze()

initialize stack;

if stack is empty

failure;

success;

Unvisited neighbours are pushed in the following order:

up, down, left, andright. The order in which neighbours are visited will be opposite: right,left, down, and up.

exitMaze()

initialize stack;

if stack is empty

failure;

success;

Unvisited neighbours are pushed in the following order: up, down, left, andright.

The order in which neighbours are visited will be opposite: right,left, down, and up.

exitMaze()

initialize stack;

if stack is empty

failure;

success;

exitMaze()

initialize stack;

if stack is empty

failure;

success;

Consider the following example:

Here is part of the C++ implementation:

void Maze : : pushUnvisited ( int row , int col ) {if ( store [ row ] [ col ] == passage | | store [ row ] [ col ] == exitMarker ) {

mazeStack . push ( Cell ( row , col ) ) ;}

void Maze : : exitMaze ( ) {int row , col ;currentCell = entryCell ;while ( ! ( currentCell == exitCell ) ) {

row = currentCell . x ;col = currentCell . y ;cout << ∗this ; // p r i n t a snapshot ;if ( ! ( currentCell == entryCell ) )

store [ row ] [ col ] = visited ;pushUnvisited ( row−1,col ) ;pushUnvisited ( row+1,col ) ;pushUnvisited ( row , col−1);pushUnvisited ( row , col+1);if ( mazeStack . empty ( ) ) {

cout << ∗this ;cout << "Failure\n" ;return ;

}else currentCell = mazeStack . pop ( ) ;

}cout << ∗this ;cout << "Success\n" ;

}void Maze : : exitMaze ( ) {

int row , col ;currentCell = entryCell ;

while ( ! ( currentCell == exitCell ) ) {row = currentCell . x ;col = currentCell . y ;cout << ∗this ; // p r i n t a snapshot ;if ( ! ( currentCell == entryCell ) )

int row , col ;currentCell = entryCell ;while ( ! ( currentCell == exitCell ) ) {

row = currentCell . x ;col = currentCell . y ;

cout << ∗this ; // p r i n t a snapshot ;if ( ! ( currentCell == entryCell ) )

row = currentCell . x ;col = currentCell . y ;cout << ∗this ; // p r i n t a snapshot ;

if ( ! ( currentCell == entryCell ) )store [ row ] [ col ] = visited ;

pushUnvisited ( row−1,col ) ;pushUnvisited ( row+1,col ) ;pushUnvisited ( row , col−1);pushUnvisited ( row , col+1);if ( mazeStack . empty ( ) ) {

store [ row ] [ col ] = visited ;

pushUnvisited ( row−1,col ) ;pushUnvisited ( row+1,col ) ;pushUnvisited ( row , col−1);pushUnvisited ( row , col+1);if ( mazeStack . empty ( ) ) {

store [ row ] [ col ] = visited ;pushUnvisited ( row−1,col ) ;pushUnvisited ( row+1,col ) ;pushUnvisited ( row , col−1);pushUnvisited ( row , col+1);

if ( mazeStack . empty ( ) ) {cout << ∗this ;cout << "Failure\n" ;return ;

else currentCell = mazeStack . pop ( ) ;}cout << ∗this ;cout << "Success\n" ;

Queues

A queue is essentially a line-up.

Items are added to the back of the queueand are later accessed from the front. A queue is sometimes referred to asa FIFO structure, meaning first in / first out.

Queue operations:

clear() Emptys the queue.

isEmpty() Checks to see if the queue is empty.

enqueue(el) Puts the element el at the end of the queue.

dequeue() Takes the first element from the queue.

firstEl() Returns the top-most element, without removing it.

Queues

A queue is essentially a line-up. Items are added to the back of the queueand are later accessed from the front.

A queue is sometimes referred to asa FIFO structure, meaning first in / first out.

Queue operations:

Queues

A queue is essentially a line-up. Items are added to the back of the queueand are later accessed from the front. A queue is sometimes referred to asa FIFO structure, meaning first in / first out.

Queue operations:

Queues

Queue operations:

Queues

Queue operations:

Queues

Queue operations:

Queues

Queue operations:

Queues

Queue operations:

Queues

Queue operations:

Demonstration of queue operations:

A queue can be implemented efficiently as a doubly-linked list. If thequeue has a fixed maximum size, it can also be implemented as an array.

The array-based implementation uses two indices, first and last to keeptrack of the position of the queue within the array...

A queue can be implemented efficiently as a doubly-linked list.

If thequeue has a fixed maximum size, it can also be implemented as an array.

How do we represent the empty queue?

first = −1, last = −1

How do we tell if the queue is full?

If first happens to be at 0, the queue is full if last == size−1.

If first > 0, the queue is full if last == first − 1

The following is the code for an array-based queue...

How do we represent the empty queue? first = −1, last = −1

If first happens to be at 0, the queue is full if

last == size−1.

If first > 0, the queue is full if

last == first − 1

template<class T , int size = 100>class ArrayQueue {

public :ArrayQueue ( ) {

first = last = −1;}void enqueue (T ) ;T dequeue ( ) ;bool isFull ( ) {

return first == 0 && last == size−1 | |first == last + 1 ;

}bool isEmpty ( ) {

return first == −1;}

private :int first , last ;T storage [ size ] ;

Consider the operation of enqueueing...

template<class T , int size = 100>class ArrayQueue {public :

ArrayQueue ( ) {first = last = −1;

void enqueue (T ) ;T dequeue ( ) ;bool isFull ( ) {

}bool isEmpty ( ) {

}void enqueue (T ) ;T dequeue ( ) ;

bool isFull ( ) {return first == 0 && last == size−1 | |

first == last + 1 ;}bool isEmpty ( ) {

}void enqueue (T ) ;T dequeue ( ) ;bool isFull ( ) {

bool isEmpty ( ) {return first == −1;

}private :

int first , last ;T storage [ size ] ;

}bool isEmpty ( ) {

Consider the operation of enqueueing...ENGI 4892 (MUN) Unit 4 June 1, 2011 21 / 24

Check if queue is full

In general,

Increment lastPlace element in storage[last]

If last is at the end of the array,

Set last = 0Place element in storage[last]

Special case: Enqueueing into an empty queue. This can be handled likethe second case, but we must also set first = 0.

template<class T , int size>void ArrayQueue<T , size> : : enqueue (T el ) {

if ( ! isFull ( ) )if ( last == size−1 | | last == −1) {

storage [ 0 ] = el ;last = 0 ;if ( first == −1)

first = 0 ;}else storage[++last ] = el ;

else cout << "Full queue.\n" ;}

Check if queue is fullIn general,

Increment last

Place element in storage[last]If last is at the end of the array,

If last is at the end of the array,Set last = 0

Place element in storage[last]

If last is at the end of the array,Set last = 0Place element in storage[last]

Special case: Enqueueing into an empty queue.

This can be handled likethe second case, but we must also set first = 0.

if ( ! isFull ( ) )

if ( last == size−1 | | last == −1) {storage [ 0 ] = el ;last = 0 ;if ( first == −1)

storage [ 0 ] = el ;

last = 0 ;if ( first == −1)

storage [ 0 ] = el ;last = 0 ;

if ( first == −1)first = 0 ;

}else storage[++last ] = el ;

first = 0 ;}

else storage[++last ] = el ;else cout << "Full queue.\n" ;

Consider the operation of dequeueing:

Store the value of the first elementIn general,

Increment first

If first is at the end of the array,

Set first = 0

Special cases

Dequeueing the last element. Handled by setting first = last = −1

Dequeueing on the empty queue. Forbidden by precondition.

template<class T , int size>T ArrayQueue<T , size> : : dequeue ( ) {

T tmp ;tmp = storage [ first ] ;if ( first == last )

last = first = −1;else if ( first == size−1)

first = 0 ;else first++;return tmp ;

Store the value of the first element

In general,

Increment first

Set first = 0

Special cases

Increment firstIf first is at the end of the array,

Set first = 0

Special cases

Increment first

Set first = 0

Special cases

Set first = 0

Special cases

Set first = 0

Special cases

Set first = 0

Special cases

Set first = 0

Special cases

Dequeueing the last element.

Handled by setting first = last = −1

Set first = 0

Special cases

Dequeueing the last element.

Handled by setting first = last = −1

Set first = 0

Special cases

Set first = 0

Special cases

Dequeueing on the empty queue.

Forbidden by precondition.

Set first = 0

Special cases

Dequeueing on the empty queue.

Forbidden by precondition.

Set first = 0

Special cases

Set first = 0

Special cases

Set first = 0

Special cases

Set first = 0

Special cases

T tmp ;tmp = storage [ first ] ;

if ( first == last )last = first = −1;

else if ( first == size−1)first = 0 ;

else first++;return tmp ;

Set first = 0

Special cases

last = first = −1;

else if ( first == size−1)first = 0 ;

Set first = 0

Special cases

first = 0 ;

Set first = 0

Special cases

first = 0 ;else first++;

return tmp ;}

Set first = 0

Special cases

The following shows how the storage array changes as operations occur:

The top figure shows the operations on an abstract queue. The bottomfigure shows the operations on an ArrayQueue (the array is shownupside-down).

The top figure shows the operations on an abstract queue.

The bottomfigure shows the operations on an ArrayQueue (the array is shownupside-down).

unit 4: stacks and queues · 1 stacks 1 stacks in stl 1 case study: exiting a maze 1 queues engi...

Documents