cs240 Lab10

CS 240
Lab 10

Purpose: To explore some advanced variants of pointer-based linked lists.

Reading: Linked lists with head nodes are discussed on pp. 586-589. Circular linked lists, with and without head nodes, are discussed on pp. 589-591. Multiply-ordered linked lists are discussed on pp. 631-632.

Assignment: We have already implemented an ordered, pointer-based, simple linked list in lab 3. We have seen that this type of data structure can expand or contract as needed, can maintain its elements in an ordered manner, can allow sequential access to its elements, and can allow insertion and deletion of elements without any shifting.

The file LinkedList.h contains a template for the kind of simple linked list described above (LinkTester.cpp has also been provided so that you can try it out if you like However, please write your own testers for the following!). In this lab you will copy and rename this file for each step, then modify it as directed below.

Linked list with head node (HeadNodeList.h): Since the first node in a simple linked list does not have a predecessor, insertion to either an empty list or to the front of the list requires special logic. It follows, therefore, that if it were possible for every node to have a predecessor, this special logic would be unnecessary. This is the rationale behind using a dummy first node, called a head node, at the beginning of a list.

Rename your class HeadNodeList.
Modify the linked-list constructor to create a dummy node, set its next field to NULL, and have first point to it. Note: except for the fact that it does not contain any list element, a head node is created just like any other node.
Modify the isEmpty() function so that it checks to see if first->next is equal to NULL.
Modify the copy-constructor and overloaded assignment operator to accommodate a dummy head node (i.e., do not attempt to access its data field).
Must the destructor be modified?
Modify the display function so that it does not attempt to output the head node.
Modify the insert and remove functions: notice how using a head node streamlines the logic.
A small modification will have to be made to the search function as well: Do not attempt to access the data field of the head node.
Write a suitable tester, compile, and run.

Circular linked list (CircularList.h): It is sometimes useful to insure that every node has both a predecessor and a successor, except when the list is empty. This can be accomplished by making the last node in a linkedlist point to the first node in the list (instead of pointing to NULL). Construction of this circular linked list will simplify some operations, while requiring special consideration for others.

Rename your class CircularList.
Construction of an empty circular linked list is the same as that for a simple linked list.
Like a simple linked list, the list is empty when first == NULL.
Except for the case of an empty list, the copy-constructor and overloaded assignment operator must modify their loop conditions, and must insure that the last node in the new list points to the first node in the new list.
Modify the loop condition for the destructor.
Modify the loop condition of the display function.
The insert function will require special logic for insertion into an empty list so that the single node will point to itself. Although every node now has a predecessor and a successor, what happens when a node must be inserted to the front of the list?
The remove function will require special logic for deletion from a one-element list (so that the list will become empty if a node is its own successor). What happens when a node must be removed from the front of the list?
The loop condition as well as the boolean condition after the loop of the search function will need to be modified.
Would it be easier to implement a circular linked list if a pointer were maintained to the last node in the list, instead of the first node? How would this change the implementation? (Be ready to discuss your answer).
Write a suitable tester, compile, and run.

Circular linked list with head node (CircularHeadNode.h): Many of the above special considerations are simplified if a circular linked list is constructed with a head node.

Start as above, and rename your class CircularHeadNode.
Construction of an empty circular linked list with a head node is similar to that of the construction of a linked list with a head node - except that the head node is made to point to itself.
The list is empty when the head node points to itself.
The copy-constructor and overloaded assignment operator must both modify their loop conditions, insure that the last node in the new list points to the first node in the new list, and make sure that they do not attempt to access the data field of the head node.
The loop condition for the destructor must be modified.
The display function must not attempt to output the data field of the head node, and its loop condition must be modified.
The insert and remove functions must be modified as appropriate: it will now be possible to simplify their logic.
The loop condition of the search function must be modified, and it must not access the data field of the head node.
Write a suitable tester, compile, and run.

Multiply-Ordered list(MultiplyOrderedList): A simple linked list is ordered by a single data field. It is not unusual, however, for a list element to contain several pieces of data, each of which could be ordered with its own next field.

Rename your class MultiplyOrderedList.
Modify your class so that it contains three first data members (first1, first2, and first3).
Modify your Node class so that it contains three data fields (Name, Address, and ZipCode) and three next fields (next1, next2, and next3).
Modify your class as needed to correctly implement all three orderings. Note: each insert and remove operation will now involve comparisons of three fields, not just one.
Write a suitable tester, compile, and run.