Stack ADT. B/W Confirming Pages

Transcription

1 wu23399_ch19.qxd 1/2/07 20:46 Page Stack ADT O b j e c t i v e s After you have read and studied this chapter, you should be able to Describe the key features of the Stack ADT. Develop applications using stacks. Implement the Stack ADT by using an array. Implement the Stack ADT by using a linked list. the key differences between the array Explain and linked implementations of the Stack ADT. 1035

2 wu23399_ch19.qxd 1/2/07 20:46 Page Chapter 19 Stack ADT I n t r o d u c t i o n We continue our study of ADTs with the Stack ADT in this chapter. As we did in Chapter 18, we start with the definition of the Stack ADT and present two different implementations. We conclude the chapter with sample applications of the Stack ADT. The Stack ADT is modeled after a physical stack of items, such as a stack of pancakes or a stack of plates. If you were asked to remove any plate from a stack of plates, which one would you remove? The topmost one, of course. Similarly, the most effortless place to add a new plate is at the top of the stack. Like its physical counterpart, the defining feature of the Stack ADT is its restrictive insertion and removal operations. An item can only be added to the top of the stack, and only the topmost item of the stack can be removed. Because of this restriction, the Stack ADT is quite simple. And consequently, its implementations are relatively straightforward, compared to the List ADT. As simple as it may be, the Stack ADT is remarkably versatile and useful in many diverse types of applications. stack top of stack LIFO 19.1 The Stack ADT A stack is a linearly ordered collection of elements where elements, or items, are added to and removed from the collection at the one end called the top of stack. This restriction will ensure that the last element added to a stack is the first to be removed next. For this reason, a stack is characterized as a last-in, first-out (LIFO) list. Figure 19.1 shows a sample generic stack named samplestack with five elements and another stack named with five three-letter animal names. Items in a stack are said to be linearly ordered because the order in which the items are added and removed follows the strict linear sequence. In other words, the item at the ith position below the top of the stack moves to the (i 1)st position when the topmost item is removed. Similarly, the item at the ith position below the top of the stack moves to the (i 1)st position when a new item is added to the top of the stack. TOP E 4 E 3 This is the top of stack. New element is added here, and only the top-of-stack element can be removed. TOP "bee" "dog" E 2 "ape" samplestack E 1 "gnu" E 0 "cat" Figure 19.1 A generic stack samplestack with five elements and a stack with three-letter animal names.

3 wu23399_ch19.qxd 1/2/07 20:46 Page The Stack ADT 1037 push pop peek clear size isempty Because the addition and removal operations are restricted, the methods defined for the Stack ADT are much simpler than those defined for the List ADT. The add operation named push adds a new item to the top of the stack. The remove operation named pop removes the topmost item. The get operation named peek returns the topmost item, without actually removing it. There are two query operations named size and isempty. The size method returns the number of items in the stack, and the isempty method returns true if the size of the stack is 0. The update operation named clear empties the stack. The push operation will add the designated element to the top of the stack. The current elements in the stack are pushed down one position. The stack does not have any size restriction. It will grow without bound. Of course, the computer memory is not limitless, so there will be a hardware limitation on how big a stack can grow, but there will be no size restriction at theadt level.also, there is no restriction on the elements. You can add duplicates, for instance. Figure 19.2 illustrates the push operation. The pop operation is the reverse of the push operation. It will remove the topmost element from the stack if there is any. If the stack is empty, then the operation will throw an exception. There are a number of possible Java exceptions that the operation can throw, and we will discuss them in Section For now, we ll just say that the operation will throw some kind of exception. Figure 19.3 illustrates the pop operation on nonempty and empty stacks. The peek operation is just like the pop operation except that the top element is not removed from the stack. Figure 19.4 illustrates the peek operation on nonempty and empty stacks. The clear operation removes all elements in the stack. It causes no problem to call the clear operation on an empty stack. This operation becomes handy, for example, when you want to clear the stack before reusing it for processing the next batch of input data. See Figures 19.5 and The size operation returns the number of elements in the stack. This operation is not as commonly used on the stacks as the isempty operation, but we will include it in the specification as it is not costly to implement this operation. Including this operation maintains the consistent set of methods available on all types of collection objects. The isempty operation tests whether the stack is empty. If it is, then true is returned. Otherwise, false is returned. See Figure Before After TOP "bat" TOP "dog" push("bat") "dog" "ape" "ape" "cat" "cat" Figure 19.2 A sample push operation on the stack.

4 wu23399_ch19.qxd 1/2/07 20:46 Page Chapter 19 Stack ADT Before After TOP "bat" "dog" pop( ) TOP "dog" "ape" "cat" returns "ape" "cat" "bat" pop( ) throws <exception> Figure 19.3 Sample pop operations on the stack. Before After TOP "dog" peek( ) TOP "dog" "ape" "cat" returns "ape" "cat" "dog" No structural change is made. peek( ) throws <exception> Figure 19.4 Sample peek operations on the stack.

5 wu23399_ch19.qxd 1/2/07 20:46 Page The Stack ADT 1039 Before After TOP "dog" "ape" clear( ) "cat" Figure 19.5 A sample clear operation on the stack. Before After TOP "dog" TOP "dog" "ape" size( ) "ape" "cat" returns "cat" 3 No structural change is made. Figure 19.6 A sample clear operation on the stack. Before After TOP "dog" isempty( ) TOP "dog" "ape" "cat" returns "ape" "cat" false isempty( ) returns Figure 19.7 true Sample isempty operations on the stack.

