LevelDB 關鍵算法概述

原創 jeff_0825 2020-06-22 01:31
•LevelDB是Google開源的一套鍵值存儲引擎，它是受BigTable中SSTable的啓發，去除了SSTable中的一些庫依賴，完善了一些細節後修改而成，雖然沒在BigTable中使用，但數據的格式與組織方法與SSTable基本同出一轍，目前主要在Chrome中使用。
•LevelDB是典型的LSM-Tree的實現，支持range query。
•LevelDB採用Skip-List作爲內存索引，key與value可以爲任意二進制序列。
•LevelDB支持快照查詢。
•LevelDB支持前綴壓縮與塊壓縮。

LSM-Tree的實現

LSM-Tree的基本思想，再記錄下讀文章的幾點感受。

LSM思想非常樸素，就是將對數據的更改hold在內存中，達到指定的threadhold後將該批更改批量寫入到磁盤，在批量寫入的過程中跟已經存在的數據做rolling merge。

拿update舉個例子：

比如有1000萬行數據，現在希望update table.a set addr='new addr' where pk = '833'，

如果使用B-Tree類似的結構操作，就需要：

1. 找到該條記錄所在的page，

2. load page到內存（如果恰好該page已經在內存中，則省略該步）

3. 如果該page之前被修改過，則先flush page to disk

4. 修改數據

上面的動作平均來說有兩次disk I/O，

如果採用LSM-Tree類似結構，則：

1. 將需要修改的數據直接寫入內存

可見這裏是沒有disk I/O的。

當然，我們要說，這樣的話讀的時候就費勁了，需要merge disk上的數據和memory中的修改數據，這顯然降低了讀的性能。

確實如此，所以作者其中有個假設，就是寫入遠大於讀取的時候，LSM是個很好的選擇。我覺得更準確的描述應該是”優化了寫，沒有顯著降低讀“，因爲大部分時候我們都是要求讀最新的數據，而最新的數據很可能還在內存裏面，即使不在內存裏面，只要不是那些更新特別頻繁的數據，其I/O次數也是有限的。

所以LSM-Tree比較適合的應用場景是：insert數據量大，讀數據量和update數據量不高且讀一般針對最新數據。

文章讀下來有以下幾點感受：

1. 基本思想早就有了，作者給出了較好的表現形式。

2. Merge是page/block級別的，而不是BigTable中的文件級別的。這一點主要原因可能是BigTable在分佈式場景下做block級別很困那，而且GFS也不支持修改。

3. 其提出的比較標準比較有趣，將磁盤容量，轉速等結合起來給出一個以美元爲單位的cost標準，然後跟B-Tree結構的實現做了比較，結果當然是大大勝出。但是這裏我覺得作者有些比較是不合理的，比如LSM使用log而B-Tree沒有使用，這顯然對B-Tree不公，其實B-Tree如果使用log，寫入性能應該不比LSM差，順序讀取可能差一些。

4. 在Multi components 中，提出Ci/Ci+1的比例達到20的時候是最優的，這個數字意義不大，但是其中的分析方法對於Merge策略的選擇是個啓發。


http://blog.csdn.net/heiyeshuwu/article/details/8445396



Skip-List
http://blog.csdn.net/haidao2009/article/details/8206856

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是一種隨機化的數據結構，基於並聯的鏈表，其效率可比擬於二叉查找樹（對於大多數操作需要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 概率分析

 




 

 



發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

數據保護技巧揭祕：爲導出文件添加防護密碼的實用指南

一、前言 當涉及到敏感數據的導出和共享時，數據安全是至關重要的。在現代數字化時代，保護個人和機密信息免受未經授權的訪問和竊取是每個組織和個人的首要任務之一。在這種背景下，葡萄城的純前端表格控件 SpreadJS 提供的加密功能爲用戶提供了一

葡萄城技術團隊 2024-06-03 14:30:40

圖牀軟件Minio oss

docker run -p 9000:9000 -p 9001:9001 --name minio -d --restart=always -e "MINIO_ACCESS_KEY=admin" -e "MINIO_SECRET_KEY=a

hiningrise 2024-06-03 14:25:00

一個docker容器暴露多個端口

how to configure multiple domain (virtual host) and multiple virtual port # start the nginx proxy docker run -d -p 80:80

hiningrise 2024-06-03 14:25:00

