跳表的实现

跳表

1 概念

对于一个有n个元素的有序数组，用折半搜索法进行搜索所需要的时间为O（log n），而对一个有序链表进行搜索所需要的时间为O（n）。 

我们可以通过对有序链表上的全部或部分节点增加额外的指针，来提高搜索性能。 通常节点结构中有一组有层次的链，0级链是包含所有元素的有序链表，1级链表是0级链的一个子集。I级链所包含的元素是i-1级链的子集。这样的结构就是跳表。

增加了向前指针的链表叫作跳表。跳表不仅能提高搜索性能，同时也可以提高插入和删除操作的性能。它采用随机技术决定链表中哪些节点应增加向前指针以及在该节点中应增加多少个指针。

2 级的分配：

i-1级元素属于i级元素的概率为p； p通常取0.5

MaxLeve最大值：log_1/p(N) - 1;  N是元素个数

CutOff=p*RAND_MAX； 

Int lev=0;

While(rand()<=CutOff) lev++; 

如：

template<class E, class K>

Int SkipList<E,K>::Level()

{ //产生一个随机级号，该级号<=MaxLevel

 Int lev=0;

 While(rand()<=CutOff) lev++;

 Return (lev <= MaxLevel)?lev:MaxLevel;

 }

或如下：

  long newLevel = 0;

  while ( (newLevel < maxLevel - 1) && (drand48() < probability) ) {

    newLevel++;

  }

3 复杂性分析

跳表中有n个元素时，搜索，插入，删除操作的平均复杂性为O(log n).