6 wu23399_ch19.qxd 1/2/07 20:46 Page Chapter 19 Stack ADT 1. Draw the stack after executing the following operations, starting with an empty stack called. String bee = new String("bee"); String cat = new String("cat");.clear( );.push(bee);.push(cat);.pop( ); 2. Repeat Question 1 with the following statements: String bee = new String("bee"); String cat = new String("cat"); String dog = new String("dog"); petstack.push(bee); petstack.push(cat); petstack.push(dog); petstack.peek( ); petstack.pop( ); petstack.pop( ); petstack.push(dog); 19.2 The Stack Interface As we did for the List ADT, we will use a Java interface to define the Stack ADT. We will continue to prefix our interfaces and classes with NPS. (There are no conflicts because no interface named Stack and no classes named ArrayStack and LinkedStack exist in the java.util packages; but for consistency, we will prefix all of our interfaces and classes with NPS.) Formalizing what we have presented in Section 19.1, we have the following definition: NPSStack package edu.nps.util; public interface NPSStack<E> { public void clear( ); public boolean isempty( ); public E peek( ) throws NPSStackEmptyException; public E pop( ) throws NPSStackEmptyException; public void push(e element); public int size( );

7 wu23399_ch19.qxd 1/2/07 20:46 Page The Stack Interface 1041 TABLE 19.1 The NPSStack interface Table Interface: NPSStack void clear( ) Removes all elements from the stack. boolean isempty( ) Determines whether the stack is empty. Returns true if it is empty; false otherwise. Object peek( ) throws NPSStackEmptyException Returns the top-of-stack element without removing it from the stack. Throws an exception when the stack is empty. Object pop( ) throws NPSStackEmptyException Removes the top-of-stack element and returns it. Throws an exception when the stack is empty. void push( Object element ) Adds an element to the stack. This element becomes the new top-of-stack element. int size( ) Returns the number of elements in the stack. Table 19.1 summarizes the methods of the NPSStack interface. The peek and pop methods are defined to throw an NPSStackEmptyException. We could have thrown an NPSNoSuchElementException because there is no such (top-of-stack) element when you attempt to pop or peek an empty stack. However, NPSNoSuchElementException is equally applicable, for example, when you search for an element that is not in a data structure. It is preferable to use an exception that identifies the error condition as precisely as possible, instead of using a generic exception. Because the specific error condition that would result in an exception for the pop and peek operations is an empty stack, we chose to throw an exception specifically defined for this purpose. The NPSNoSuchElementException class is a very simple class. Here s the definition: NPSNoSuchElementException package edu.nps.util; public class NPSStackEmptyException extends RuntimeException { public NPSStackEmptyException( ) { this("stack is empty"); public NPSStackEmptyException(String message) { super(message);

8 wu23399_ch19.qxd 1/2/07 20:46 Page Chapter 19 Stack ADT 19.3 The Array Implementation In this section, we will implement the NPSStack interface by using an array to store the stack elements. Figure 19.8 illustrates the array implementation of the Stack ADT. The NPSArrayStack Definition The NPSArrayStack class implements the NPSStack interface, and its class declaration is as follows: package edu.nps.util; public class NPSArrayStack<E> implements NPSStack<E> { //class body comes here We use an array element to store the stack elements and an int variable count to keep track of the number of elements currently in the stack. Since the Java array uses zero-based indexing, the value of count is also the index of the array where we add the next element. We will also define a constant for the default size we use when creating the array in the zero-argument constructor. These data members are declared as private static final int DEFAULT_SIZE = 25; private E[ ] element; private int count; ADT Stack Array Implementation TOP "bat" "dog" "ape" "cat" This value is also the index of the array where we add the next item. :NPSArrayStack count 4 element n :String "bat" :String "dog" :String "ape" :String The array is drawn vertically to capture the nature of stack more clearly. "cat" Figure 19.8 An array implementation of the Stack ADT.

9 wu23399_ch19.qxd 1/2/07 20:46 Page The Array Implementation 1043 We will define two constructors: one takes no argument and another takes one argument that specifies the initial size of the array. They are defined as follows: public NPSArrayStack( ) { this(default_size); public NPSArrayStack(int size) { if (size <= 0) { throw new IllegalArgumentException( "Initial capacity must be positive"); element = (E[]) new Object[size]; count = 0; clear Notice that we first create an array of Object and then typecast it to an array of E, the type parameter. This is necessary because it is not allowed to create an array of generic type in Java. We will set element[i] to null, where i = 0,..., count-1, so the objects referenced by element[i] will be garbage-collected. We will then reset the count variable to 0. public void clear( ) { for (int i = 0; i < count; i++) { element[i] = null; count = 0; isempty This operation is straightforward. If the value of count is 0, then the stack is empty. Otherwise, the stack is not empty. public boolean isempty( ) { return (count == 0); peek This is one of the two operations that can potentially throw an NPSStackEmpty- Exception. We throw an NPSStackEmptyException when the stack is empty. Otherwise, we return the top-of-stack element. public E peek() throws NPSStackEmptyException { if (isempty( )) { throw new NPSStackEmptyException( ); else { Be careful! The current top return element[count-1]; of stack is at the (count-1) index position.

10 wu23399_ch19.qxd 1/2/07 20:46 Page Chapter 19 Stack ADT pop push The pop operation removes the top-of-stack element. If the stack is not empty, we adjust the count data member and remove the topmost element by setting the value of the corresponding index position to null. Here s the method: public E pop() throws NPSStackEmptyException { if (isempty( )) { throw new NPSStackEmptyException( ); else { count--; E item = element[count]; element[count] = null; return item; Adding a new item to the top of a stack and updating the count data member can be expressed easily and concisely as element[count] = item; count++; Can be combined into one statement as element[count++] = item; The complication will arise when the array is fully occupied. When the array is full, we need to enlarge it to accommodate more items. We will define a private method called expand to create a new array that is 1.5 times larger than the current array. This is the same technique we used in the NPSArrayList class. Here s the method: private void expand( ) { // create a new array whose size is 150% of // the current array int newlength = (int) (1.5 * element.length); E[] temp = (E[]) new Object[newLength]; // now copy the data to the new array for (int i = 0; i < element.length; i++) { temp[i] = element[i]; element = temp; The push method is defined as follows: public void push(e item) { if (count == element.length) { expand( ); element[count++] = item;

11 wu23399_ch19.qxd 1/2/07 20:46 Page The Array Implementation 1045 size The last method is straightforward. We simply return the value of the count data member. public int size ( ) { return count; Here s the complete source code (for brevity, javadoc and most other comments in the actual source file are removed here): NPSArrayStack package edu.nps.util; public class NPSArrayStack<E> implements NPSStack<E> { private static final int DEFAULT_SIZE = 25; private E[ ] element; private int count; public NPSArrayStack( ) { this(default_size); Constructor public NPSArrayStack(int size) { if (size <= 0) { throw new IllegalArgumentException( "Initial capacity must be positive"); element = (E[]) new Object[size]; count = 0; public void clear() { clear for(int i = 0; i < count; i++) { element[i] = null; count = 0; public boolean isempty() { isempty return count == 0; public E peek( ) throws NPSStackEmptyException { if (isempty( )) { peek

12 wu23399_ch19.qxd 1/2/07 20:46 Page Chapter 19 Stack ADT throw new NPSStackEmptyException( ); else { return element[count-1]; public E pop() throws NPSStackEmptyException { pop if (isempty( )) { throw new NPSStackEmptyException( ); else { count--; E item = element[count]; element[count] = null; return item; public void push(e item) { push if (count == element.length) { expand( ); element[count++] = item; public int size( ) { size return count; private void expand( ) { expand int newlength = (int) (1.5 * element.length); E[] temp = (E[]) new Object[newLength]; for (int i = 0; i < element.length; i++) { temp[i] = element[i]; element = temp;

13 wu23399_ch19.qxd 1/2/07 20:46 Page The Linked-List Implementation Draw the array stack (like the right-hand side diagram in Figure 19.8) after executing the following operations, starting with an empty stack called. String bee = new String("bee"); String cat = new String("cat");.clear();.push(cat);.push(bee); 2. What is the purpose of the enlarge method? 3. What will happen if you replace the statement inside the else block of the pop method with the following? return element[count--]; 19.4 The Linked-List Implementation The linked-list implementation of the Stack ADT follows the same implementation pattern for the List ADT in Chapter 18. Figure 19.9 illustrates the linked-list implementation of the Stack ADT. ADT Stack Linked-List Implementation :String "bat" :NPSLinkedStack :String TOP "bat" "dog" "ape" "cat" count 4 topofstack "dog" :String "ape" The links are drawn pointing downward to capture the nature of stack more clearly. :String "cat" Figure 19.9 A linked-list implementation of the stack.

14 wu23399_ch19.qxd 1/2/07 20:46 Page Chapter 19 Stack ADT The StackNode Class The linked node structure for the stack is exactly the same as the one for the list. The StackNode class is defined as the inner class of the NPSLinkedStack class. Here s the class definition: class StackNode { private E item; private StackNode next; public StackNode(E item) { this.item = item; this.next = null; The NPSLinkedStack Class We keep two data members in the class. The first data member is a reference variable topofstack that points to the top-of-stack element. We adjust its value every time we pop an item from or push an item onto the stack. The second data member is an int variable count that keeps track of the number of elements currently in the stack. Their declarations are as follows: private StackNode topofstack; Private int count; We define only a single constructor that takes no arguments and sets the stack to its initial state, which is an empty stack. The constructor is defined as follows: public NPSLinkedStack( ) { clear( ); clear When we reset the topofstack pointer to null, the topmost node will get garbagecollected (because no pointers point to it any more). When this topmost node gets garbage-collected, the node below no longer has a pointer pointing to it, which causes this node to be garbage-collected also. This ripple effect will eventually cause all nodes to be garbage-collected. Here s the clear method: public void clear( ) { topofstack = null; count = 0;

15 wu23399_ch19.qxd 1/2/07 20:46 Page The Linked-List Implementation 1049 isempty The isempty method is implemented easily by checking the value of the data member count: public boolean isempty( ) { return count == 0; peek If the stack is empty, we throw an NPSstackEmptyException. Otherwise, we return the top-of-stack node (without actually removing it). Here s the method: public E peek( ) throws NPSStackEmptyException { if (isempty( )) { throw new NPSStackEmptyException( ); else { pop return topofstack.item; If the stack is empty, we throw an NPSStackEmptyException. Otherwise, we set a temp pointer to the topmost item, update the topofstack pointer, and return the topmost item. Here s the method: public E pop( ) throws NPSStackEmptyException { if (isempty( )) { throw new NPSStackEmptyException( ); push else { count--; E temp = topofstack.item; topofstack = topofstack.link; return temp; Adding a new element to a link-based stack is simpler than adding to an array-based stack because we do not have to worry about the overflow condition. All we need to do is to allocate a new node, adjust the topofstack pointer, and increment the counter. The method is defined as follows: public void push(e element) { StackNode newtop = new StackNode(element); newtop.link = topofstack; //add the new node to top topofstack = newtop; //set new node as top-of-stack count++;

16 wu23399_ch19.qxd 1/2/07 20:46 Page Chapter 19 Stack ADT size The size method simply return the value of the data member count: public int size( ) { return count; We are now ready to list the complete NPSLinkedStack class. In the source code listing, we do not show any javadoc comments, to keep the listing to a manageable size. The actual source code includes the full javadoc comments. NPSLinkedStack package edu.nps.util; public class NPSLinkedStack<E> implements NPSStack<E> { private StackNode topofstack; private int count; public NPSLinkedStack( ) { clear( ); public void clear( ) { topofstack = null; count = 0; public boolean isempty( ) { return (count == 0); public E peek( ) throws NPSStackEmptyException { if (isempty( )) { throw new NPSStackEmptyException( ); else { return topofstack.item; public E pop( ) throws NPSStackEmptyException { if (isempty( )) { throw new NPSStackEmptyException( ); else { count--; E temp = topofstack.item; Constructor clear isempty peek pop

17 wu23399_ch19.qxd 1/2/07 20:46 Page The Linked-List Implementation 1051 topofstack = topofstack.link; return temp; public void push(e element) { StackNode newtop = new StackNode(element); newtop.link = topofstack; topofstack = newtop; count++; public int size( ) { return count; class StackNode { private E item; private StackNode link; //points to the element //one position below this node public StackNode(E item) { this.item = item; this.link = null; push size StackNode 1. Draw the linked stack (like the right-hand side diagram in Figure 19.9) after executing the following operations, starting with an empty stack called. String bee = new String("bee"); String cat = new String("cat");.clear();.push(cat);.push(bee); 2. Instead of using count == 0 to check for an empty stack, can we use topofstack == null?

18 wu23399_ch19.qxd 1/2/07 20:46 Page Chapter 19 Stack ADT 19.5 Implementation Using NPSList At the beginning of this chapter, we wrote that a stack can be characterized as a special kind of a list called a LIFO list. A stack is a LIFO list because the last item to be added to a stack is the first item to be removed from the stack next. We can in fact implement the Stack ADT by using a list. Consider the following NPSListStack class: NPSListStack package edu.nps.util; public class NPSListStack<E> implements NPSStack<E> { private static final int FRONT = 0; private NPSList<E> list; public NPSListStack( ) { list = new NPSLinkedList<E>(); public void clear( ) { list.clear(); public boolean isempty( ) { return list.isempty(); public E peek( ) throws NPSStackEmptyException { if (isempty( )) { throw new NPSStackEmptyException( ); else { return list.get(front); public E pop( ) throws NPSStackEmptyException { if (isempty( )) { throw new NPSStackEmptyException( ); else { return list.remove(front); public void push(e element) { list.add(front, element);

19 wu23399_ch19.qxd 1/2/07 20:46 Page Sample Application 1053 public int size( ) { return list.size(); See how easily and succinctly the whole class can be implemented. Notice that in this implementation, we treat the first item in the linked list as the top-of-stack item. Do you know why? Instead of the NPSLinkedList class, we can use the NPSArrayList class. But with the NPSArrayList class, we should treat the last item in the list as the top-of-stack element to avoid the shifting of items when a new item is added Sample Application Application Matching HTML Tags The use of the Stack ADT is quite common in many different applications. In this section we will illustrate a typical use of a stack.we will write a program that checks the correctness of a given HTML document. An HTML, which stands for Hyper Text Markup Language, is a markup language designed for creating a web page. HTML uses a set of predefined tags to describe the structure of a document.the tags are used, for example, to specify the title, different levels of headings, numbered lists, and tables in a document. XML, or extended Markup Language, is another markup language that is used widely in today s computing world. It is not necessary to understand HTML fully to appreciate the use of a stack in checking the syntax of an HTML document.we only need to know how the HTML tags are organized in a document.the following is a very small (and valid) HTML document: <html> <head> <title>a sample HTML page</title> </head> <body> <h1>sample HTML</h1> <p>see how the tags are matched in pairs?</p> <h4>this is a table</h4> <table border="2"> <tr> <td>row 1 column 1</td> <td>row 1 column 2</td> </tr> </table> </body> </html>

20 wu23399_ch19.qxd 1/2/07 20:46 Page Chapter 19 Stack ADT 19.6 Sample Application continued Figure A Web browser displaying the sample HTML document. Figure shows how this HTML document is displayed in a Web browser. The Web browser interprets the tags in the given HTML document and renders the page accordingly. The key characteristic of HTML tags is that the tags come in pairs: the opening and matching closing tags. There s an exception to this rule, but we will ignore it for the sake of simplicity in the following discussion (see Exercise 11). For example, the opening tag for the title is <title> and its matching closing tag is </title> The closing tag includes the forward slash (/) before the tag name. The tag names are caseinsensitive, so it doesn t matter, for example, if we specify the opening tag for the title as or as <title> <TITLE> The tags in the example HTML document are displayed in blue for easy viewing. The text in black is the content that gets displayed in the Web browser. If we strip the content,

21 wu23399_ch19.qxd 1/2/07 20:46 Page Sample Application 1055 this is what we get (tags are indented to show the structure clearly): <html> <head> <title> </title> </head> <body> <h1> </h1> <p> </p> <h4> </h4> <table border= 2 > <tr> <td> </td> <td> </td> </tr> </table> </body> </html> Notice how the matching tags are nested. We will never encounter a situation in which the matching tags cross over. In other words,in a valid HTML document,we will never face a situation like this: Invalid <body> <table> </body> </table> This type of cross over will not happen in a valid HTML file. We can characterize the formulation of tags in a valid HTML document as follows: 1. All opening tags have matching closing tags. 2. When a closing tag is encountered in the document, its corresponding opening tag was already encountered.that is, opening tags always come before the closing tags. 3. Tags can be nested, but they never overlap.

22 wu23399_ch19.qxd 1/2/07 20:46 Page Chapter 19 Stack ADT 19.6 Sample Application continued These characteristics call for a stack to check the validity of a given HTML document. Here s the pseudocode for the syntax checker: NPSStack tagstack = new NPSArrayStack( ); boolean haserror = false, done = false; while (!done) { If all tags are processed and yet the stack is not empty, then it means there were opening tags with no matching closing tags. if (no more tags in a file) { done = true; if (!tagstack.isempty( )) { haserror = true; else { nexttag = get next tag from the file; if (nexttag is an opening tag) { tagstack.push(nexttag); //every opening tag gets //stacked exactly once else { //it's a closing tag If the next incoming tag is a closing tag, its corresponding opening tag must be the current top-of-stack element because of the properly nested characteristic. toptag = tagstack.pop( ); if (toptag does not match nexttag) { done = true; haserror = true; if (haserror) { //Invalid HTML else { //Valid HTML To concentrate on the stack processing, we assume the two helper classes HTML TagRetriever and HTMLTag. An HTMLTagRetriever object handles the retrieval of HTML tags from the specified file. An HTMLTag object represents a single HTML tag. Implementation of these classes is left as an exercise. Table 19.2 lists the methods of HTMLTagRetriever, and Table 19.3 lists the method of HTMLTag. Now we are ready to implement the pseudocode. Let s define a class named HTML TagChecker. The major portion of the logic expressed in the pseudocode is implemented in the key method called isvalid. This method returns true if the tags in the designated

23 wu23399_ch19.qxd 1/2/07 20:46 Page Sample Application 1057 Table 19.2 The HTMLTagRetriever class Table Class: HTMLTagRetriever HTMLTagRetriever( String filename ) throws IOException Constructs a new HTMLTagRetriever object and associates it to the file with the name filename. Throws an IOException if the said file cannot be opened. void reset( ) Resets this object so the processing of the tags can be repeated from the beginning. void reset( String filename ) throws IOException Same as the reset method with no parameter. This method, however, associates the object to the new file.throws an IOException if said file cannot be opened. boolean hasmoretags( ) Returns true if there are more tags in the file. Otherwise, returns false. HTMLTag nexttag( ) throws NoSuchElementException Returns the next HTMLTag object in the file. If there are no more tags, then the NoSuchElementException exception is thrown. file are syntactically correct. Otherwise, it returns false. The name of the file to process is passed to the constructor of HTMLTagChecker. Here s the class: HTMLTagChecker import edu.nps.util.*; import java.io.ioexception; public class HTMLTagChecker { private NPSStack<HTMLTag> tagstack; private HTMLTagRetriever tagretriever; public HTMLTagChecker(String filename) throws IOException { tagstack = new NPSArrayStack<HTMLTag>( ); tagretriever = new HTMLTagRetriever(filename);

24 wu23399_ch19.qxd 1/2/07 20:46 Page Chapter 19 Stack ADT 19.6 Sample Application continued Table 19.3 The HTMLTag class Table Class: HTMLTag HTMLTag(String text) Creates a new HTMLTag object.the parameter text is the actual string, such as <body> and <title>,for the tag. boolean match(htmltag tag) Compares the parameter tag with this HTMLTag object in a caseinsensitive manner.the tag object can represent either the opening or the closing tag.the method will make the appropriate checking. Forexample, if this HTMLTag object represents <HEAD> and the argument tag object represents </HEAD>, then it is a match. Likewise, if this HTMLTag object represents </HEAD> and the argument tag object represents <HEAD>, then it is a match also. If there is a match, the method returns true. Otherwise, it returns false.the opening HTMLTag object can contain attribute values. For example, in the tag <TABLE border="2"> the border attribute specifies the width of the table border.this method correctly matches the opening tag that includes attributes with its closing tag. boolean isopeningtag( ) Returns true if this object represents an opening tag. Otherwise, returns false. boolean isclosingtag( ) Returns true if this object represents a closing tag. Otherwise, returns false. public boolean isvalid( ) { HTMLTag nexttag = null, toptag = null; tagstack.clear( ); boolean haserror = false, done = false; while (!done) { if (!tagretriever.hasmoretags( )) { //no more tags done = true;

25 wu23399_ch19.qxd 1/2/07 20:46 Page Sample Application 1059 if (!tagstack.isempty( )) { //there are some //leftover opening tags haserror = true; //with no matching closing tags done = true; else { nexttag = tagretriever.nexttag( ); if (nexttag.isopeningtag( )) { tagstack.push(nexttag); else { //it's a closing tag toptag = tagstack.pop( ); if (!toptag.match(nexttag)) { done = true; haserror = true; return haserror; /// M A I N m e t h o d // public static void main(string[] arg) { try { HTMLTagChecker checker = new HTMLTagChecker("index.html"); if (checker.isvalid()) { System.out.println("Input HTML file is valid"); else { System.out.println("Input HTML file is NOT valid"); catch (IOException e) { System.out.println("Error opening the designated file");

26 wu23399_ch19.qxd 1/2/07 20:46 Page Chapter 19 Stack ADT 19.7 Sample Application Development backtracking Solving a Maze with Backtracking Many computer problems can be solved by the technique called backtracking. The name characterizes how the solution to a problem is found. Consider a maze problem. We define a maze to be a two-dimensional array of cells.each cell has four sides with at most three sides having a wall. You can move from one cell to an adjacent cell if there is no wall between the two cells. Two special cells are indentified as the entry and exit cells. The problem is to find a path that takes you from the entry cell to the exit cell of a given maze.figure shows a sample 5-by-5 maze. For humans, finding a solution path for a such small maze is almost immediate. But when the maze gets larger, say, 100 by100, finding a solution is not an easy matter anymore.(we re talking here about a human finding a solution for a maze drawn on a sheet of paper,and not about finding solution for a real-life maze or labyrinth.) What kind of a computer solution can we devise to find a solution path? We assume here that a given maze includes at least one solution path. A maze is represented by a Maze object that consists of N-by-M cells. A cell is represented by a MazeCell object. The Maze and MazeCell classes are described in Tables 19.4 and 19.5, respectively. It is left as an exercise to implement these two classes. One brute-force solution is to visit cells randomly, starting from the entry cell. This is akin to a human walking blindly around the maze. This simplistic approach can be expressed in the following manner: public void solverandom(maze maze) { MazeCell current = maze.getentrycell(); MazeCell exit = maze.getexitcell(); Cell is identified by the row and column numbers. This cell, for example, is (2,0) S 4 E Solution Path (0,3) (0,2) (1,2) (2,2) (3,2) (1,3) (3,0) (4,0) (4,1) (4,2) (4,3) (3,3) (3,4) (2,4) S E Figure A sample maze with 5-by-5 cells.the entry cell is marked with S and the exit cell with E. The dotted line shows the solution path from S to E. For this maze, there s exactly one solution path.

27 wu23399_ch19.qxd 1/2/07 20:46 Page Sample Development 1061 Table 19.4 The Maze class Table Class: Maze Maze( int rowsize, int columnsize ) Creates a new rowsize-by-columnsize maze. In its initial state, all cells are marked unvisited. One cell is designated as the entry cell and another cell as the exit cell. The entry and exit cells border one of the outer boundaries. void clear( ) Resets the maze to its initial state. int getcolumncount( ) Returns the number of columns of this maze. int getrowcount( ) Returns the number of rows of this maze. MazeCell getentrycell( ) Returns the entry cell. MazeCell getexitcell( ) Returns the exit cell. MazeCell getnextcell( MazeCell currentcell ) Returns a visitable cell adjacent to currentcell.returns null if there is no visitable adjacent cell. MazeCell getnextrandomcell( MazeCell currentcell ) Randomly selects and returns a cell adjacent to currentcell.the state of cell (visitable or not) is ignored by this method. while (current!= exit) { //move to a random adjacent cell current = maze.getnextrandomcell(current); System.out.println("Solution Path Found"); Since the method does not keep track of the cells visited, all it does is to output the message Solution Path Found when the exit cell is reached. It does not (cannot) print out the solution path. A much more elegant solution would be backtracking. Here s how it works. Mark the entry cell visited. Visit an adjacent cell that is not yet visited. Mark this cell visited (so we won t visit this cell again). Repeat this visit-and-mark-visited routine until either the exit cell is visited or there is no adjacent cell to visit from the current cell. If the exit cell is visited, then we found the solution. If there are no more adjacent cells to visit from the

28 wu23399_ch19.qxd 1/2/07 20:46 Page Chapter 19 Stack ADT 19.7 Sample Application continued Table 19.5 The MazeCell class Table Class: MazeCell MazeCell( int rownum, int columnnum ) Creates a new cell. Each cell is identified by its row number and column number, the position it occupies in a maze. In its initial state, all four walls are up. int getcolumnnumber( ) Returns the column number of this cell. int getrownumber( ) Returns the row number of this cell. boolean isvisited( ) Returns true if the cell is not visited yet (i.e., it is visitable) and false if the cell is visited. boolean iswallup( int side ) Returns true if the wall of the specified side of this cell is up. Possible values for the parameter are MazeCell.NORTH, MazeCell.SOUTH, MazeCell.EAST, and MazeCell.WEST. void putwalldown( int side ) Knocks down the wall of the specified side of this cell. Possible values for the parameter are MazeCell.NORTH, MazeCell.SOUTH, MazeCell.EAST, and MazeCell.WEST. void setvisited( boolean state ) Sets the state of this cell.the value of true means the cell is visited and false means not visited. current node, we backtrack to the cell before the current cell and repeat the process again from that cell. Figure illustrates two backtracking steps. The key aspect of implementing this backtracking algorithm is to remember the cell to backtrack to.the ADT that goes hand in hand with backtracking is a stack.when we visit a cell, we push it onto a stack. The current cell is at the top of stack, and the adjacent cell we visit next from the current cell will be the new top of stack (and it will be the current cell in the next iteration). When we backtrack from a cell, we simply pop a stack. The new top of stack is the cell we re backtracking to. Figure shows the correspondence between the path and the stack content. We use the setvisited method of the MazeCell class to mark a visited cell. The getnextcell method of the Maze class returns a next visitable cell (a cell that is not yet

29 wu23399_ch19.qxd 1/2/07 20:46 Page Sample Development S 0 S 0 N S C backtrack from (2,0) to (1,0) C backtrack from (1,0) to (1,1) C A B C Figure This illustrates how the backtracking works.visited cells are marked with a red circle. Diagram A: There are no more adjacent cells to visit from the current cell (C), so we backtrack to cell (1,0). Diagram B: Again, there are no more adjacent from the current cell, so we backtrack. Diagram C: From the current cell, we can visit cell (0,1), so we visit it next (N). (2,1) S (2,2) 1 (1,2) C stack (0,2) (0,3) Figure The stack content shows the order of visiting cells in the path currently under consideration. visited) from a given cell. If there are no more visitable cells from a given cell, the method returns null. Here s the method that finds a solution path by backtracking: public void solvebacktracking(maze maze) { MazeCell current = maze.getentrycell(); MazeCell exit = maze.getexitcell(); NPSStack<MazeCell> stack = new NPSArrayStack<MazeCell>( ); stack.push(current); while (current!= exit) { current = maze.getnextcell(current);

30 wu23399_ch19.qxd 1/2/07 20:46 Page Chapter 19 Stack ADT 19.7 Sample Application continued if (current!= null) { current.setvisited(true); //mark it visited stack.push(current); else { //no more visitable cells from the //top-of-stack cell, so backtrack current = stack.pop(); System.out.println("Solution Path:"); while (stack.isempty()) { //print out the solution System.out.println(stack.pop()); //path backward Because we are using a stack, the solution path found is printed backward from the exit cell to the entry cell.it is more natural to print out the path forward from the entry cell to the exit cell. This is left as an exercise. S u m m a r y Astack is a linearly ordered last-in, first-out (LIFO) collection of elements. An item can be added to only the top of a stack, and only the top item of a stack can be removed. An array and a linked-list are two possible implementations of the Stack ADT. The Stack ADT can be implemented easily by using a list (an instance of a class that implements the List ADT). Base implementation of the Stack ADT does not support any traversal operation. The use of the Stack ADT is illustrated in two sample applications: an HTML syntax checker and a maze solver. Backtracking is a technique used in finding a solution for a search problem. The Stack ADT is used in implementing the backtracking algorithm.

31 wu23399_ch19.qxd 1/2/07 20:46 Page 1065 Exercises 1065 K e y C o n c e p t s Stack ADT array implementation of Stack ADT linked-list implementation of Stack ADT backtracking E x e r c i s e s 1. Draw a state-of-memory diagram that shows the effect of the pop operation on a NPSLinkedStack. Use the state where there are four items in the stack before the pop operation. 2. Draw a state-of-memory diagram that shows the effect of the push operation on a NPSLinkedStack. Use the state where there are three items in the stack before the push operation. 3. Draw a state-of-memory diagram that shows the result of executing each of the following two sets of code. a. NPSStack stack = new NPSLinkedStack( ); Person p = new Person(...); stack.push(p); stack.push(p); b. NPSStack stack = new NPSLinkedStack( ); Person p1 = new Person(...); Person p2 = new Person(...); stack.push(p1); stack.push(p2); 4. Add a new method toarray to the NPSStack interface and implement the method in both NPSArrayStack and NPSLinkedStack. The toarray method will return an array with the bottommost element at position 0, element 1 above the bottom at position 1, and so forth. For a mathematically pure Stack ADT, we do not define such conversion operation. But in the actual use of stacks, we often need to access every element in the stack. For example, in the maze sample application, if the toarray method is available, we can easily print out the solution path in the forward direction (from the entry cell to the exit cell) instead of the backward direction that we printed in the solvebacktracking method. 5. Adding the toarray method is one way to provide access to all elements in a stack. Another way is to include the iterator method to the NPSStack interface that returns an iterator. Implement the iterator method in both NPSArrayStack and NPSLinkedStack. The iterator will access the items in the stack from top to bottom.

32 wu23399_ch19.qxd 1/2/07 20:46 Page Chapter 19 Stack ADT 6. Code a new implementation class for the Stack interface called NoDupStack that does not allow a duplicate of the existing element to be pushed onto the stack. We define an element e2 to be a duplicate of e1 if e1.equals(e2) is true. Define a new exception class called NPSDuplicateException and throw this exception from the push method when an attempt is made to push a duplicate. Use an array for this implementation. 7. Repeat Exercise 6, but this time use the linked nodes instead of an array. 8. In the NPSLinkStack class, the data member list is an instance of NPSLinkedList we use to maintain the stack elements. If a stack is a LIFO list (i.e., a stack IS-A a list), shouldn t we define it as a subclass of the NPSLinkedList class? Why is it wrong to so? 9. When implementing the NPSListStack class, we treat the first item in a list as the top-of-stack item. Modify the class so the last item in the linked list is treated as the top-of-stack item. Which implementation is more efficient? Why? 10. Implement the NPSListStack class using the NPSArrayList class. 11. Implement the HTMLTagRetriever class. There are some HTML tags that do not have the matching closing tags. For this exercise, assume such tags are <br>, <hr>, and <img> tags. The nexttag method must ignore these tags. 12. Implement the HTMLTag class. Pay close attention to the match method. Some opening tags, such as the <table> tag, can contain attributes in addition to the tag name. For example, the <table> tag can be or <table> <table border="2"> When you match the opening and closing tags, you have to ignore the attributes in the opening tags. 13. In this chapter, we assumed that a given maze has at least one solution path. Modify the solvebacktracking method so it will handle the case when a given maze does not have any solution. Terminate the method after displaying the message No Solution Path if there is no solution path. 14. The solvebacktracking method prints out the solution path backward. Modify the method so the solution path is printed forward from the entry cell to the exit cell. Assume the original definition of the NPSStack interface. Specifically, you cannot use the toarray method (see Exercise 4). Hint: Use another stack. 15. Implement the Maze and MazeCell classes. Their public methods are described in Tables 19.4 and 19.5, respectively. The most difficult aspect of this exercise is the creation of a maze, which is carried out in the constructor of the Maze class. Here s one way to create a maze that has exactly one solution path from the entry cell to the exit cell: 1. Start with all four walls up for every cell in the maze. 2. Knock down the walls to create paths.

33 wu23399_ch19.qxd 1/2/07 20:46 Page 1067 Exercises Randomly select the entry and exit cells. Make sure these are selected from the boundary cells (those that face the boundary of the maze). The basic idea of the algorithm for step 2 goes like this: Start from a random cell. Remember this cell in a list. Mark this cell as visited. (You will visit every cell in the maze exactly once.) Set this cell as current. Find an adjacent cell of the current cell that is not yet visited. Knock down the walls between this cell and the current cell. Set this cell as the current cell and repeat the process. If there are no more visitable cells from the current cell, remove a random cell from the list and repeat the process. Stop the routine when all cells in the maze are visited. Expressing this basic idea in a more formal pseudocode, we have the following: mark all cells as 'not visited'; currentcell = pick a random cell; list.add(currentcell); while (there are unvisited cells) { currentcell = list.get(random location); while (currentcell has a 'not visited' adjacent cell) { if (currentcell has more than 1 'not visited' adjacent cell) { list.add(currentcell); //put it back in the list //so other adjacent cells are //considered later previouscell = currentcell; currentcell = getnextcell(previouscell); mark currentcell as 'visited'; knock down the wall between previouscell and currentcell; list.add(currentcell); To support some of the operations expressed in the pseudocode, you may have to define additional methods in the MazeCell class. 16. Write a program that checks if the input arithmetic expression is syntactically correct. Assume the arithmetic expressions include only integer constants, four arithmetic operators, and parentheses. Nested parentheses are allowed. Here are examples of valid arithmetic expressions: * (2 + 7) (23 / (3-4)) / 8 12

34 wu23399_ch19.qxd 1/2/07 20:46 Page Chapter 19 Stack ADT And here are examples of invalid arithmetic expressions: * (4 + 2)) ) ( 17. Forth is a unique and interesting programming language. It can be characterized as a stack-oriented programming language where programs are written in postfix notation. If we write arithmetic expressions using postfix notation, we write them as <leftoperand> <rightoperand> <operator> For example, instead of writing we write in postfix notation. The ordinary way we write arithmetic expressions uses the notation called infix. Here are some examples that compare the infix and postfix expressions: Infix Postfix (8 5) * * 5 4 * (8 5) * Notice that postfix expressions do not include parentheses because they are not necessary. Write a program that evaluates a given postfix arithmetic expression that consists of integer constants and four arithmetic operators,, /, and *. You use a stack to remember the operands. Whenever you encounter an operand in the input postfix expression, stack it. When you encounter an operator in the input postfix expression, its left and right operands are in the stack. Pop the stack twice to get the left and right operands, compute the result, and push the result back to the stack. When there are no more operators left in the expression, the top-of-stack element in the stack is the result of the whole expression. You may assume the input postfix expression is syntactically correct, so you do not have to do any error checking.