Question

SKIP LIST IMPLEMENTATION (C++)

Described a Skip List implementation where every SkipNode had four pointers: up, down, prev, and next. Describe how we can insert into a Skip List where the SkipNode has only down and next pointers instead. You may assume, for this problem, that you will never flip a coin with enough heads in a row to increase the height of the Skip List.

Answer 1

Implementing the skip list data structure

• The link list element structure used to implement a Skip List
  • The link list element used to implement the skip list has 4 links (not including the data portion):
• The Entry strcuture in a Skip List (the SkipListEntry class)
  • Skip List entry:

    public class SkipListEntry { public String key; public Integer value; public SkipListEntry up; // up link public SkipListEntry down; // down link public SkipListEntry left; // left link public SkipListEntry right; // right link ... (methods) }

    Note:

    As you can see, my entry type is again very specific (no generic types): String key Integer value              When I write the demo program, I will do it using specific types (classes), not parameterized classes I have showed you how to convert a specific class into a parameterized class, so you can write one if you want to Reason for using specific classes: My choice is didactic in nature; I don't want to spend time analyzing the overly complex syntax of parameterized classes I want to spend my time teaching algorithms, not Java syntax

• Making (and using) the special −∞ and +∞ elements
  • Representing the −∞ element and the +∞ element:

    The −∞ and the +∞ is just an ordinary Skip List Entry containing a special value for the key field.

  • We can accommodate the −∞ element and the +∞ element by defining 2 special key value:

    public class SkipListEntry { public String key; public Integer value; public SkipListEntry up, down, left, right; public static String negInf = "-oo"; // -inf key value public static String posInf = "+oo"; // +inf key value .... }

  • How to instantiate a Skip List entry containing +∞:

    SkipListEntry x = new SkipListEntry( SkipListEntry.posInf, null );

    How to check if an Skip List entry x contains +∞:

    key == SkipListEntry.posInf

  OK, now we move on to the Skip list itself....

• Structure (class) to represent a Skip List
  • Remember that a Skip List is a very complicated list

    But.... It is never the less a list

    To represent a list, we only use a pointer (that points to the first element) Often, we use more pointers for improve efficiency (such as a tail pointer)

  • Variables in the SkipList class:

    public class SkipList { public SkipListEntry head; // First element of the top level public SkipListEntry tail; // Last element of the top level public int n; // number of entries in the Skip List public int h; // Height public Random r; // Coin toss .... }

    Note:

    The Random object r is used to determine the height of a newly added entry            (We use r to simulate a coin toss experiment)

  • Example illustrating how the variables are used:

    Note:

    Since the logical top level does not contain any entries: The implementation will omit the logical top layer The variables head and tail provide quick access to the end elements of the real top layer Usage of head and tail: They allow us to easily add an new layer above the top layer

• Constructing a Skip List object
  • The constructor will construct an empty Skip List which looks like this:
  • Constructor code:

    public SkipList() // Constructor... { SkipListEntry p1, p2; /* ----------------------------------- Create an -oo and an +oo object ----------------------------------- */ p1 = new SkipListEntry(SkipListEntry.negInf, null); p2 = new SkipListEntry(SkipListEntry.posInf, null); /* -------------------------------------- Link the -oo and +oo object together --------------------------------------- */ p1.right = p2; p2.left = p1; /* -------------------------------------- Initialize "head" and "tail" --------------------------------------- */ head = p1; tail = p2; /* -------------------------------------- Other initializations --------------------------------------- */ n = 0; // No entries in Skip List h = 0; // Height is 0 r = new Random(); // Make random object to simulate coin toss }

  • The SkipList class so far:

    public class SkipList { public SkipListEntry head; // First element of the top level public SkipListEntry tail; // Last element of the top level public int n; // number of entries in the Skip List public int h; // Height public Random r; // Coin toss public SkipList() // Constructor... { SkipListEntry p1, p2; p1 = new SkipListEntry(SkipListEntry.negInf, null); p2 = new SkipListEntry(SkipListEntry.posInf, null); head = p1; tail = p2; p1.right = p2; p2.left = p1; n = 0; h = 0; r = new Random(); } ... }

• Implementing the basic Map operations
  • Basic Map operations:

    get() put() remove()

    Notice that each basic operation must first find (search) the appropriate entry (using a key) before the operation can be completed.

    So we must learn how to search a Skip List for a given key first....

• Search operation in a skip list
  • Consider the links traversed to locate the key 50:
  • Psuedo code:

    p = head; repeat { Move to the right until your right neighbor node contains a key that is greater than k if ( not lowest level ) Drop down one level else exit }

  • Search algorithm for Skip List:

    /* ------------------------------------------------------ findEntry(k): find the largest key x <= k on the LOWEST level of the Skip List ------------------------------------------------------ */ public SkipListEntry findEntry(String k) { SkipListEntry p; /* ----------------- Start at "head" ----------------- */ p = head; while ( true ) { /* ------------------------------------------------ Search RIGHT until you find a LARGER entry E.g.: k = 34 10 ---> 20 ---> 30 ---> 40 ^ | p must stop here p.right.key = 40 ------------------------------------------------ */ while ( (p.right.key) != SkipListEntry.posInf && (p.right.key).compareTo(k) <= 0 ) { p = p.right; // Move to right } /* --------------------------------- Go down one level if you can... --------------------------------- */ if ( p.down != null ) { p = p.down; // Go downwards } else { break; // We reached the LOWEST level... Exit... } } return(p); // Note: p.key <= k }

  • Note:

    If the key k is found in the Skip List, findEntry(k) will return the reference to the entry containg the key k If the key k is not found in the Skip List, findEntry(k) will return the reference to the floorEntry(k) entry containg a key that is smaller than k Example: findEntry(42) will return the reference to 39:

• Implementing the "get(Key k)" method
  • get(k):

    /** Returns the value associated with a key. */ public Integer get (String k) { SkipListEntry p; p = findEntry(k); if ( k.equals( p.key ) ) return(p.value); else return(null); }

• Put(k,v): inserting into a Skip List
  • Pseudo code for put(k,v):

    put(k, v) { SkipListEntry p; p = findEntry(k); if ( k.equals( p.key ) ) // Found ! { p.value = v; // Update the value