Array of references to references to objects? Skip lists...

Question

I'm trying to hammer out a SkipList ADT by tomorrow night. The structure of my SkipList is basically: A Skip list has a reference to the first SkipListNode. Each SkipListNode has an array of links, where a link of level 1 links to the next node that is at least level 1 (every node is at least level 1), and array of 2 links to the next node down the list that is at least that tall, etc. For the last tallest node in the list, it will have links that are null, as there are no nodes after it which can reach up to its higher level links.
My problem is that as I traverse the list looking for the insert position, I need to keep track of the taller links which may be 'cut-off' by the newly inserted node. Just as with a normal LinkedList, I would want to make the new node point to where these old links pointed, and point the old links to the new node. What I have been trying to do is build an array:
SkipListNode previousLinks[] = new SkipListNode[levelOfTallestNodeInSkipList];
As I traverse a SkipListNode, I over-write the previousLinks[i] with every level i link I encounter. For example say I'm in a level 5 node (currentNode) with key 15. I'm trying to inser key 17. I try the level 5 node's level 5 link and its null, so I would want to make previousLinks[5] = currentNode[5]. I then try currentNode's level 4 link, it's not null but it points to a node with key 47, which is past the insertion point for a node with key 17. So again, I want previousLinks[4] to REFER TO currentNode[4]. Etc, etc... I get down to currentNode's level 1 link and see it links to a node with key 16 and level 1. Ok, this is less than 17 so I make currentNode = key 16 node (which is lvl 1). Then I traverse currentNode's only link- a level 1 link- and see that it links to a node with key 18. BOOM: here's the insert point. I randomly select level 4 for the new node which will hold 17. This means that I will 'cut-off' the level four link of the node holding key 15. What I want to be able to do is:
/*connect new links to where old links point to*/
for (int k = 0; k < newNode.level; k++) {
if (k < current.level)
newNode.links[k] = previousLinks[k];
else
newNode.links[k] = null;
/*connect old links to newly created node*/
for (int k = 0;
k < Math.min(current.level, newNode.level); k++)
previousLinks[k] = newNode;
But this doesn't work. The previousLinks array seems to only hold the values which were copied from the earlier nodes, not references to the fields in the nodes which point further down the list. What I want is a C++ style array of pointers to fields in an object's array so that I can change where these fields point (refer).
I hope this post makes enough sense for someone to at least give me a clue... thanks.

Answer 1

My skiplist implementation has a method to lookup a node. The resultant array of nodes has length the maximum height of the skiplist. At each level the array containes a reference to the node prior to the one I am looking for at that level. This allows me to patch all the relevant nodes when I add/remove an item to/from the skiplist.
My code might help give you the idea.
     * Looks up the payload in the list returning an array
     * of nodes that point to the element immediately before
     * the desired element.
     * @param target the node we are searching for
     * @return and array of Nodes that are just prior to the
     * node we are looking for.
    private Node[] lookup(Node target)
        Node[] update = new Node[MAX_HEIGHT+1];
        int k = m_height;
        Node p = m_header;
        do
            Node q = null;
            while (((q = p.getNext(k) )!= null) && (m_comparator.lessThan(q, target))) p = q;
            update[k] = p;
        }  while (--k >= 0);
        return update;
    }