CS 261 - Winter 2011

Linked List Introduction

Problem with Array and Dynamic Array

• The problem with an array is that elements are kept in a single large block of memory

• Can often use more memory than necessary if collection grows and shrinks repeatedly

• Linked list is a good alternative, as the memory use is always proportional to the number of elements in the collection

Characteristics of Linked Lists

• Elements are held in objects termed Links

• Links are 1-1 with elements, allocated and released as necessary.

• Each link points to next link in sequence, sometimes to previous link.

• Lots of variations on a simple idea

A typical Link Structure

struct link {

EleType value;

struct link * next;

};

Some variations in Linked lists

• List have header (special value to point to start)

• Use null as terminator, or special value for end

• Use single or double links?

• Pointer to first element, or pointer to first and last

Simplest Example, List Stack

• List stack is the simplest data structure that can be implemented using linked list idea

• Keep pointer to first element (null if empty)

• Elements are added or removed from front

• can only access first element

Picture of list stack

Code for list stackstruct ListStack {

struct link * firstLink; /* initialize sets to zero */

};

void listStackPush (struct listStack *stk, double val)

{

stk->firstLink = _newLink(val, stk->firstLink);

}

Internal utility routine

struct link * _newLink (EleType v, struct link * n) { struct link * lnk = (struct link *) malloc(sizeof(struct link)); assert (lnk != 0); lnk->value = v; lnk->next = n; return lnk;}

Think about how to write Top, push, isEmpty

• What are the steps involved in returning top of stack?

• Removing top of stack?

• Returning true (1) if stack is empty, and false (0) if it is not empty

How fast is List Stack?

• Compare to dyArrayStack

• push - list O(1) always, dyArray(1) expected

• pop - list O(1) always, dyArray same

• top - list O(1) always, dyArray same

• In practice dyArray is slightly faster in real timinings.

But what about queues?

• An array queue is hard to do, because you can't add to the beginning without sliding things up.

• With lists it is easy. Just keep a pointer to both the front AND the back.

• Elements added to the back, removed from front

Picture of list queue

Why add to back, remove fron front?

• Think about the issues

• Why not other way around?

• Container where you can add to back or front, but remove from front only, is sometimes called a Scroll.

Sentinels get rid of special cases

• Notice in discussing pop we needed to treat removing last element as special case.

• Can avoid this by using a Sentinel

• A sentinel is just a link without a value, never removed, sits at front or back of the collection.

• Don’t need to check for removing last val

Picture of Sentinel

Sentinel 3 9 7 4

Front ptrBack ptr

Class Structure for List Queuestruct listQueue {

struct link * firstLink;

struct link * lastLink;

};

void listQueueAddBack (struct listQueue *lst, EleType val);

Init makes the sentinel

void ListQueueInit (struct listQueue *q) {

struct slink *lnk = (struct slink *)

malloc(sizeof(struct slink));

assert(lnk != 0); /* lnk is the sentinel */

lnk->next = 0;

q->firstLink = q->lastLink = lnk;

}

Elements are Added to endvoid listQueueAddLast (struct listQueue *q,

EleType val) {

q->lastLink->next = _newLink(val, 0);

q->lastLink = q->lastLink->next;

}

Are there any special cases?

Return the front element

• How do you return the front element? Are there any special cases?

• How do you remove the front element? Again, are there special cases?

• How do you tell if the list is empty?

What about a deque?

• What if we want to add and remove elements from both front and back?

• Need to use links going both forward and backwards

• Makes adding a new link harder, as must maintain both forward and backward links.

• Will do that in tomarrows lesson

What about a Bag?

• Contains is easy - just a loop

• Add is easy - can either add to front or to back

• Remove is the tricky one. How to patch up links after removing an element.

• Two solutions, double links or previous pointers (will do double links tomarrow)

Previous Pointers• As you loop over the links looking for value to

remove, keep pointer to previous elementStruct link prevLink = q->firstLink;Struct link current;for (current = prev->next ; current != 0; current = current-

>link) { if (EQ(current->value, testValue)) { // do what needs to be done return; } prevLink = current;}

When you find it

• When you find the element to be deleted, what does prev point to?

• What if the element to be deleted is at the front of the list? Does this matter?

Your turn

• See if you can do stack (should be trivial)

• See if you can do queue (only slightly harder)

• See if you can do bag (requires a little more thought)