Stacks and Their Applications

Size: px

Start display at page:

Download "Stacks and Their Applications"

Chastity Jocelyn Lawson
6 years ago
Views:

1 Chapter 5 Stacks and Their Applications We have been discussing general list structures. In practice, we often work with some restricted cases, in which insertions and/or deletions occur only at one or two positions in a list. In this chapter and the next, we study two such cases: stacks and queues. A stack is a list for which insertions, deletions and inspections all take place at one end of the list, top. It has an important property that the data added in first can only be retrieved at last. Thus, it is also called LIFO list. Trays in cafeteria is a typical example in our daily life. 1

2 Stack is also used in computer science, e.g., in managing function calls. When a function is called, some critical data such as the location at which the call is made, values of local variables, etc., must be saved before the control is transferred. Once the called function is exited, all the saved data must be restored. When a chain of such function invocation is involved, data saved for the function that is called first is going to be restored at last. A stack provides an effective and natural mechanism in this case. Although it is easy and natural to derive a stack class from the general list structure, it is more efficient to start from scratch. 2

3 A customized implementation class Stack { public: Stack(int MaxStackSize = 10); ~Stack() {delete [] stack;} bool IsEmpty() const {return top == -1;} bool IsFull() const {return top == MaxTop;} T Top() const; Stack<T>& Add(const T& x); Stack<T>& Delete(T& x); private: int top; // current top of stack int MaxTop; // max value for top T *stack; // element array }; Notice that for stack, Add and Delete are usually called Push and Pop. 3

4 Define operations Stack<T>::Stack(int MaxStackSize){ MaxTop = MaxStackSize - 1; stack = new T[MaxStackSize]; top = -1; } T Stack<T>::Top() const{ if (IsEmpty()) throw OutOfBounds(); return stack[top]; } Stack<T>& Stack<T>::Add(const T& x){ if (IsFull()) throw NoMem(); stack[++top] = x; return *this; } Stack<T>& Stack<T>::Delete(T& x){ if (IsEmpty()) throw OutOfBounds(); x = stack[top--]; return *this; } 4

5 An linked implementation Below gives another implementation based on a linked structure. template<class T> class LinkedStack { public: LinkedStack() {top = 0;} ~LinkedStack(); bool IsEmpty() const {return top == 0;} bool IsFull() const; T Top() const; LinkedStack<T>& Add(const T& x); LinkedStack<T>& Delete(T& x); private: Node<T> *top; // pointer to top node }; 5

6 Implement operations T LinkedStack<T>::Top() const{ if (IsEmpty()) throw OutOfBounds(); return top->data; } LinkedStack<T>& LinkedStack<T>::Add(const T& x){ Node<T> *p = new Node<T>; p->data = x; p->link = top; top = p; return *this; } LinkedStack<T>& LinkedStack<T>::Delete(T& x){ if (IsEmpty()) throw OutOfBounds(); x = top->data; Node<T> *p = top; top = top->link; delete p; return *this; } 6

7 Homework 5.1. Add in the following functions for the LinkedStack class: Determine the size of the stack, input a stack and output a stack Extend the LinkedStack class to add a function Split that splits a stack into two: the first contains the bottom half elements, and the second contains the rest Write another one that places all the elements in the second stack on top of those in the first. For all the above homework, you need to submit source code and sample output. 7

8 Applications There are many useful applications for stacks. We look at a simple one first. When we write down an arithmetic expression, we have to make sure that the left parentheses match with the corresponding right ones. For example, in (a (b+c)+d),, the (s in positions 1 and 4 matches with the ) in positions 8 and 11. We observe that if we scan the whole expression, a character string, from left to right, then each ) must match with the most recently occurring (. This observation motivates us to push all the ( to a stack, and whenever we see a ), we pop off a ( from the top. If at the end, the stack is empty, everything is matched up. If it not empty at the end, or there is nothing in the stack to match with a ), something must be wrong. 8

9 const int MaxLength = 100; void PrintMatchedPairs(char *expr){ Stack<int> s(maxlength); int j, length = strlen(expr); for (int i = 1; i <= length; i++) { if (expr[i - 1] == ( ) s.add(i); else if (expr[i - 1] == ) ) try {s.delete(j); cout << j << << i << endl;} catch (OutOfBounds) {cout << "No match for right parenthesis" << " at " << i << endl;} } while (!s.isempty()) { s.delete(j); cout << "No match for left parenthesis at " << j << endl;} } 9

10 Railroad cars A freight train has n cars. It is going through n stations, at each of which one car will be detached. Thus, with a list of cars in an arbitrary order, it makes sense to rearrange those cars into the order from n through 1. We will do so in a shunting yard that has an input track, where a list of arbitrarily ordered cars are sent in, an output track, and k holding tracks, where cars can be temporarily stored before going to the output track. 10

11 When arranging cars, we can only do one of the following two things: 1)move a car from the right end of the input track into one of the holding tracks; 2) A car can be moved from a holding track to the left end of the output track. Notice that once a car is moved into a holding track as the last one, it must be the first to be moved out of there. Hence, all the holding tracks are stacks. Moreover, whenever the cars in any holding track is not in an increasing order, the rearrangement can t be completed. Hence, our basic ides is when we get the next car from the input track, we will check if it has the label next to that of the last car in the output track. If it is, send it out; otherwise, we will send it to one of the holding tracks such that its top car has the smallest label which is bigger than that of the incoming one(?). 11

12 During the rearrangement, we also have to check the top cars in the holding tracks to see if any of them has the next label, before we go to the input track to bring in the next one. In some cases, we might need more holding tracks, e.g., the original order of 1,n,n 1,, 2 requires n 1 holding tracks. Homework 5.4: Write a program for the railroad car switching system, assuming track i holds s i cars, 1 i k. 12

13 Maze A maze is a rectangular area with an entrance and an exit. Its interior contains walls or obstacles that one can t walk through. In our case, the entrance is the top left corner, and the exit is the bottom right corner. Given such a maze, we want to find a path that goes from the entrance to the exit. 13

14 Basic ideas It is clear that we can represent a maze as an m n matrix, M, with index (1, 1), and (m, n) representing the entrance and exit, respectively. M(i, j) = 1 iff the position (i, j) is a block. Below is an initial design. void main(){ Welcome(); InputMaze(); if (FindPath()) OutputPath(); else cout << "No Path" << endl; } Now, we have to elaborate it into a C++ program. 14

15 How to find a path? We begin with the entrance position, if it is already the exit, we are done. Otherwise, we have to look for the next position in the path. Generally speaking, we can try the right one, the one below, the left one, and the one above. If we can go to any of them, we can keep the current position somewhere, and go to the next one, and continue from there. If we reach a dead end via that next position, we have to come back, or backtrack, to try an alternative. Since, we should always change the most recently made option, we have to keep the path in a stack. Homework 5.5. Write a program to implement the above idea, using a linked list to hold the path. 15

More Group HW. #ifndef Stackh #define Stackh. #include <cstdlib> using namespace std;

More Group HW. #ifndef Stackh #define Stackh. #include <cstdlib> using namespace std; More Group HW The following code is contained in the file ex1stck.h. Fill in the blanks with the C++ statement(s) that will correctly finish the method. Each blank may be filled in with more than one statement.