微軟官方開源免費的Blazor UI組件庫 - Fluent UI Blazor

前言 今天大姚給大家分享一個由微軟官方開源（MIT License）、免費的Blazor UI組件庫：Fluent UI Blazor。 全面的ASP.NET Core Blazor簡介和快速入門 Fluent UI Blazor介紹

追逐時光 2024-06-03 14:22:00

再也不用爲找.NET相關的項目和框架發愁了

前言 最近經常在DotNetGuide技術社區交流羣裏看到有小夥伴問：有什麼好用的.NET定時任務調度框架推薦的？有什麼好的WPF/WinForm/Blazor圖表庫推薦的？.NET好用的後臺管理框架有推薦的嗎？大家平時都是怎麼找.NET

追逐時光 2024-06-03 14:22:00

leetcode 60 排列序列

排列序列 已解答 困難 相關標籤 相關企業 給出集合 [1,2,3,...,n]，其所有元素共有 n! 種排列。 按大小順序列出所有排列情況，並一一標記，當 n = 3 時, 所有排列如下： "123" "132" "213" "231

張博的博客 2024-06-03 14:19:49

k8S的kube-proxy相關ipvs

  ipvsadm命令 沒想到自己之前二進制部署的，也是ipvs代理模式 node2上沒有裝ipvs，也看不了一些ipvs規則  node1上安裝ipvsadm,然後就可以看的k8s添加的規則了 yum install ipvsadm

馬昌偉 2024-06-03 14:13:49

零基礎寫框架：從零設計一個模塊化和自動服務註冊框架

關於從零設計 .NET 開發框架 作者：癡者工良 教程說明： 倉庫地址：https://github.com/whuanle/maomi 文檔地址：https://maomi.whuanle.cn 作者博客： https://www.whu

癡者工良 2024-06-03 14:13:38

英語背單詞 專四詞彙 2024年06月 ChatGPT

2024-06-03 index word pronunciation parts of speech explanation translation in Chinese 1 fuss /fʌs/ noun/verb unnec

ChuckLu 2024-06-03 14:06:57

背單詞 首字母 2024年06月

2024-06-302024-06-292024-06-282024-06-272024-06-262024-06-252024-06-242024-06-232024-06-222024-06-212024-06-202024-06-19

ChuckLu 2024-06-03 14:06:57

初探富文本之基於虛擬滾動的大型文檔性能優化方案

初探富文本之基於虛擬滾動的大型文檔性能優化方案 虛擬滾動是一種優化長列表性能的技術，其通過按需渲染列表項來提高瀏覽器運行效率。具體來說，虛擬滾動只渲染用戶瀏覽器視口部分的文檔數據，而不是整個文檔結構，其核心實現根據可見區域高度和容器的滾動位

WindrunnerMax 2024-06-03 14:05:17

.Net 中間件 - 新開源代碼生成器 -ReZero

ReZero AP ReZero是一款.NET中間件 ： 一款通過界面操作就能生成API ,  可以集成到任何.NET6+ API項目,無破壞性，也可讓非.NET用戶使用exe文件 ReZero生成器功能簡介 1、表文檔導出：支持目錄導航

孫凱旋 2024-06-03 14:03:26

Microsoft.Extensions.DependencyInjection會自動釋放通過DI（依賴注入）創建的對象

Microsoft.Extensions.DependencyInjection中（下面簡稱DI），在調用ServiceProvider和IServiceScope對象的Dispose()方法時，也會自動調用ServiceProvider和

PowerCoder 2024-06-03 14:03:06

爲什麼以及如何要進行架構設計權衡？

對於“軟件架構”這個詞有很多定義和含義。而且，“軟件開發”、“軟件設計”和“軟件架構”這三個概念之間存在相當大的重疊，它們在許多方面相互交融。 從核心上看，可以將軟件架構視爲在構建應用程序時，對不同選擇進行權衡的學科。 1 爲什麼需要權衡以

路人111122233 2024-06-03 14:00:36

如何使用Node.js、TypeScript和Express實現RESTful API服務

Node.js是一個基於 Chrome V8 引擎的 JavaScript 運行環境。Node.js 使用了一個事件驅動、非阻塞式 I/O 的模型,使其輕量又高效。Express是一個保持最小規模的靈活的 Node.js Web應用程序開發

黃明基 2024-06-03 13:59:46