碼上快樂

相關內容    簡體    繁體

Skip List（跳躍表）原理詳解與實現【轉】

本文轉載自   查看原文   2018-01-23 10:56   2610    【linux內核】/ 【嵌入式基礎】

轉自：http://dsqiu.iteye.com/blog/1705530

Skip List（跳躍表）原理詳解與實現

 

本文內容框架：

§1 Skip List 介紹

§2 Skip List 定義以及構造步驟

  §3 Skip List 完整實現

 

§4 Skip List 概率分析

§5 小結

 

 

 

§1 Skip List 介紹

 

Skip List是一種隨機化的數據結構，基於並聯的鏈表，其效率可比擬於二叉查找樹（對於大多數操作需要O(log n)平均時間）。基本上，跳躍列表是對有序的鏈表增加上附加的前進鏈接，增加是以隨機化的方式進行的，所以在列表中的查找可以快速的跳過部分列表(因此得名)。所有操作都以對數隨機化的時間進行。Skip List可以很好解決有序鏈表查找特定值的困難。

 

 

§2 Skip List 定義以及構造步驟

 

Skip List定義

像下面這樣（初中物理經常這樣用，這里我也盜用下）：

一個跳表，應該具有以下特征：

  1. 一個跳表應該有幾個層（level）組成；
  2. 跳表的第一層包含所有的元素；
  3. 每一層都是一個有序的鏈表；
  4. 如果元素x出現在第i層，則所有比i小的層都包含x；
  5. 第i層的元素通過一個down指針指向下一層擁有相同值的元素；
  6. 在每一層中，-1和1兩個元素都出現(分別表示INT_MIN和INT_MAX)；
  7. Top指針指向最高層的第一個元素。

構建有序鏈表

link list

的一個跳躍表如下：

 

Skip List構造步驟：

       1、給定一個有序的鏈表。

2、選擇連表中最大和最小的元素，然后從其他元素中按照一定算法（隨機）隨即選出一些元素，將這些元素組成有序鏈表。這個新的鏈表稱為一層，原鏈表稱為其下一層。
3、為剛選出的每個元素添加一個指針域，這個指針指向下一層中值同自己相等的元素。Top指針指向該層首元素
4、重復2、3步，直到不再能選擇出除最大最小元素以外的元素。

 

 

§3 Skip List 完整實現

 

下面來定義跳表的數據結構（基於C）

首先是每個節點的數據結構

C代碼   收藏代碼
  1. typedef  struct nodeStructure  
  2. {  
  3.   
  4.     int key;  
  5.   
  6.     int value;  
  7.   
  8.     struct nodeStructure *forward[1];  
  9. }nodeStructure;  
 

跳表的結構如下

C代碼   收藏代碼
  1. typedef  struct skiplist  
  2. {  
  3.   
  4.     int level;  
  5.   
  6.     nodeStructure *header;  
  7. }skiplist;  

下面是跳表的基本操作

首先是節點的創建

C代碼   收藏代碼
  1. nodeStructure* createNode(int level,int key,int value)  
  2. {  
  3.   
  4.     nodeStructure *ns=(nodeStructure *)malloc(sizeof(nodeStructure)+level*sizeof(nodeStructure*));    
  5.   
  6.     ns->key=key;    
  7.   
  8.     ns->value=value;    
  9.   
  10.     return ns;    
  11. }  
 

列表的初始化

列表的初始化需要初始化頭部，並使頭部每層（根據事先定義的MAX_LEVEL）指向末尾（NULL）。

C代碼   收藏代碼
  1. skiplist* createSkiplist()  
  2. {  
  3.   
  4.     skiplist *sl=(skiplist *)malloc(sizeof(skiplist));    
  5.   
  6.     sl->level=0;    
  7.   
  8.     sl->header=createNode(MAX_LEVEL-1,0,0);    
  9.   
  10.     for(int i=0;i<MAX_LEVEL;i++)    
  11.   
  12.     {    
  13.   
  14.         sl->header->forward[i]=NULL;    
  15.   
  16.     }  
  17.   
  18.     return sl;  
  19. }  

插入元素

插入元素的時候元素所占有的層數完全是隨機的，通過隨機算法產生

 

