Unit 4: Stacks and Queues

Size: px

Start display at page:

Download "Unit 4: Stacks and Queues"

Jayson Peters
5 years ago
Views:

1 Unit 4: Stacks and Queues Engineering 4892: Data Structures Faculty of Engineering & Applied Science Memorial University of Newfoundland June 1, 2011 ENGI 4892 (MUN) Unit 4 June 1, / 24

2 1 Stacks 1 Stacks in STL 1 Case study: exiting a maze 1 Queues ENGI 4892 (MUN) Unit 4 June 1, / 24

3 Stacks A stack is a list of items accessed only through one end of the list. It is sometimes referred to as a LIFO structure, meaning last in / first out. A stack is sometimes visualized as growing upwards, like a real stack of trays in a cafeteria. Hence, the accessible end of the stack is referred to as the 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. ENGI 4892 (MUN) Unit 4 June 1, / 24

Demonstration of stack operations: Stacks are useful when we need to store data and then access it again in reverse order. e.g. Matching delimiters in C++.

4 Demonstration of stack operations: Stacks are useful when we need to store data and then access it again in reverse order. e.g. Matching delimiters in C++. In C++ the following delimeters must exist in matched pairs: ( ) [ ] { } Matching pairs of delimeters can be nested within each other. We can match a pair only after all the delimeters between them have been dealt with. ENGI 4892 (MUN) Unit 4 June 1, / 24

5 The following algorithm (given in pseudocode) matches delimeters using a stack 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; else failure; (Note that this algorithm does not handle comments appropriately.)

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

7 Another example application of stacks involves the addition of very large numbers. The sum, 234,123,574,345,123,050, ,122,344,556,413,666,990,000,121...does not fit in an int. This can be addressed by breaking each number into its numerals and putting these numerals on a stack. Addition then involves an operation on two stacks with one stack as an output (representing the result). First, each number is broken into numerals and these are pushed onto the stack in order of decreasing significance. ENGI 4892 (MUN) Unit 4 June 1, / 24

8 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(); if stack2 is not empty result += stack2.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 3784 is shown on the following slide...

10 Stacks in STL STL defines a generic stack class called stack. By default, it is an adaptation of the doubly-ended queue class deque. However, it can be customized 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 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) ENGI 4892 (MUN) Unit 4 June 1, / 24

11 STL defines all of the expected stack operations. However, pop only removes the top element it does not return it. The following Stack class can 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 ; } } ; ENGI 4892 (MUN) Unit 4 June 1, / 24

12 A stack is used to remember untried positions and to organize the order in which these positions are attempted. Case study: exiting a maze Consider 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. It applies the following procedure: Try moving right, left, down, and up If a route beginning with any one of these fails, try a new route that starts in an untried direction

13 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.

14 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; else currentcell = stack.pop(); success; Unvisited neighbours are pushed in the following order: up, down, left, and right. 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 be explored.

15 Consider the following example:

16 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 s n a p s h o t ; 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" ; } ENGI 4892 (MUN) Unit 4 June 1, / 24

17 Queues A queue is essentially a line-up. Items are added to the back of the queue and are later accessed from the front. A queue is sometimes referred to as a 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. ENGI 4892 (MUN) Unit 4 June 1, / 24

18 Demonstration of queue operations: A queue can be implemented efficiently as a doubly-linked list. If the queue has a fixed maximum size, it can also be implemented as an array. The array-based implementation uses two indices, first and last to keep track of the position of the queue within the array... ENGI 4892 (MUN) Unit 4 June 1, / 24

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

20 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... ENGI 4892 (MUN) Unit 4 June 1, / 24

21 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... ENGI 4892 (MUN) Unit 4 June 1, / 24

22 Check if queue is full In general, Increment last Place element in storage[last] If last is at the end of the array, Set last = 0 Place element in storage[last] Special case: Enqueueing into an empty queue. This can be handled like the 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" ; }

23 Consider the operation of dequeueing: Store the value of the first element In 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 ; }

24 The following shows how the storage array changes as operations occur: The top figure shows the operations on an abstract queue. The bottom figure shows the operations on an ArrayQueue (the array is shown upside-down). ENGI 4892 (MUN) Unit 4 June 1, / 24

Wentworth Institute of Technology COMP201 Computer Science II Spring 2015 Derbinsky. Stacks and Queues. Lecture 11.

Wentworth Institute of Technology COMP201 Computer Science II Spring 2015 Derbinsky. Stacks and Queues. Lecture 11. Lecture 11 1 More Data Structures In this lecture we will use a linked list to implement two abstract data types (ADT) An ADT provides the interface, or what a data structure does We can then use code