跳表的原理及其实现

╰+攻爆jí腚メ 2022-06-08 13:25 286阅读 0赞

作用/目的  
  
跳表作为一种数据结构通常用于取代平衡树。  
  
起因  
  
平衡树可以用于表示抽象的数据类型如字典和有序链表，它通过树旋转（Tree Rotation）操作强制使树结构保持平衡来保证节点搜索的效率。在数据为随机插入的情况下，平衡树性能表现良好；但数据为顺序插入或者需要删除节点的情况下，平衡树的性能就会有些糟糕。  
  
跳表可以作为平衡树的一种替代选择。它使用随机的平衡策略取代平衡树严格的强制的树平衡策略。因此它具有更简单有效的插入/删除方法以及更快的搜索速度。  
  
原理  
  
假设有一个链表，我们要查找某个节点，则我们需要逐个的查找链表的每个节点

![SouthEast][]  
如果链表是有序的，并且每隔一个节点都有一个指向其前面2个位置节点的指针，那我们只需要最多查找⌈N/2⌉个节点（N为链表长度）  
![SouthEast 1][]  
如果再每隔3个节点就有指向其前面4个位置节点的指针，那么我们就只需要查找不超过⌈N/4⌉+2个节点  
![SouthEast 2][]  
也即如果每个(2^i)位置的节点都有指向其前面2^i个位置节点的指针，则查找某个节点的次数可以下降到⌈log2^n⌉次（只是指针数会变为之前的双倍）  
![SouthEast 3][]  
这种数据结构可以用于快速的查找，只是插入和删除不太容易实现。  
  
*如果不再依照节点的位置，而是采取一种随机的策略来决定节点是否具有额外的指向前面节点的指针呢？*  
  
假设拥有k个前向指针的节点我们称之为k等级节点，在节点被分配出来的时候，我们通过随机策略（按照一定的概率）来决定节点的等级（也即有几个前向指针），节点的第i个指针也不再指向其前面2^i个位置的节点，而是指向等级i的下个节点。这样，插入和删除节点都只需要做很少的改动，其整体的效果却和上面所描述的类似。  
![SouthEast 4][]

由于这种数据结构是一个链表带有额外的指针，在链表的节点间跳跃，因此，原作者称其为*跳跃链表（skip lists）*。  
  
实现/算法  
  
节点等级  
  
随机生成节点等级的算法有很多种，这里介绍原作者采用的算法：

1.  首先确定一个概率p（1/2、1/4等），用于确定节点是否需要有下一个等级。
2.  就跟投骰子一样，节点有1/2或1/4的概率获得下一个等级，如果是，则节点的等级k=k+1，如果不是，则节点的等级为k，至此结束。
3.  如此重复循环。

但这里会有一个问题，某些节点的等级k可能会很大（一直获得下一个等级，虽然概率极低），这在算法的原理上没有问题（除了有极少的性能损耗），但在工程的实现上会相当麻烦，因此，在实际的实现当中，通常会设置一个最高等级（MAX\_LEVEL），并且还会有一个当前链表最大等级，搜索的时候从当前最大等级开始。  
  
关于p和MAX\_LEVEL取值，原作者推荐的p值是1/4或1/2，MAX\_LEVEL可根据所选的p及链表所含的最多元素个数n通过公式logp^n所得。  
  
初始化  
  
初始化的时候，我们会分配一个NIL节点（最终节点）并将其key值设为最大int值，还会分配一个链表初始节点，其header拥有MAX\_LEVEL个前向指针，所有的前向指针都初始化成指向NIL节点（表明链表中暂无节点）。

搜索算法  
  
通常，我们从当前链表的最大等级的header开始搜索，如果同一等级节点的key值小于搜索值，则搜索相同等级的后续节点，否则，进入到下一个等级节点继续搜索。直到搜索到相应的值或已到最低等级而后续节点的值又大于当前搜索值（表明搜索已失败）为止。  
  
插入/删除  
  
插入和删除节点只需要在搜索的基础上再进行简单的插入和删除操作，只是需要注意两个操作当中前向指针关系的处理，以及增加和减少链表等级后及时更新当前最大等级的值。插入的过程可见如下示意图：  
![SouthEast 5][]

