bool IntList::Contains(ListElement * current, int value){
  if (current == NULL) {
    return false;
  } else if (current->data == value) {
    return true;
  } else {
    return Contains(current->next, value);
  }
}

void IntList::PrintList(ListElement * current){
  if (current != NULL) {
    cout << current->data << ' ';
    PrintList(current->next);
  }
}

void IntList::DeleteList(ListElement * current){
  // Delete nodes from the tail to the head
  if (current != NULL) {
    DeleteListRec(current->next);
    delete current;
  }
}

These recursive definitions, however, do have some undesirable features. Although Contains() works identically to its iterative counterpart, PrintList() does not output the "Here is the list:" comment. Can you see why this cannot easily be put in the recursive function?

More importantly, the recursive definition of DeleteList() shown above can, under some circumstances, cause a runtime error. Although it does delete all nodes, and will work perfectly as a destructor, it does not set head=NULL afterwards. (Look at the pictures, they'll show this to you!)

For this reason, we will wrap all recursive methods in an extra method that takes care of additional tasks (such as writing a comment to the screen, setting head=NULL) and special cases (such as adding to an empty list). As an added bonus we find that our recursive and iterative implementations of the class will now have identical interfaces (if you do not know what this means, the so called "interface-implementation separation", find out now -- re-read your CS210 notes). The user will then not have to pass the head of the list to Contains(), PrintList(), or DeleteList() as shown above; they may call the method as if it were an iterative implementation.