C代碼   收藏代碼
  1. int randomLevel()    
  2. {  
  3.   
  4.     int k=1;  
  5.   
  6.     while (rand()%2)    
  7.   
  8.         k++;    
  9.   
  10.     k=(k<MAX_LEVEL)?k:MAX_LEVEL;  
  11.   
  12.     return k;    
  13. }  

 

 

 

跳表的插入需要三個步驟，第一步需要查找到在每層待插入位置，然后需要隨機產生一個層數，最后就是從高層至下插入，插入時算法和普通鏈表的插入完全相同。

跳表,Skip List

 

C代碼   收藏代碼
  1. bool insert(skiplist *sl,int key,int value)  
  2. {  
  3.   
  4.     nodeStructure *update[MAX_LEVEL];  
  5.   
  6.     nodeStructure *p, *q = NULL;  
  7.   
  8.     p=sl->header;  
  9.   
  10.     int k=sl->level;  
  11.   
  12.     //從最高層往下查找需要插入的位置  
  13.   
  14.     //填充update  
  15.   
  16.     for(int i=k-1; i >= 0; i--){  
  17.   
  18.         while((q=p->forward[i])&&(q->key<key))  
  19.   
  20.         {  
  21.   
  22.             p=q;  
  23.   
  24.         }  
  25.   
  26.         update[i]=p;  
  27.   
  28.     }  
  29.   
  30.     //不能插入相同的key  
  31.   
  32.     if(q&&q->key==key)  
  33.   
  34.     {  
  35.   
  36.         return false;  
  37.   
  38.     }  
  39.   
  40.     
  41.   
  42.     //產生一個隨機層數K  
  43.   
  44.     //新建一個待插入節點q  
  45.   
  46.     //一層一層插入  
  47.   
  48.     k=randomLevel();  
  49.   
  50.     //更新跳表的level  
  51.   
  52.     if(k>(sl->level))  
  53.   
  54.     {  
  55.   
  56.         for(int i=sl->level; i < k; i++){  
  57.   
  58.             update[i] = sl->header;  
  59.   
  60.         }  
  61.   
  62.         sl->level=k;  
  63.   
  64.     }  
  65.   
  66.     
  67.   
  68.     q=createNode(k,key,value);  
  69.   
  70.     //逐層更新節點的指針，和普通列表插入一樣  
  71.   
  72.     for(int i=0;i<k;i++)  
  73.   
  74.     {  
  75.   
  76.         q->forward[i]=update[i]->forward[i];  
  77.   
  78.         update[i]->forward[i]=q;  
  79.   
  80.     }  
  81.   
  82.     return true;  
  83. }  

 

 

 紅色區域為輔助數組update的內容

 

刪除節點

刪除節點操作和插入差不多，找到每層需要刪除的位置，刪除時和操作普通鏈表完全一樣。不過需要注意的是，如果該節點的level是最大的，則需要更新跳表的level。

 

C代碼   收藏代碼
  1. bool deleteSL(skiplist *sl,int key)  
  2. {  
  3.   
  4.     nodeStructure *update[MAX_LEVEL];  
  5.   
  6.     nodeStructure *p,*q=NULL;  
  7.   
  8.     p=sl->header;  
  9.   
  10.     //從最高層開始搜  
  11.   
  12.     int k=sl->level;  
  13.   
  14.     for(int i=k-1; i >= 0; i--){  
  15.   
  16.         while((q=p->forward[i])&&(q->key<key))  
  17.   
  18.         {  
  19.   
  20.             p=q;  
  21.   
  22.         }  
  23.   
  24.         update[i]=p;  
  25.   
  26.     }  
  27.   
  28.     if(q&&q->key==key)  
  29.   
  30.     {  
  31.   
  32.         //逐層刪除，和普通列表刪除一樣  
  33.   
  34.         for(int i=0; i<sl->level; i++){    
  35.   
  36.             if(update[i]->forward[i]==q){    
  37.   
  38.                 update[i]->forward[i]=q->forward[i];    
  39.   
  40.             }  
  41.   
  42.         }   
  43.   
  44.         free(q);  
  45.   
  46.         //如果刪除的是最大層的節點，那么需要重新維護跳表的  
  47.   
  48.         for(int i=sl->level-1; i >= 0; i--){    
  49.   
  50.             if(sl->header->forward[i]==NULL){    
  51.   
  52.                 sl->level--;    
  53.   
  54.             }    
  55.   
  56.         }    
  57.   
  58.         return true;  
  59.   
  60.     }  
  61.   
  62.     else  
  63.   
  64.         return false;  
  65. }  

 

 

 

