cs 261 - winter 2010
Post on 12-Jan-2016
40 Views
Preview:
DESCRIPTION
TRANSCRIPT
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; }}
top related