1. /*
2.  * File :skiplist.h
3.  * Interface for SkipList and SkipListElement
4.  * Author: cxf
5.  * Version: 1.0
6.  * Date: 02/08/2008
7.  * History:
8.    02/08/2008; cxf; Version 1.0
9.  */
11. #ifndef _SKIPLIST_H_
12. #define _SKIPLIST_H_
14. #define MAXLEVEL 6 //节点中的最大级
15. #define SKIPLIST_NOT_FOUND -1 //在跳表中没有找到相应的节点时，返回的值
16. typedef int Key;   //键的类型
17. typedef int Value; //值的类型
19. /* 跳表节点 */
20. class SkipListElement
21. {
22. public:
23.     SkipListElement(int _level = 0, Key _key = 0, Value _value = 0);
24.     ~SkipListElement();
25.     void SetValue(Value _value);
26.     Value GetValue() const;
27.     void SetKey(Key _key);
28.     Key GetKey() const;
29.     void SetLevel(int _level);
30.     int GetLevel() const;
31.     void SetElement(int _level, SkipListElement *_next);
32.     SkipListElement* GetElement(int _level) const;
33. private:
34.     Key key; //键
35.     Value value; //值
36.     int level;  //本节点的最大级，共有level + 1级，从0到level
37.     SkipListElement **next;
38. };
40. /* 跳表类 */
41. class SkipList
42. {
43. public:
44.     SkipList(SkipListElement *_head = NULL);
45.     ~SkipList();
46.     void Insert(const Key _key, const Value _value);
47.     Value Search(const Key _key);
48.     void Free(Key _key);
49.     friend std::ostream& operator<<(std::ostream out, const SkipList &slist);
50. private:
51.     int GetNewLevel();
52.     SkipListElement *head; //跳表的头节点
53. };
55. #endif
57. /*
58.  * File :skiplist.cpp
59.  * Implemention for SkipList and SkipListElement
60.  * Author: cxf
61.  * Version: 1.0
62.  * Date: 02/08/2008
63.  * History:
64.  * 02/08/2008; cxf; Version 1.0
65.  */
67. #include <cassert> //assert
68. #include <climits> //INT_MAX
69. #include <iostream> 
70. #include <ctime>   //time
71. #include "skiplist.h"
73. using namespace std;
75. SkipListElement::SkipListElement(int _level /* = 0 */, Key _key /* = 0 */, /
76.                                  Key _value /* = 0 */)
77. {
78.     level = _level;
79.     key = _key;
80.     value = _value;
81.     //动态分配指针数组空间
82.     next = (SkipListElement**)malloc(sizeof(SkipListElement*) * (level + 1));
83.     if (NULL == next)
84.     {
85.         cout << __FILE__ << ":" << __LINE__ << " " << "no enough memory!" << endl;
86.         exit(-1);
87.     }
88.     for (int i = 0; i <= level; i++)
89.     {
90.         next[i] = NULL;
91.     }
92. }
94. SkipListElement::~SkipListElement()
95. {
96.     free(next);
97. }
99. void SkipListElement::SetKey(Key _key)
100. {
101.     key = _key;
102. }
104. void SkipListElement::SetValue(Value _value)
105. {
106.     value = _value;
107. }
109. void SkipListElement::SetElement(int _level, SkipListElement *_next)
110. {   
111.     assert(_level >= 0 && _level <= level);
112.     next[_level] = _next;
113. }
115. SkipListElement* SkipListElement::GetElement(int _level) const
116. {
117.     assert(_level >= 0 && _level <= level);
118.     return next[_level];
119. }
121. Key SkipListElement::GetKey() const
122. {
123.     return key;
124. }
126. Value SkipListElement::GetValue() const
127. {
128.     return value;
129. }
131. int  SkipListElement::GetLevel() const
132. {
133.     return level;
134. }
136. /* 若级别比当前的高，需要重新分配空间，否则，不必释放空间，留作以后用*/
137. void SkipListElement::SetLevel(int _level)
138. {
139.     if (_level > level)
140.     {
141.         //重新分配空间
142.         next = (SkipListElement**)realloc(next, (_level + 1) * sizeof(void *)); 
143.         if (NULL == next)
144.         {
145.             cout << __FILE__ << ":" << __LINE__ << " " << "no enough memory!" << endl;
146.             exit(-1);
147.         }
148.         //初始化增加的空间
149.         memset(next + (level + 1), 0, sizeof(void *) * (_level - level));
150.     }
151.     level = _level;
152. }
154. /*===========================以下为SkipList部分===================================*/
156. SkipList::SkipList(SkipListElement *_head /* = NULL */)
157. {
158.     if (NULL == _head)
159.     {
160.         head = new SkipListElement();
161.         //头节点的key设置为无限大
162.         head->SetKey(INT_MAX);
163.     }
164.     else
165.     {
166.         head = _head;
167.     }
168. }
170. SkipList::~SkipList()
171. {
172.     SkipListElement *element = head;
173.     //从级0开始，依次删除所有的节点
174.     while (element != NULL)
175.     {
176.         SkipListElement *temp = element->GetElement(0);
177.         delete element;
178.         element = temp;
179.     }
180. }
181. /* 随机产生一个级，为产生的新节点用 */
182. int SkipList::GetNewLevel()
183. {
184.     static int i = 0;
185.     /* 因为插入新节点的时间间隔几乎为零，为产生不同的随机数，加入静态变量
186.      * 以使每次该函数被调用时种子不同
187.      */
188.     srand(time(0) + i); 
189.     i += 20;
190.     return rand() % MAXLEVEL + 1;
191. }
193. /* 将键为_key,值为_value的节点插入到跳表中
194.  * 算法思想：可将跳表看做是一系列普通的链表，在跳表中插入节点，就是寻找插
195.  * 入节点在每一级中的插入位置(并保存), 然后根据插入节点的级n，在0-n级的n+1
196.  * 条普通链表中依次插入节点
197.  */
198. void SkipList::Insert(const Key _key, const Value _value)
199. {
200.     SkipListElement *elemnet = head;
201.     SkipListElement *next = NULL;
202.     SkipListElement  update(MAXLEVEL);//保存每一级插入位置
203.     int newLevel = 0; //新节点的所分配的级
204.     int i = 0;
205.     //从头节点开始扫描所有级
206.     for (i = head->GetLevel(); i >= 0; i--)
207.     {
208.         next = elemnet->GetElement(i);
209.         while (next != NULL && _key > next->GetKey())
210.         {
211.             elemnet = next;
212.             next = elemnet->GetElement(i);
213.         }
214.         //保存每一级指针
215.         update.SetElement(i, elemnet);
216.     }
217.     elemnet = elemnet->GetElement(0);
218.     //若键为_key的节点存在跳表中，更新其值
219.     if ((elemnet != NULL) && (_key == elemnet->GetKey()))
220.     {
221.         elemnet->SetValue(_value);
222.     }
223.     //不存在键为_key的节点
224.     else
225.     {
226.         //产生一个级
227.         newLevel = GetNewLevel();
228.         //若新节点的级比头节点的级大，更新头节点的级
229.         if (newLevel > head->GetLevel())
230.         {
231.             for (int i = head->GetLevel() + 1; i <= newLevel; i++)
232.             {
233.                 update.SetElement(i, head);
234.             }
235.             head->SetLevel(newLevel);
236.         }
237.         //构造新的节点
238.         elemnet = new SkipListElement(newLevel, _key, _value);
239.         //调整新节点每一级的指针，以及该节点前后的指针关系
240.         for (i = 0; i <= newLevel; i++)
241.         {
242.             elemnet->SetElement(i, update.GetElement(i)->GetElement(i));
243.             update.GetElement(i)->SetElement(i, elemnet);
244.         }
245.     }
246. }
248. /* 从跳表中寻找键为_key的节点的值 */
249. Value SkipList::Search(const Key _key)
250. {
251.     SkipListElement *elemnet = head;
252.     SkipListElement *next = NULL;
253.     for (int i = head->GetLevel(); i >= 0; i--)
254.     {
255.         next = elemnet->GetElement(i);
256.         while ((next != NULL) && (_key > next->GetKey()))
257.         {
258.             elemnet = next;
259.             next = elemnet->GetElement(i);
260.         }
261.         //存在要找的节点,停止搜索并立即返回
262.         if ((next != NULL) && (_key == next->GetKey()))
263.         {
264.             return next->GetValue();
265.         }
266.     }
267.     //不存在要找的节点
268.     return SKIPLIST_NOT_FOUND;
269. }
271. /* 从跳表中删除键值为_key的节点 */
272. void SkipList::Free(Key _key)
273. {
274.     SkipListElement *element = head;
275.     SkipListElement *next = NULL;
276.     SkipListElement temp(MAXLEVEL); //保存欲删除节点前后的指针关系
277.     int i = 0;
278.     //从头节点开始扫描所有级
279.     for (i = head->GetLevel(); i >= 0; i--)
280.     {
281.         next = element->GetElement(i);
282.         //若_key > next->GetKey()，则转入下一个节点扫描剩下的级
283.         while ((next != NULL) && (_key > next->GetKey()))
284.         {
285.             element = next;
286.             next = next->GetElement(i);
287.         }
288.         //temp保存每一级中，欲删除节点的前一个节点指针
289.         temp.SetElement(i, element);
290.     }
291.     element = element->GetElement(0);
292.     //找到节点
293.     if (element != NULL && element->GetKey() == _key)
294.     {
295.         for (i = 0; i <= element->GetLevel(); i++)
296.         {
297.             //修改节点间的指针关系
298.             temp.GetElement(i)->SetElement(i, element->GetElement(i));
299.         }
300.         //删除本节点
301.         delete element;
302.         //修改头节点的级，若头节点中某一级的指针为空，则减一级
303.         while ((head->GetLevel() > 0) && (head->GetElement(head->GetLevel()) == NULL))
304.         {
305.             head->SetLevel(head->GetLevel() - 1);
306.         }
307.     }
308. }
310. /*  输出跳表，形式如下：每一行第一个是头节点（键是一个很大的数值）
311.     2147483647-->10-->NULL
312.     2147483647-->10-->20-->NULL
313.     2147483647-->10-->15-->20-->30-->NULL
314.     2147483647-->10-->15-->20-->25-->30-->NULL
315.     2147483647-->10-->15-->20-->25-->30-->NULL
316. */
317. ostream& operator<<(ostream out, const SkipList &slist)
318. {
319.     SkipListElement *element = slist.head;      
320.     for (int i = slist.head->GetLevel(); i > 0; i--)
321.     {
322.         element = slist.head;
323.         while (element != NULL)
324.         {
325.             cout << element->GetKey() << "-->";
326.             element = element->GetElement(i);
327.         }
328.         cout << "NULL" << endl;
329.     }
330.     return out;
331. }