查找

跳表的優點就是查找比普通鏈表快，當然查找操作已經包含在在插入和刪除過程，實現起來比較簡單。

跳表,Skip List

 搜索key=14的示意圖

 

 

C代碼   收藏代碼
  1. int search(skiplist *sl,int key)  
  2. {  
  3.   
  4.     nodeStructure *p,*q=NULL;  
  5.   
  6.     p=sl->header;  
  7.   
  8.     //從最高層開始搜  
  9.   
  10.     int k=sl->level;  
  11.   
  12.     for(int i=k-1; i >= 0; i--){  
  13.   
  14.         while((q=p->forward[i])&&(q->key<=key))  
  15.   
  16.         {  
  17.   
  18.             if(q->key==key)  
  19.   
  20.             {  
  21.   
  22.                 return q->value;  
  23.   
  24.             }  
  25.   
  26.             p=q;  
  27.   
  28.         }  
  29.   
  30.     }  
  31.   
  32.     return NULL;  
  33. }  

 

 

完整代碼如下：

 

C代碼   收藏代碼
  1. #include<stdio.h>  
  2. #include<stdlib.h>  
  3.     
  4. #define MAX_LEVEL 10 //最大層數  
  5.     
  6. //節點  
  7. typedef  struct nodeStructure  
  8. {  
  9.     int key;  
  10.     int value;  
  11.     struct nodeStructure *forward[1];  
  12. }nodeStructure;  
  13.     
  14. //跳表  
  15. typedef  struct skiplist  
  16. {  
  17.     int level;  
  18.     nodeStructure *header;  
  19. }skiplist;  
  20.     
  21. //創建節點  
  22. nodeStructure* createNode(int level,int key,int value)  
  23. {  
  24.     nodeStructure *ns=(nodeStructure *)malloc(sizeof(nodeStructure)+level*sizeof(nodeStructure*));    
  25.     ns->key=key;    
  26.     ns->value=value;    
  27.     return ns;    
  28. }  
  29.     
  30. //初始化跳表  
  31. skiplist* createSkiplist()  
  32. {  
  33.     skiplist *sl=(skiplist *)malloc(sizeof(skiplist));    
  34.     sl->level=0;    
  35.     sl->header=createNode(MAX_LEVEL-1,0,0);    
  36.     for(int i=0;i<MAX_LEVEL;i++)    
  37.     {    
  38.         sl->header->forward[i]=NULL;    
  39.     }  
  40.     return sl;  
  41. }  
  42.     
  43. //隨機產生層數  
  44. int randomLevel()    
  45. {  
  46.     int k=1;  
  47.     while (rand()%2)    
  48.         k++;    
  49.     k=(k<MAX_LEVEL)?k:MAX_LEVEL;  
  50.     return k;    
  51. }  
  52.     
  53. //插入節點  
  54. bool insert(skiplist *sl,int key,int value)  
  55. {  
  56.     nodeStructure *update[MAX_LEVEL];  
  57.     nodeStructure *p, *q = NULL;  
  58.     p=sl->header;  
  59.     int k=sl->level;  
  60.     //從最高層往下查找需要插入的位置  
  61.     //填充update  
  62.     for(int i=k-1; i >= 0; i--){  
  63.         while((q=p->forward[i])&&(q->key<key))  
  64.         {  
  65.             p=q;  
  66.         }  
  67.         update[i]=p;  
  68.     }  
  69.     //不能插入相同的key  
  70.     if(q&&q->key==key)  
  71.     {  
  72.         return false;  
  73.     }  
  74.     
  75.     //產生一個隨機層數K  
  76.     //新建一個待插入節點q  
  77.     //一層一層插入  
  78.     k=randomLevel();  
  79.     //更新跳表的level  
  80.     if(k>(sl->level))  
  81.     {  
  82.         for(int i=sl->level; i < k; i++){  
  83.             update[i] = sl->header;  
  84.         }  
  85.         sl->level=k;  
  86.     }  
  87.     
  88.     q=createNode(k,key,value);  
  89.     //逐層更新節點的指針，和普通列表插入一樣  
  90.     for(int i=0;i<k;i++)  
  91.     {  
  92.         q->forward[i]=update[i]->forward[i];  
  93.         update[i]->forward[i]=q;  
  94.     }  
  95.     return true;  
  96. }  
  97.     
  98. //搜索指定key的value  
  99. int search(skiplist *sl,int key)  
  100. {  
  101.     nodeStructure *p,*q=NULL;  
  102.     p=sl->header;  
  103.     //從最高層開始搜  
  104.     int k=sl->level;  
  105.     for(int i=k-1; i >= 0; i--){  
  106.         while((q=p->forward[i])&&(q->key<=key))  
  107.         {  
  108.             if(q->key == key)  
  109.             {  
  110.                 return q->value;  
  111.             }  
  112.             p=q;  
  113.         }  
  114.     }  
  115.     return NULL;  
  116. }  
  117.     
  118. //刪除指定的key  
  119. bool deleteSL(skiplist *sl,int key)  
  120. {  
  121.     nodeStructure *update[MAX_LEVEL];  
  122.     nodeStructure *p,*q=NULL;  
  123.     p=sl->header;  
  124.     //從最高層開始搜  
  125.     int k=sl->level;  
  126.     for(int i=k-1; i >= 0; i--){  
  127.         while((q=p->forward[i])&&(q->key<key))  
  128.         {  
  129.             p=q;  
  130.         }  
  131.         update[i]=p;  
  132.     }  
  133.     if(q&&q->key==key)  
  134.     {  
  135.         //逐層刪除，和普通列表刪除一樣  
  136.         for(int i=0; i<sl->level; i++){    
  137.             if(update[i]->forward[i]==q){    
  138.                 update[i]->forward[i]=q->forward[i];    
  139.             }  
  140.         }   
  141.         free(q);  
  142.         //如果刪除的是最大層的節點，那么需要重新維護跳表的  
  143.         for(int i=sl->level - 1; i >= 0; i--){    
  144.             if(sl->header->forward[i]==NULL){    
  145.                 sl->level--;    
  146.             }    
  147.         }    
  148.         return true;  
  149.     }  
  150.     else  
  151.         return false;  
  152. }  
  153.     
  154. void printSL(skiplist *sl)  
  155. {  
  156.     //從最高層開始打印  
  157.     nodeStructure *p,*q=NULL;  
  158.     
  159.     //從最高層開始搜  
  160.     int k=sl->level;  
  161.     for(int i=k-1; i >= 0; i--)  
  162.     {  
  163.         p=sl->header;  
  164.         while(q=p->forward[i])  
  165.         {  
  166.             printf("%d -> ",p->value);  
  167.             p=q;  
  168.         }  
  169.         printf("\n");  
  170.     }  
  171.     printf("\n");  
  172. }  
  173. int main()  
  174. {  
  175.     skiplist *sl=createSkiplist();  
  176.     for(int i=1;i<=19;i++)  
  177.     {  
  178.         insert(sl,i,i*2);  
  179.     }  
  180.     printSL(sl);  
  181.     //搜索  
  182.     int i=search(sl,4);  
  183.     printf("i=%d\n",i);  
  184.     //刪除  
  185.     bool b=deleteSL(sl,4);  
  186.     if(b)  
  187.         printf("刪除成功\n");  
  188.     printSL(sl);  
  189.     system("pause");  
  190.     return 0;  
  191. }  

 

§4 Skip List 概率分析

 




 

 

 

§5 小結

本篇博文已經詳細講解了Skip List數據結構的所有內容，應該可以有一個深入的了解。如果你有任何建議或者批評和補充，請留言指出，不勝感激，更多參考請移步互聯網。

 

參考：

①Skip List: http://www.cs.auckland.ac.nz/software/AlgAnim/niemann/s_skl.htm

②Songeliu: http://www.spongeliu.com/63.html

③Shi Kai Lun ： http://yilee.info/skip-list.html

④Michael T. Goodrich Roberto Tamassia Algorithm Design Foundations, Analysis, and Internet Examples

⑤http://epaperpress.com/sortsearch/skl.html


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 跳躍表原理和實現 用go實現常用算法與數據結構——跳躍表(Skip list) 數據結構與算法(c++)——跳躍表(skip list) 跳躍表-原理及Java實現 講講跳躍表（Skip Lists） 跳躍表原理 跳躍表原理與實踐 跳躍表 SkipList【數據結構】原理及實現 Redis 跳躍表實現 java實現跳躍表
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM