CS212 - COMPUTATIONAL STRUCTURES AND ALGORITHMS

Transcription

1 CS212 - COMPUTATIONAL STRUCTURES AND ALGORITHMS Lab #4 - Due Wednesday, February 11, at the start of class Purpose: To develop familiarity with recursive lists Introduction The linked list data structure is an inherently recursive one - e.g. consider the following typical class definition for a Node on a list: class Node // Various methods private: // Various fields Node * _link; ; Note that the class Node is defined in terms of itself, since each Node contains a field which can point to another Node. This leads to the following way of thinking about a list: A list is either empty, or it consists of a head and a tail. The head is whatever kind of information the list stores. The tail is another list. e.g. consider the following list: External pointer ant bee cat dog this can be regarded as a list whose head is ant and whose tail is the list: External pointer bee cat dog which, in turn, can be regarded as a list whose head is bee and whose tail is... until finally we get down to External pointer dog which can be regarded as a list whose head is dog and whose tail is empty. 1

2 Naturally, when we view lists in this way, it makes sense to do operations on them recursively. This is what we will do in this lab. For the duration of this lab, you may not use any kind of C++ looping construct (for, while, or do). All repetition must be done using recursion. In this lab, we will be working with the AlphabeticalList class whose header file is attached as Appendix A. Study this header file carefully before coming to lab. You will notice that the public methods are supported by private methods (recursive auxillaries) that actually do the work - e.g. the public copy constructor and assignment operator are supported by the private copy method; the public insert method is supported by a private insert method, etc. The private methods are all class (static) methods, and take a list as a parameter. Each will do its job by operating directly at the head of the list and/or recursively calling itself to operate on the tail of the list. Also, note that this list does not use a header node - the recursive implementation is actually simpler without one! A portion of the implementation file for this class is given in Appendix B. Again, study this partial implementation file before coming to lab. Note how each of the public methods is implemented by simply calling an appropriate private method. Your task, in lab, will be to actually implement the private methods. To help you see how this is done, the code for one of these methods (remove - the hardest one!) - is supplied below. (You will need to type it in yourself.) Again, study this code carefully before coming to lab. AlphabeticalList::Node * AlphabeticalList::remove(string name, Node * list, bool & success) // Base case - the list is empty, or the name we want cannot occur on // it (would be before the current head of the list.) Report failure and // return the unaltered list if (list == NULL name < list -> _name) success = false; return list; // Base case - we found the name. Report success, and return the list // with front node removed. Recycle the removed node else if (name == list -> _name) success = true; Node * result = list -> _link; delete list; return result; // Recursive case. Remove name from tail of list - replace current // tail with possibly modified one. else list -> _link = remove(name, list -> _link, success); return list; Note that, if we used this method to remove bee from our initial example list, we would invoke the recursive case to replace the tail of the original list with the list that results from removing 2

