Skip CS514: List Implementation (updated!)
March 12, 2002
Tower Nodes are Critical Your implementation of a skip list will rely heavily on a tower node. A tower node is, rather than a single next pointer and key and data variables (if you are programming in Java, replace pointer with reference in this and following discussions) as in a singly linked list, but an array of next pointers along with single key and data variables. You need to be able to do the following to a tower node (these operations form the public interface of the class): * Get/set the tower height. You will not be shrinking nodes, so in setting the height, you need only support making the tower taller (i.e. making the next array longer). * Get/set what the next pointer at a particular height is. * Get/set the data in the node. * Get the key of the node. (You can set the key on object construction the key in the node should never need to change.) IMPLEMENT THE TOWER NODE FIRST, BEFORE YOU DO ANYTHING ELSE! Create a test skip list by artificially setting all the pointers yourself. It is CRITICAL that you test that this class works properly, even though it is not conceptually complicated. I repeat: be sure you get the expected results. One helpful way to test your tower node class is to write a debugging method that prints out each node in the list and the nodes to which each of the next pointers of that node points. This can be implemented either as a recursive method in the tower node class, or as an iterative method which takes in the first node in a list and walks down the nodes by following the next[0] pointers. To print out the nodes, you could print out the keys of the nodes to which each pointer points, but the nodes are not guaranteed to be unique. In a C/C++ implementation, a node is uniquely identified by its memory address; in Java, you could try using the hashCode( ) method (inherited from java.lang.Object) of the tower node to get a unique integer corresponding to the tower node. To The Skip List Class Let study the skip list now in detail. In class and in the paper, we had two conceptual s sentinels. A sentinel can be loosely defined as a structure that participates in the list and has meaning, but is not a data-bearing sentinel. One of these sentinels is the first item in the list, and it is as tall as any item in the list. The other is the last item, which represents a collection of null pointers. We will create a physical representation for the first sentinel only. So, as far as instance-level variables in the class, all we need to do is keep an instance-level pointer to this header sentinel. In the constructor for the class, we set this pointer equal to a new tower node. This node will never be examined in the search, so it doesn matter what t key we assign it; for error-checking purposes, it might be good to assign it a very large negative number, such as -231, so as to distinguish it from a real key.
As far as Dictionary ADT operations go, since search, insert, and delete all have the same fundamental activity, which I will call skip searching, it would be wise to factor it out into a separate method for maintainability and reusability. The skip search boils down to finding the spot before the expected location of the element in question, sort of like in a linked list and in a binary search tree, except you need to find this spot for many levels/paths, not just one. Let look at some code for skip searching that we use to service the other major s ll Dictionary operations. (NOTE: The code below is provided for illustration only and has not been tested. For accuracy sake, I would like to hear of bugs arising from use of this code, s but if such bugs cause your lab not to work, it is your responsibility, NOT mine.)
// In the skip list class constructor, initialize sentinel to be a new // TowerNode with dummy key. Ill refer to it as _listHeader below. /* C++-style skip search algorithm (private method inside skip list) * Java programmers: use . instead of ->, use TowerNode as the return ty pe, and use TowerNode[] as the type for the updatePtrs parameter. - the return value from this method is a reference to the first tower node in the list containing the key, if any - the updatePtrs parameter is an ARRAY of TowerNode pointers for which updatePtrs[maxUpdLvl] down to updatePtrs[0] are the nodes immediately preceding the returned node OR the spot where it should b...