Linked Lists

Okay, we started them last time, but didn't get very far. Be forewarned -- the treatment of linked lists in SLL.h and SLL.cpp is different than in your book. Superior, but different. First things first:

The element class

• Contains a pointer to an element. Yes, this is okay, because when the compiler gets to this point, it already knows that element is a class.
• Has minimal number of functions -- you could easily add others if you wanted, like returning a copy of the string.
• list class is a friend. This is intended to give it the ability to change the element's next pointer. You could abuse this and play with the string, but we won't.
  • We don't want to make next public or defined accessor functions to get at it, because then anybody can mess around with it.
• The list class has a notion of what the "current" element is.
• The element constructor:
  • Sets next to NULL.
  • Makes a copy of the string s. This will avoid the possibility of any dangling reference to the string.

list class

Constructor

Destructor

• Destroys each element individually. You must save the pointer to the next element before you delete the element.
• There is a local variable "next", and there is "x->next" which is member data of an element. They are related, but are not the same thing. "next" holds "x->next" after x has been deleted. (Remember, once we delete something, we aren't allowed to look at it anymore.)
• The way we've gone through the list in the destructor is more complicated than it would need to be if we weren't destroying each element. If we were only going through the list and performing some less harmful action, we could loop like this:

    for (x = head; x != NULL; x = x->next)
        process *x;

insert

• Takes constant time. When using big-O notation, we express a constant as O(1), so we can also say that insert takes O(1) time.
• Allocates an element via the element constructor.
• Inserts the newly created element after the current element. If current == NULL, the new element is the new head of the list.

Here is a series of pictures representing what happens when insert is called in the case in which current points to an element that is neither the head nor the tail. Before anything happens, we have this picture:

The first thing that happens is that a new element is created, called x. x is initialized with the value we intend to insert, the string s. Let's say we want to insert the name "Scott Baker" after "Patrick Roy".

Now that the new element exists, we splice it into the list. First, we adjust the next pointer of x to point to the same thing as current->next.

Now, adjust current's next pointer to point to x, and set current to x.

Et voila! The element is inserted in the list. The process for inserting at the tail is exactly similar, but after the last step, if tail == current, then tail is set to x. The procedure for inserting at the head is a little different. Instead of updating current's next pointer, we update head.

remove

• Takes O(n) time.
• Splices out the current element by making the next pointer of its predecessor skip over it.
• But we need to know the predecessor in order to splice.
• Finding the element such that its next == current takes time linear with respect to the length of the list (in the worst case).

To remove an element from the list:

First thing is to set the pred pointer (a local variable) to the element preceding current. To do this, we must scan through the list. This takes linear time.

Assuming that pred isn't NULL, we set pred->next to current->next.

And finally, we deallocate current and assign current to pred.

If pred is NULL, then we're removing the first element of the list. In this case, we set head to current->next.