C实现代码：

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

1.  \#include <stdio.h>  
2.  \#include <stdlib.h>  
3.  \#include <time.h>  
4.    
5.  \#define MAX\_NUM\_OF\_LEVEL 16  
6.  \#define MAX\_LEVEL (MAX\_NUM\_OF\_LEVEL-1)  
7.  \#define MAX\_INT 0x7fffffff /\* max integer \*/  
8.  \#define MAX\_BITS 32 /\* 32-bit integers \*/  
9.    
10. typedef struct \_NODE \{  
11.     int key;  
12.     int value;  
13.     struct \_NODE \*\*forward; /\* variable sized array of forward pointers \*/  
14. \} NODE;  
15.   
16. typedef struct \_SKIPLIST \{  
17.    int level;       /\* maximum level of the list \*/  
18.    struct \_NODE \*header; /\* pointer to header \*/  
19. \} SKIPLIST;  
20.   
21. NODE \*NIL;  
22. int RANDOM\_BITS;  
23. int BITS\_LEFT;  
24.   
25. int random()  
26. \{  
27.     srand(time(NULL));  
28.     return rand();  
29. \}  
30.   
31. NODE \*alloc\_node\_of\_level(int level)  
32. \{  
33.     NODE \*new\_node;  
34.     new\_node = (NODE \*)malloc(sizeof(NODE)+(level\*sizeof(struct \_NODE \*)));  
35.     return new\_node;  
36. \}  
37.   
38. init()  
39. \{  
40.     NIL = alloc\_node\_of\_level(0);  
41.     NIL->key = MAX\_INT;  
42.     RANDOM\_BITS = random();  
43.     BITS\_LEFT = MAX\_BITS;  
44. \}  
45.   
46. int random\_level()  
47. \{  
48.     int level = 0;  
49.     int b;  
50.       
51.     do \{  
52.         b = RANDOM\_BITS&3; /\* p=1/4(25%) \*/  
53.         if (!b)   
54.             level++;  
55.         RANDOM\_BITS >>= 2;  
56.         BITS\_LEFT -= 2;  
57.         if (BITS\_LEFT == 0) \{ /\* re-generate random bits \*/  
58.             RANDOM\_BITS = random();  
59.             BITS\_LEFT = MAX\_BITS;  
60.         \}  
61.     \} while (!b);  
62.       
63.     return (level > MAX\_LEVEL ? MAX\_LEVEL : level);  
64. \}  
65.       
66. SKIPLIST \*new\_list()  
67. \{  
68.     SKIPLIST \*l;  
69.     int i;  
70.       
71.     l = (SKIPLIST \*)malloc(sizeof(SKIPLIST));  
72.     l->level = 0;  
73.     l->header = alloc\_node\_of\_level(MAX\_LEVEL);  
74.     for (i = 0; i < MAX\_LEVEL; i++)  
75.         l->header->forward\[i\] = NIL;  
76.           
77.     return l;  
78. \}  
79.   
80. void free\_list(SKIPLIST \*l)  
81. \{  
82.     NODE \*p, \*q;  
83.     p = l->header;  
84.     while (p != NIL) \{  
85.         q = p->forward\[0\];  
86.         free(p);  
87.         p = q;  
88.     \}  
89.     free(l);  
90. \}  
91.   
92. int insert(SKIPLIST \*l, int key, int value)  
93. \{  
94.     int k;  
95.     NODE \*update\[MAX\_LEVEL\], \*p, \*q;  
96.       
97.     p = l->header;  
98.     k = l->level;  
99.       
100.     /\* search \*/  
101.     while (k >= 0) \{  
102.         while (q = p->forward\[k\], q->key < key) p = q;  
103.         update\[k\] = p;  
104.         k--;  
105.     \}  
106.       
107.     if (q->key == key) \{ /\* same key already exists \*/  
108.         q->value = value;  
109.         return 1;  
110.     \}  
111.       
112.     /\* insert new node \*/  
113.     k = random\_level();  
114.     if (k > l->level) \{  
115.         k = ++l->level;  
116.         update\[k\] = l->header;  
117.     \}  
118.     q = alloc\_node\_of\_level(k);  
119.     q->key = key;  
120.     q->value = value;  
121.     while (k >= 0) \{  
122.         p = update\[k\];  
123.         q->forward\[k\] = p->forward\[k\];  
124.         p->forward\[k\] = q;  
125.         k--;  
126.     \}  
127.       
128.     return 0;  
129. \}  
130.       
131. int delete(SKIPLIST \*l, int key)  
132. \{  
133.     int k, m;  
134.     NODE \*update\[MAX\_LEVEL\], \*p, \*q;  
135.       
136.     p = l->header;  
137.     k = m = l->level;  
138.       
139.     /\* search \*/  
140.     while (k >= 0) \{  
141.         while (q = p->forward\[k\], q->key < key) p = q;  
142.         update\[k\] = p;  
143.         k--;  
144.     \}  
145.       
146.     if (q->key != key) \{ /\* key not exists \*/  
147.         /\* NOT FOUND \*/  
148.         return 1;  
149.     \}  
150.       
151.     k = 0;  
152.     while (k <= m && (p = update\[k\])->forward\[k\] == q) \{  
153.         p->forward\[k\] = q->forward\[k\];  
154.         k++;  
155.     \}  
156.     free(q);  
157.       
158.     while (l->header->forward\[m\] == NIL && m > 0)  
159.         m--;  
160.     l->level = m;  
161.       
162.     return 0;  
163. \}  
164.   
165. int search(SKIPLIST \*l, int key, int &value)  
166. \{  
167.     int k;  
168.     NODE \*p, \*q;  
169.       
170.     p = l->header;  
171.     k = l->level;  
172.       
173.     /\* search \*/  
174.     while (k >= 0) \{  
175.         while (q = p->forward\[k\], q->key < key) p = q;  
176.         k--;  
177.     \}  
178.       
179.     if (q->key != key) \{   
180.         /\* NOT FOUND \*/  
181.         return -1;  
182.     \}  
183.       
184.     \*value = value;  
185.     return 0;  
186. \}  
187.   
188. /\* TESTS \*/  
189. int main(int argc, char \*argv\[\])  
190. \{  
191.     SKIPLIST \*l;  
192.     int i, k;  
193.     int keys\[65536\];  
194.     int v;  
195.       
196.     init();  
197.       
198.     l = new\_list();  
199.       
200.     for (k = 0; k < 65536; k++) \{  
201.         keys\[k\] = random();  
202.         insert(l, keys\[k\], keys\[k\]);  
203.     \}  
204.       
205.     for (i = 0; i < 4; i++) \{  
206.         for(k = 0; k < 65536; k++) \{  
207.             if (!search(l, keys\[k\], &v))   
208.                 printf("error in search \#%d,\#%d\\n", i, k);  
209.                   
210.             if (v != keys\[k\])   
211.                 printf("search returned wrong value\\n");  
212.         \}  
213.           
214.         for(k = 0; k < 65536; k++) \{  
215.             if (!delete(l, keys\[k\]))   
216.                 printf("error in delete\\n");  
217.             keys\[k\] = random();  
218.             insert(l, keys\[k\], keys\[k\]);  
219.         \}  
220.     \}  
221.   
222.     free\_list(l);  
223.     return 0;  
224. \}

[SouthEast]: /images/20220608/3ad66792db5240bf9e2569eb95e920a6.png
[SouthEast 1]: /images/20220608/11bd2a4678a048e4ac9e0ec8bbd587a3.png
[SouthEast 2]: /images/20220608/95279d90843d4c7fae7482841c5d38e0.png
[SouthEast 3]: /images/20220608/2202bddfe7354a0ba56e2141d028d0df.png
[SouthEast 4]: /images/20220608/9fc452fd95cf47a8836793dd0b02a697.png
[SouthEast 5]: /images/20220608/2c82b61460bb4869a6908aafae734b35.png
[view plain]: http://blog.csdn.net/bluecll/article/details/37094991#