An Introduction to Data Structures

Chapter 16: An Introduction to Data Structures - II

Lecture Goal

To be able to implement linked lists

Linked Lists

Inserting an element.

Removing an element.

Implementing Linked Lists (The Classes for Lists, Nodes, and Iterators)

We will start with a linked list of strings.

A linked list stores each value in a separate object called a node.

class Node {
public:
   Node(string s);
private:
   string data;
   Node* previous;
   Node* next;
friend class List;
friend class Iterator;
};

The friend declarations indicate the List and Iterator member functions are allowed to inspect and modify the data members of the Node class.
A class should not grant friendship to another class lightly, because it breaks the privacy protection.

The list object holds the locations of the first and last nodes in the list.

class List {
public:
   List();
   void push_back(string s);
   void insert(Iterator pos, string s);
   Iterator erase(Iterator pos);
   Iterator begin();
   Iterator end();
private:
   Node* first;
   Node* last;
};

When the list is empty the first and last pointers are NULL.
A list object stores no data; it just knows where to find the node objects that store the list contents.

An iterator denotes a position in the list.

class Iterator {
public:
   Iterator();
   string get() const;     /* use instead of * */
   void next();            /* use instead of ++ */
   void previous();        /* use instead of -- */
   bool equals(Iterator b) const; /* use instead of == */
private:
   Node* position;
   Node* last;
friend class List;
};

We will enable the operators ++, --, * and == in the next chapter.
If the iterator points past the end of the list, then the position pointer is NULL.
The iterator stores a pointer to the last element of the list, so that the previous method can move the iterator back from the past-the-end position to the last element of the list.

Implementing Linked Lists (Implementing Iterators)

Iterators are created by the begin and end functions of the List class.

Iterator List::begin() {
   Iterator iter;
   iter.position = first;
   iter.last = last;
   return iter;
}

Iterator List::end() {
   Iterator iter;
   iter.position = NULL;
   iter.last = last;
   return iter;
}

The next function advances the iterator to the next position.

Note that it is illegal to advance the iterator once it is in the past-the-end position.
```
void Iterator::next()
{  assert(position != NULL)
   position = position->next;
}
```
The previous function is similar.

When the iterator points to the first element in the list, it is illegal to move it further backward.

void Iterator::previous()
{  if (position == NULL) position = last;
   else    position = position->previous;
   assert(position != NULL);
}

The get function simply returns the data value of the node to which position points.

string Iterator::get() const
{  assert(position != NULL);
   return position->data;
}

The equals function compares two position pointers.

bool Iterator::equals(Iterator b) const
{  return position == b.position; }

Implementing Linked Lists (Implementing Insertion and Removal)

For the push_back function, we must first make a new node.
```
Node* newnode = new Node(s);
```

The node must point back to the old end of the list, while the old end must point to it.

newnode->previous = last; // (1)
last->next = newnode;     // (2)
last = newnode;           // (3) !

There is a special case when last is NULL (the list is empty).
```
if (last == NULL)
{  first = newnode;
   last = newnode;
}
```

The complete member-function:

void List::push_back(string s)
{  Node* newnode = new Node(s);
   if (last == NULL) /* list is empty */
   {  first = newnode;
      last = newnode;
   }
   else
   {  newnode->previous = last;
      last->next = newnode;
      last = newnode;
   }
}

To insert an element in the middle of the list requires manipulating both elements on either side of the new node.

There is a special case when the list is empty.

if (iter.position == NULL)
{  push_back(s);
   return;
}

Otherwise we create pointers to track the surrounding nodes.
```
Node* after = iter.position;
Node* before = after->previous;
```

We tell the new node where it belongs in the list.

newnode->previous = before; // (1)
newnode->next = after;      // (2)

Then update the surrounding nodes.

after->previous = newnode;  // (3)
if (before == NULL) /* insert at beginning */
   first = newnode;
else
   before->next = newnode;  // (4)

When know that after is not NULL, but before could be.

As with insertion, we will need to work with both the element before and after the one to be removed.

Of course we cannot remove a node that is not there.

assert(iter.position != NULL)

We create pointers to track all three nodes we need to work with.

Node* remove = iter.position;
Node* before = remove->previous;
Node* after = remove->next;

We disconnect the node to be removed from the one before it; note the special case when we delete from the front of the list.

if (remove == first) first = after;
else   before->next = after;

We repeat the process with the node after the one to delete.

if (remove == last) last = before;
else   after->previous = before;

Finally we delete the node.

delete remove;