My approach to explaining skip lists is significantly different from the explanation in the MSDN article, and there are differences in the implementation as well.

So, I wouldn’t say that my post is redundant.

Linked lists:
http://msdn.microsoft.com/en-u.....S.80).aspx

Other data structures (queue, stack, BT, BST, etc.):
http://msdn.microsoft.com/en-u.....S.80).aspx

http://tech.puredanger.com/2007/10/03/skip-lists/

You should really also check out the ConcurrentSkipListMap included in Java 6:

http://java.sun.com/javase/6/d.....stMap.html

One of the big benefits of skip lists is that because they are built around linked lists, they can exhibit very localized locking. ConcurrentSkipListMap is a concurrent skip list based map and is written in lock free style (no synchronization, relies solely on CAS-like operations). This makes ConcurrentSkipListMap a concurrent sorted map with excellent performance. I’d recommend reading the source code as well as it is extremely well written and a great example of lock-free coding.

One last note on ‘my’ implementation: i think it’s better (in general) to restore the randon number generation instead of using the hashcode to determine the depth of the node. Using hashcodes in case of integers will generate a nice distribution, but for all other types all bets are off

Requiring where T : IComparable on the list is desirable.

(i just noticed that the type parameters in my sample are missing, just the better, this will prevent viewers from using it as-is, with all the known defects )

Wow, seems like you looked at skip lists pretty in depth! Awesome, experimentation is a great way to learn. Here are responses to some of your points:

- The “distribution” of nodes: see answer to AlexR I just posted.

- GetHashCode: if two values are equal, then their hash codes are guaranteed to be equal. But, hash codes are not intended for less-than-greater-than comparison, and don’t work that way in general.

- O(N) vs O(N/2): it is true that in a sorted list, a lookup will visit N/2 nodes on average. In the big-Oh notation, O(N) is the same as O(N/2), and it is customary to drop the constant factor of 1/2.

- Note that a skip list is an ordered data structure, so it can do a number of things efficiently that a hash table cannot: e.g. in-order enumeration, find the smallest element larger than X, etc.

- When running your benchmarks, make sure you are measuring a RELEASE build rather than a DEBUG build.

Hope that helps, and thanks for reading.

How does skip list do that? These two properties ensure it:
1. About 1/2 of nodes are in the lowest list only, about 1/4 nodes are in the lowest two lists, 1/8 in the lowest three, and so forth.
2. Nodes with different “heights” are mixed up about evenly.

After any sequence of insertions and removals, properties (1) and (2) still hold.

You can define these properties much more precisely, and use them to prove that insertion, removal and lookup are O(log N) on a skip list, with a very high probability.

Makes sense?