3 bee from the current tail. This recursive invocation would execute the second base case to return a list without the node containing bee. If we were trying to remove bat, instead, the recursive invocation would execute the first base case, reporting failure, since bat cannot occur in an alphabetical list beginning with bee, and the initial invocation would now return an unmodified list. Before Coming to Lab Review sections of the handout entitled A Comparison of the Syntax and Semantics of C++ and Java. Carefully study sections 13 and 14 of the handout entitled A Comparison of the Syntax and Semantics of C++ and Java. Although this lab is not primarily about references and const variables, some of the methods in the code you will be working with use reference and/or const parameters and/or results, so you should understand this material. Detailed Directions Log in to one of the workstations. Create a subdirectory of your cs212 directory named lab4 for use in this lab. (You may use either partner's account.) Copy the files furnished by the professor to your lab4 subdirectory. The following command will work, provided you have made your lab4 subdirectory your current working directory: (Note that the second argument to the cp command is a dot, which means current working directory.) cp /usr/gc/cs212/lab4/*. This should result in the following files being copied into your lab4 subdirectory. You may want to use the ls command to be sure they re all there before proceeding. lab4.h - header file for a recursive implementation of an alphabetical list lab4.cc - partially complete implementation for the above lab4tester.o - test driver Write the code for each of the private methods, replacing the null implementations currently in the skeleton file. Your code must include appropriate comments identifying the base and recursive cases - as in the example above. Give careful attention to making these comments clear and precise. You would be wise to do these one at a time. The first two you should do are insert and print - once you have done these, you can test both these methods and ones you develop subsequently. (See discussion of test driver below) You can compile and link your program using the following command g++ lab4.cc lab4tester.o -o lab4 Answer the following question on your writeup form: Why is the recursive version of printreverse() so much simpler than the non-recursive version discussed in class? 3

4 Test Driver The test driver which you will copy accepts the following commands, which consist of either a single letter, or a single letter followed by a name. Be sure to test your code thoroughly! Correctness of your code will be checked by the professor during grading, instead of during lab. I name Insert name into the list R name Remove name from the list - report success or failure E Make the list empty? Report whether list is empty L name Lookup name - report success or failure P Print list B Print list backwards C Copy list (using copy constructor), then print out copy, then destroy the copy. Q Quit Also, when you quit the tester, it will print out a report of the number of nodes you created using new and the number you deleted using delete. These numbers should be equal - otherwise there is an error in your code (probably in makeempty()) that needs to be fixed! Turn In Writeup form, with printout of lab4.cc attached. Also leave all files in your cs212/lab4 directory. 4

5 APPENDIX A: HEADER FILE FOR ALPHABETICAL LIST CLASS /* * lab4.h: CS212 Lab 4 - operations on an alphabetical list, of strings, * done recursively * * Skeleton copyright (c) 2001, Russell C. Bjork */ #include <string> using namespace std; class AlphabeticalList public: // Constructor - create an empty list AlphabeticalList(); // Copy constructor AlphabeticalList(const AlphabeticalList & rhs); // Assignment AlphabeticalList & operator = (const AlphabeticalList & rhs); // Mutator - insert a new entry in the proper place void insert(string name); // Mutator - remove an entry - return true iff successful bool remove(string name); // Make the list empty - delete all nodes void makeempty(); // Accessor - report whether list is empty bool isempty() const; // Accessor - report whether a name occurs in the list bool lookup(string name) const; // Accessor - print all the elements (in order) to cout void print() const; // Accessor - ditto, but print in reverse order void printreverse() const; // Destructor ~AlphabeticalList(); 5

6 private: class Node; Node * _first; /* The following recursive methods actually do the work */ // Make a deep copy of list. Return a pointer to copy static Node * copy(const Node * list); // Insert name into list. Return pointer to modified list static Node * insert(string name, Node * list); // Remove name from list. Return pointer to modified list. // Set success to true when name is found, if it is static Node * remove(string name, Node * list, bool & success); // Delete all nodes on list static void makeempty(node * list); // Search for name in list - return true iff found static bool lookup(string name, const Node * list); // Print list to cout static void print(const Node * list); ; // Print list to cout in reverse order static void printreverse(const Node * list); class AlphabeticalList::Node public: Node(string name, Node * link) : _name(name), _link(link) string _name; Node * _link; // The following methods are implemented by the tester // to keep track of node allocation/deallocation ; void * operator new(size_t size); void operator delete(void * ptr); 6

7 APPENDIX B: PARTIAL IMPLEMENTATION OF ALPHABETICAL LIST CLASS /* * lab4.cc: Implementation of methods declared in lab4.h * * Skeleton copyright (c) 2001, Russell C. Bjork * */ #include <iostream> using namespace std; #include "lab4.h" AlphabeticalList::AlphabeticalList() : _first(null) AlphabeticalList::AlphabeticalList(const AlphabeticalList & rhs) : _first(null) * this = rhs; AlphabeticalList & AlphabeticalList::operator = (const AlphabeticalList & rhs) // Don't copy over self if (this == & rhs) return * this; // Clear out any existing nodes makeempty(); // Copy the list _first = copy(rhs._first); return * this; void AlphabeticalList::insert(string name) _first = insert(name, _first); bool AlphabeticalList::remove(string name) bool success; _first = remove(name, _first, success); return success; 7

8 void AlphabeticalList::makeEmpty() makeempty(_first); _first = NULL; bool AlphabeticalList::isEmpty() const return _first == NULL; bool AlphabeticalList::lookup(string name) const return lookup(name, _first); void AlphabeticalList::print() const print(_first); void AlphabeticalList::printReverse() const printreverse(_first); AlphabeticalList::~AlphabeticalList() makeempty(); /*** ALL STUDENT CODE GOES HERE. YOUR TASK IN LAB IS TO IMPLEMENT EACH *** OF THE PRIVATE METHODS DECLARED IN lab4.h ***/ -- Stubs currently in place omitted to conserve paper 8