CS 261 - Winter 2010

Skip Lists

Skip Lists Advantages

• Ordinary linked lists and arrays have fast (O(1)) addition, but slow search

• Sorted Vectors have fast search (O(log n)) but slow insertion

• Skip Lists have it all - fast (O(log n)) addition, search and removal times!

• Cost - Slightly more complicated

Start with an ordered listLets begin with a simple ordered list, sentinel on

the left, single links.

Start of the struct definition

struct skiplist {

struct skiplink * sentinel;

int size;

};

Operations

• Add (Object newValue) - find correct location, add the value

• Contains (Object testValue) - find correct location, see if its what we want

• Remove (Object testValue) - find correct location, possibly remove it

• See anything in common?

Slide Right

struct skiplink * slideRight (struct skiplink * current, EleType testValue) {

while ((current->next != 0) && LT(current->next->value, testValue))

current = current->next; return current;}

Finds the link RIGHT BEFORE the place the value we want should be, if it is there

Add (EleType newValue)

void add (struct skiplist* lst, EleType newValue) { struct skiplink * current = slideRight(lst->sentinel, newValue); struct link * newLink = (struct link *) malloc(sizeof(struct

link)); assert (newLink != 0); newLink->value = newValue; newLink->next = current->next; current->next = newLink; lst->size++;}

Contains (EleType testValue)

int contains (struct skip *lst, EleType testValue) {

struct skiplink * current =

slideRight (lst->leftSentinel, testValue);

if ((current->next != 0) &&

(EQ(testValue, current->next->value)))

return true;

return false;

} /* reminder, this is one level list, not real skiplist */

Remove (Object testValue)

void remove (struct skiplist *lst, EleType testValue) { struct skiplink * current = slideRight (lst->leftSentinel, testValue); if ((current->next != 0) && (EQ(testValue, current->next->value))) { current->next = current->next->next; free(current->next); lst->size--; } }

Problem with Sorted List

• What’s the use?

• Add is still O(n), so is contains, so is remove.

• No better than an ordinary list.

• Major problem with list - sequential access

Why no binary search?What if we kept a link to middle of list?

But need to keep going

And going and going

In theory it would work…..

• In theory this would work

• Would give us nice O(log n) search

• But would be really hard to maintain as values were inserted and removed

• What about if we relax the rules, and don’t try to be so precise…..

The power of probability

• Instead of being precise, keep a hierarchy of ordered lists with downward pointers

• Each list has approximately half the elements of the one below

• So, if the bottom list has n elements, how many levels are there??

Picture of Skip List

Slightly bigger list

Contains (Object testValue)

• Starting at topmost sentinel, slide right

• If next value is it, return true

• If next value is not what we are looking for, move down and slide right

• If we get to bottom without finding it, return false

Notes about contains

• See how it makes a zig-zag from top to bottom

• On average, slide only moves one or two positions

• So basically proportional to height of structure

• Which is????? O( ?? )

Remove Algorithm

• Start at topmost sentinal

• Loop as follows– Slide right. If next element is the one we

want, remove it – If no down element, reduce size– Move down

Notice about Remove

• Only want to decrement size counter if at bottom level

• Again, makes zig-zag motion to bottom, is proportional to height

• So it is again O(log n)

Add (Object newElement)

• Now we come to addition - the most complex operation.

• Intuitive idea - add to bottom row (remember to increment count)

• Move upwards, flipping a coin• As long as heads, add to next higher row• At top, again flip, if heads make new row

Add ExampleInsert the following: 9 14 7 3 20

Coin toss: T H T H H T T H T (insert if heads)

The Power of Chance

• At each step we flip a coin• So the exact structure is not predictable,

and will be different even if you add the same elements in same order over again

• But the gross structure is predictable, because if you flip a coin N times as N gets large you expect N/2 to be heads.

Notes on Add

• Again proportional to height of structure, not number of nodes in list

• So also O(log n)

• So all three operations are O(log n) !

• By far the fastest overall Bag structure we have seen!

• (Downside - does use a lot of memory as values are repeated. But who cares about memory? )

int skipListContains(struct skipList* slst, EleType d) {

struct skipLink *tmp = slst->topSentinel;

while (tmp != 0) { tmp = slideRight(tmp, d); if ((tmp->next != 0) && EQ(d, tmp->next->value))

return 1; tmp = tmp->down; } return 0;}

void skipListAdd(struct skipList * slst, EleType d) {

struct skipLink *downLink, *newLink; downLink = skipLinkAdd(slideRight(slst->topSentinel,d),d);

if (downLink != 0 && skipFlip()) { newLink = newSkipLink(d, 0, downLink);

slst->topSentinel = newSkipLink(0, newLink, slst->topSentinel);

} slst->size++;}

struct skipLink* skipLinkAdd(struct skipLink * current, EleType d) {

struct skipLink *newLink, *downLink; newLink = 0; if (current->down == 0) { newLink = newSkipLink(d, current->next, 0); current->next = newLink; } else { downLink = skipLinkAdd(slideRight(current-

>down, d), d); if (downLink != 0 && skipFlip()) { newLink = newSkipLink(d, current-

>next, downLink); current->next = newLink; } } return newLink;}

struct skipLink* newSkipLink(EleType d, struct skipLink * nlnk, struct skipLink* dlnk) {

struct skipLink * tmp = (struct skipLink *) malloc(sizeof(struct skipLink));

assert(tmp != 0); tmp->value = d; tmp->next = nlnk; tmp->down = dlnk; return tmp;}

int skipFlip() { return rand() % 2; }

void skipListRemove(struct skipList* slst, EleType d) { struct skipLink *current, *tmp; current = slst->topSentinel; while (current != 0) { current = slideRight(current, d); if (current->next != 0 && EQ(d,

current->next->value)) { tmp = current->next; current->next = current->next-

>next; free(tmp); if (current->down != 0) slst->size--; } current = current->down; }}