Making Versions of a List Program

CS 2500 PROGRAMMING ASSIGNMENT THREE
Part Three: The Ordered Linked List

DUE DATE:

Due Monday, Nov 01. Turn in working versions of main.cpp, ListCls.h, and ListCls.cpp. Also turn in a test script. All these materials must be shar'd into a single archive file and sent via e-mail before midnight, or they will be considered late and will not be accepted.

• programAssignmentRules,
  
• sampleProgramSubmission-level-01,
  
• sampleProgramSubmission-level-02,
  
• sampleProgramSubmission-level-03,
  
• howToMakeTestScript
  
• sampleTestScript-level-01
  
• sampleTestScript-level-02, and
  
• sampleTestScript-level-03
  

THE ASSIGNMENT

DETAILS OF THE RE-WRITE:

Changes Required To listCls.h

• Take out the declaration of the constant MAX_LIST
  
  
• Add declarations for struct listNode and ptrType. (part of the declaration can be put in listCls.cpp, in the manner you see it done on page 172. However, it's also permissible to put all of it in listCls.h)
  
  
• Add a declaration for a destructor with name ~listClass. Use the code on page 171 as a guide. (We will not be bothering with a "copy constructor" this time.)
  
  
• Replace the declaration of the array of list slots with a declaration of a "head" pointer. (c.f. p. 171)
  
  
• Insert a declaration of a function called "PtrTo". (It will be just like the one on page 171. ListRetrieve will need to call PtrTo.)
  
  
• Replace "PosOfKey" -- your function that translates a key value into a list position. The new version of this function might be called "SeekKey". It's job is as described in the following header comment text:
  
  /*
  SeekKey determines whether a node with key value theKey is in the list. SeekKey reports where the node is, or where it should be.
  
  INPUTS: The list. theKey -- the key value of an item whose position is to be determined.
  
  PRECONDITIONS: The list is in key order and contains at most one item with key value equal to theKey.
  
  OUTPUTS: The list. Success -- set to indicate whether an item with key value equal to theKey was found. prev and cur -- pointers to represent information about the location where the element sought is or should be.
  
  POSTCONDITIONS: Success is true if the list contains a node with key value equal to theKey. Otherwise, Success is false.
  
  If Success is true, cur points to the list node X with key value equal to theKey. Generally prev points to the predecessor of X. However, if X is the first element of the list then prev is NULL.
  
  If Success is false and the list contains any nodes with key greater than theKey, then cur points to the first such node Y. Otherwise, cur is NULL. Generally, prev points to the predecessor of Y. However, if Y is the first node, or if the list is empty then prev is NULL. Another exception is that if cur is NULL and the list is not empty then prev points to the last node.
  */
  
  

Changes Required To listCls.cpp

• Change the constructor so it initializes "head" to NULL (c.f. page 172)
  
  
• Insert code for a destructor. (c.f. page 174) Here is pseudo code for what the destructor has to do:
  

    WHILE "head" is not NULL DO
    {
      copy "head" to "temp" ;
      make "head" equal to the "next" field of the node that head
            currently points to ;
      call "delete" to free the node that "temp" points to.
    }
  

• In ListClass::ListInsert, replace the local variable that denotes list position with two pointer variables, "prev" and "cur"
  
  
• Also in ListInsert, replace the call to "PosOfKey" with a call to "SeekKey".
  
  
• In ListInsert, remove the condition that Size < MAX_LIST from the definition of Success.
  
  
• Replace the rest of the code in ListInsert with code similar (not identical) to that on page 176. When you need to specify locations of nodes, use the values of "prev" and "cur". The code on page 176 uses "NewPosition" and "PtrTo" to specify locations. This is not appropriate for your version of the module.
  
  
• Make changes to ListClass::ListDelete. Do this in a manner like ListInsert was changed. I'm leaving it as an exercise for you to figure out the rest of the details. Use the code on page 177 for hints.
  
  
• Rewrite ListClass::ListRetrieve. Except for changes you may need to make it conform with your naming conventions, ListRetrieve can be just like the version on pages 175-176.
  
  
• Insert code for the function "PtrTo". As with ListRetrieve, "PtrTo" can be virtually identical to the version on page 175.
  
  
• Replace PosOfKey with SeekKey. Here is pseudo code for SeekKey:

    void function
      listClass::SeekKey
        (keyType theKey, bool& Success, ptrType& prev, ptrType& cur)
  
    init prev to NULL and cur to head;
    WHILE ((cur is not NULL) AND
           (the key of the current node is less than theKey)) DO
    { 
      change the value of prev to cur;
      change the value of cur to the "next" field of the node
             that cur now points to.
    }
    IF cur is NULL now then set Success to false;
    ELSE IF cur now points to a node matching theKey
             set Success to true
          ELSE set Success to false 

DUE DATE:

Due Monday, Nov 01. Turn in working versions of main.cpp, ListCls.h, and ListCls.cpp. Also turn in a test script. All these materials must be shar'd into a single archive file and sent via e-mail before midnight, or they will be considered late and will not be accepted.