JAVA SkipList 跳表 的原理和使用例子

跳跃表是一种随机化数据结构，基于并联的链表，其效率可比拟于二叉查找树(对于大多数操作需要O(log n)平均时间)，并且对并发算法友好。

关于跳跃表的具体介绍可以参考MIT的公开课：跳跃表

跳跃表的应用

Skip list(跳表）是一种可以代替平衡树的数据结构，默认是按照Key值升序的。Skip list让已排序的数据分布在多层链表中，以0-1随机数决定一个数据的向上攀升与否，通过“空间来换取时间”的一个算法，在每个节点中增加了向前的指针，在插入、删除、查找时可以忽略一些不可能涉及到的结点，从而提高了效率。

在Java的API中已经有了实现：分别是

ConcurrentSkipListMap(在功能上对应HashTable、HashMap、TreeMap) ；

ConcurrentSkipListSet(在功能上对应HashSet). 

确切来说，SkipList更像Java中的TreeMap，TreeMap基于红黑树（一种自平衡二叉查找树）实现的，时间复杂度平均能达到O(log n)。

HashMap是基于散列表实现的，时间复杂度平均能达到O(1)。ConcurrentSkipListMap是基于跳表实现的，时间复杂度平均能达到O(log n)。

Skip list的性质

(1) 由很多层结构组成，level是通过一定的概率随机产生的。
(2) 每一层都是一个有序的链表，默认是升序
(3) 最底层(Level 1)的链表包含所有元素。
(4) 如果一个元素出现在Level i 的链表中，则它在Level i 之下的链表也都会出现。
(5) 每个节点包含两个指针，一个指向同一链表中的下一个元素，一个指向下面一层的元素。

Ø  ConcurrentSkipListMap具有Skip list的性质 ，并且适用于大规模数据的并发访问。多个线程可以安全地并发执行插入、移除、更新和访问操作。与其他有锁机制的数据结构在巨大的压力下相比有优势。

Ø  TreeMap插入数据时平衡树采用严格的旋转（比如平衡二叉树有左旋右旋）来保证平衡，因此Skip list比较容易实现，而且相比平衡树有着较高的运行效率。

Java代码实现：

1. SkipListEntry.java ， 这是跳跃表中存储的每个元素实体类，包含 上下左右 四个指针。
01
    package skiplist;
02

03
    public class SkipListEntry {
04
        public String key;
05
        public Integer value;
06

07
        public int pos; //主要为了打印 链表用
08

09
        public SkipListEntry up, down, left, right; // 上下左右 四个指针
10

11
        public static String negInf = new String("-oo"); // 负无穷
12
        public static String posInf = new String("+oo"); // 正无穷
13

14
        public SkipListEntry(String k, Integer v) {
15
            key = k;
16
            value = v;
17

18
            up = down = left = right = null;
19
        }
20

21
        public Integer getValue() {
22
            return value;
23
        }
24

25
        public String getKey() {
26
            return key;
27
        }
28

29
        public Integer setValue(Integer val) {
30
            Integer oldValue = value;
31
            value = val;
32
            return oldValue;
33
        }
34

35
        public boolean equals(Object o) {
36
            SkipListEntry ent;
37
            try {
38
                ent = (SkipListEntry) o; // 检测类型
39
            } catch (ClassCastException ex) {
40
                return false;
41
            }
42
            return (ent.getKey() == key) && (ent.getValue() == value);
43
        }
44

45
        public String toString() {
46
            return "(" + key + "," + value + ")";
47
        }
48
    }

2. SkipList.java, 跳跃表类，包含算法的实现。 head 和 tail 分别是 顶层的头和尾。
001
    package skiplist;
002

003
    import java.util.*;
004

005
    public class SkipList {
006
        public SkipListEntry head; // 顶层的第一个元素
007
        public SkipListEntry tail; // 顶层的最后一个元素
008

009
        public int n; // 跳跃表中的元素个数
010

011
        public int h; // 跳跃表的高度
012
        public Random r; // 投掷硬币
013

014
        public SkipList() // 默认构造函数...
015
        {
016
            SkipListEntry p1, p2;
017

018
            p1 = new SkipListEntry(SkipListEntry.negInf, null);
019
            p2 = new SkipListEntry(SkipListEntry.posInf, null);
020

021
            head = p1;
022
            tail = p2;
023

024
            p1.right = p2;
025
            p2.left = p1;
026

027
            n = 0;
028
            h = 0;
029
            r = new Random();
030
        }
031

032
        /** 返回 包含的元素个数 */
033
        public int size() {
034
            return n;
035
        }
036

037
        /** 跳跃表是否为空 */
038
        public boolean isEmpty() {
039
            return (n == 0);
040
        }
041

042
         //在最下面一层，找到要插入的位置前面的那个key
043
        public SkipListEntry findEntry(String k) {
044
            SkipListEntry p;
045
            p = head;
046

047
            while (true) {
048
                /**
049
                 * 一直向右找，例: k=34.
050
                 * 10 ---> 20 ---> 30 ---> 40 ^ | p 会在30处停止
051
                 * --------------------------------------------
052
                 ***/
053
                while (p.right.key != SkipListEntry.posInf
054
                        && p.right.key.compareTo(k) <= 0) {
055
                    p = p.right;
056
                //  System.out.println(">>>> " + p.key);
057
                }
058
                // 如果还有下一层，就到下一层继续查找
059
                if (p.down != null) {
060
                    p = p.down;
061
                     //System.out.println("vvvv " + p.key);
062
                } else
063
                    break; // 到了最下面一层 就停止查找
064
            }
065

066
            return (p); // p.key <= k
067
        }
068

069
        /** 返回和key绑定的值 */
070
        public Integer get(String k) {
071
            SkipListEntry p;
072

073
            p = findEntry(k);
074

075
            if (k.equals(p.getKey()))
076
                return (p.value);
077
            else
078
                return (null);
079
        }
080

081
        /** 放一个key-value到跳跃表中, 替换原有的并返回 */
082
        public Integer put(String k, Integer v) {
083
            SkipListEntry p, q;
084
            int i;
085

086
            p = findEntry(k);
087

088
            if (k.equals(p.getKey())) {
089
                Integer old = p.value;
090
                p.value = v;
091
                return (old);
092
            }
093

094
            q = new SkipListEntry(k, v);
095
            q.left = p;
096
            q.right = p.right;
097
            p.right.left = q;
098
            p.right = q;
099

100
            i = 0; // 当前层 level = 0
101

102
            while (r.nextDouble() < 0.5) {
103

104
                //如果超出了高度，需要重新建一个顶层
105
                if (i >= h) {
106
                    SkipListEntry p1, p2;
107

108
                    h = h + 1;
109
                    p1 = new SkipListEntry(SkipListEntry.negInf, null);
110
                    p2 = new SkipListEntry(SkipListEntry.posInf, null);
111

112
                    p1.right = p2;
113
                    p1.down = head;
114

115
                    p2.left = p1;
116
                    p2.down = tail;
117

118
                    head.up = p1;
119
                    tail.up = p2;
120

121
                    head = p1;
122
                    tail = p2;
123
                }
124

125
                while (p.up == null) {
126
                    p = p.left;
127
                }
128
                p = p.up;
129

130
                SkipListEntry e;
131

132
                e = new SkipListEntry(k, null);
133
                e.left = p;
134
                e.right = p.right;
135
                e.down = q;
136

137
                p.right.left = e;
138
                p.right = e;
139
                q.up = e;
140

141
                q = e; // q 进行下一层迭代
142
                i = i + 1; // 当前层 +1
143

144
            }
145
            n = n + 1;
146

147
            return (null); // No old value
148
        }
149

150
        public Integer remove(String key) {
151
            return (null);
152
        }
153

154
        public void printHorizontal() {
155
            String s = "";
156
            int i;
157
            SkipListEntry p;
158

159
            p = head;
160

161
            while (p.down != null) {
162
                p = p.down;
163
            }
164

165
            i = 0;
166
            while (p != null) {
167
                p.pos = i++;
168
                p = p.right;
169
            }
170

171
            p = head;
172
            while (p != null) {
173
                s = getOneRow(p);
174
                System.out.println(s);
175

176
                p = p.down;
177
            }
178
        }
179

180
        //用了打印测试
181
        public String getOneRow(SkipListEntry p) {
182
            String s;
183
            int a, b, i;
184

185
            a = 0;
186

187
            s = "" + p.key;
188
            p = p.right;
189

190
            while (p != null) {
191
                SkipListEntry q;
192

193
                q = p;
194
                while (q.down != null)
195
                    q = q.down;
196
                b = q.pos;
197

198
                s = s + " <-";
199

200
                for (i = a + 1; i < b; i++)
201
                    s = s + "--------";
202

203
                s = s + "> " + p.key;
204

205
                a = b;
206

207
                p = p.right;
208
            }
209

210
            return (s);
211
        }
212

213
        //用了打印测试
214
        public void printVertical() {
215
            String s = "";
216
            SkipListEntry p;
217
            p = head;
218
            while (p.down != null)
219
                p = p.down;
220

221
            while (p != null) {
222
                s = getOneColumn(p);
223
                System.out.println(s);
224

225
                p = p.right;
226
            }
227
        }
228
        //用了打印测试
229
        public String getOneColumn(SkipListEntry p) {
230
            String s = "";
231
            while (p != null) {
232
                s = s + " " + p.key;
233
                p = p.up;
234
            }
235
            return (s);
236
        }
237
    }

测试类，Test.java
01
    package skiplist;
02

03
    public class Test1 {
04
        public static void main(String[] args) {
05
            SkipList S = new SkipList();
06

07
            S.printHorizontal();
08
            System.out.println("------");
09
            // S.printVertical();
10
            // System.out.println("======");
11

12
            S.put("ABC", 123);
13
            S.printHorizontal();
14
            System.out.println("------");
15
            // S.printVertical();
16
             //System.out.println("======");
17

18
            S.put("DEF", 123);
19
            S.printHorizontal();
20
            System.out.println("------");
21
            // S.printVertical();
22
            // System.out.println("======");
23

24
            S.put("KLM", 123);
25
            S.printHorizontal();
26
            System.out.println("------");
27
            // S.printVertical();
28
            // System.out.println("======");
29

30
            S.put("HIJ", 123);
31
            S.printHorizontal();
32
            System.out.println("------");
33
            // S.printVertical();
34
            // System.out.println("======");
35

36
            S.put("GHJ", 123);
37
            S.printHorizontal();
38
            System.out.println("------");
39
            // S.printVertical();
40
            // System.out.println("======");
41

42
            S.put("AAA", 123);
43
            S.printHorizontal();
44
            System.out.println("------");
45
            // S.printVertical();
46
            // System.out.println("======");
47

48
        }
49
    }

输出结果：
01
    -oo <-> +oo
02
    ------
03
    -oo <-> ABC <-> +oo
04
    -oo <-> ABC <-> +oo
05
    ------
06
    -oo <-> ABC <---------> +oo
07
    -oo <-> ABC <-> DEF <-> +oo
08
    ------
09
    -oo <-> ABC <---------> KLM <-> +oo
10
    -oo <-> ABC <-> DEF <-> KLM <-> +oo
11
    ------
12
    -oo <-----------------> HIJ <---------> +oo
13
    -oo <-> ABC <---------> HIJ <-> KLM <-> +oo
14
    -oo <-> ABC <-> DEF <-> HIJ <-> KLM <-> +oo
15
    ------
16
    -oo <-------------------------> HIJ <---------> +oo
17
    -oo <-> ABC <-----------------> HIJ <-> KLM <-> +oo
18
    -oo <-> ABC <-> DEF <-> GHJ <-> HIJ <-> KLM <-> +oo
19
    ------
20
    -oo <---------------------------------> HIJ <---------> +oo
21
    -oo <---------> ABC <-----------------> HIJ <-> KLM <-> +oo
22
    -oo <-> AAA <-> ABC <-> DEF <-> GHJ <-> HIJ <-> KLM <-> +oo
23
    ------

每次运行的结果是不一样的，这就是为什么说跳跃表是属于随机化数据结构。

代码参考：Implementing the skip list data structure