jeff_0825
jeff_0825

LevelDB 关键算法概述

•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
  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
  11.   
  12.     return k;    
  13. }  
 

 

跳表的插入需要三个步骤，第一步需要查找到在每层待插入位置，然后需要随机产生一个层数，最后就是从高层至下插入，插入时算法和普通链表的插入完全相同。

 

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
  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
  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
  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; ilevel; 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. }  
 

 

查找

跳表的优点就是查找比普通链表快，当然查找操作已经包含在在插入和删除过程，实现起来比较简单。

 搜索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  
  2. #include  
  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
  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
  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
  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
  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
  128.         {  
  129.             p=q;  
  130.         }  
  131.         update[i]=p;  
  132.     }  
  133.     if(q&&q->key==key)  
  134.     {  
  135.         //逐层删除，和普通列表删除一样  
  136.         for(int i=0; ilevel; 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
  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
  11.   
  12.     return k;    
  13. }  
 

 

跳表的插入需要三个步骤，第一步需要查找到在每层待插入位置，然后需要随机产生一个层数，最后就是从高层至下插入，插入时算法和普通链表的插入完全相同。

 

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
  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
  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
  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; ilevel; 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. }  
 

 

查找

跳表的优点就是查找比普通链表快，当然查找操作已经包含在在插入和删除过程，实现起来比较简单。

 搜索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  
  2. #include  
  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
  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
  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
  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
  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
  128.         {  
  129.             p=q;  
  130.         }  
  131.         update[i]=p;  
  132.     }  
  133.     if(q&&q->key==key)  
  134.     {  
  135.         //逐层删除，和普通列表删除一样  
  136.         for(int i=0; ilevel; 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 概率分析

 




 

 



你可能感兴趣的:(LevelDB 关键算法概述)

  • QQ群采集助手，精准引流必备神器 2401_87347160 其他经验分享
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • 微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务java架构
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
  • 2021-08-26 影幽
    在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
  • 腾讯云技术深度探索：构建高效云原生微服务架构 我的运维人生 云原生架构腾讯云运维开发技术共享
    腾讯云技术深度探索：构建高效云原生微服务架构在当今快速发展的技术环境中，云原生技术已成为企业数字化转型的关键驱动力。腾讯云作为行业领先的云服务提供商，不断推出创新的产品和技术，助力企业构建高效、可扩展的云原生微服务架构。本文将深入探讨腾讯云在微服务领域的最新进展，并通过一个实际案例展示如何在腾讯云平台上构建云原生应用。腾讯云微服务架构概览腾讯云微服务架构基于云原生理念，旨在帮助企业快速实现应用的容
  • Goolge earth studio 进阶4——路径修改与平滑 陟彼高冈yu Googleearthstudio进阶教程旅游
    如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
  • PHP环境搭建详细教程 好看资源平台 前端php
    PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
  • 基于社交网络算法优化的二维最大熵图像分割 智能算法研学社（Jack旭） 智能优化算法应用图像分割算法php开发语言
    智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
  • 郎朗大婚娶公主：所有光环的背后，都是十年如一日的自律 简小尘
    近日，关于郎朗大婚的新闻上了热搜，看了新娘的照片，既有天使般的面容，更有魔鬼般的身材，关键是人家还身世好，又有才华，这真的是让所有男人羡慕嫉妒恨哪。有些人不禁会想，“凭什么郎朗的人生就象开挂了一样，可我却每天都活得这么狼狈！”其实，每个开挂的人生背后，都是苦行僧般的自律。01欲戴王冠，必承其重。练琴不能只靠兴趣，更需要自律！我们先来看一下朗朗在小时候的作息时间表：早晨5:45起床，练琴1小时。中午
  • 【加密社】Solidity 中的事件机制及其应用 加密社 闲侃区块链智能合约区块链
    加密社引言在Solidity合约开发过程中，事件（Events）是一种非常重要的机制。它们不仅能够让开发者记录智能合约的重要状态变更，还能够让外部系统（如前端应用）监听这些状态的变化。本文将详细介绍Solidity中的事件机制以及如何利用不同的手段来触发、监听和获取这些事件。事件存储的地方当我们在Solidity合约中使用emit关键字触发事件时，该事件会被记录在区块链的交易收据中。具体而言，事件
  • 深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具 nseejrukjhad 数据库python
    深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
  • 如何部分格式化提示模板:LangChain中的高级技巧 nseejrukjhad langchainjava服务器python
    标题:如何部分格式化提示模板:LangChain中的高级技巧内容:如何部分格式化提示模板:LangChain中的高级技巧引言在使用大型语言模型(LLM)时,提示工程是一个关键环节。LangChain提供了强大的提示模板功能,让我们能更灵活地构建和管理提示。本文将介绍LangChain中一个高级特性-部分格式化提示模板,这个技巧可以让你的提示管理更加高效和灵活。什么是部分格式化提示模板?部分格式化提
  • Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
  • 121. 买卖股票的最佳时机 薄荷糖的味道_fb40
    给定一个数组，它的第i个元素是一支给定股票第i天的价格。如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。注意你不能在买入股票前卖出股票。示例1:输入:[7,1,5,3,6,4]输出:5解释:在第2天（股票价格=1）的时候买入，在第5天（股票价格=6）的时候卖出，最大利润=6-1=5。注意利润不能是7-1=6,因为卖出价格需要大于买入价格。示例2:输入:
  • 每日算法&面试题，大厂特训二十八天——第二十天（树） 肥学 ⚡算法题⚡面试题每日精进java算法数据结构
    目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
  • Python快速入门 —— 第三节：类与对象 孤华暗香 Python快速入门python开发语言
    第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
  • pyecharts——绘制柱形图折线图 2224070247 信息可视化pythonjava数据可视化
    一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
  • 回溯算法-重新安排行程 chirou_ 算法数据结构图论c++图搜索
    leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
  • 数据仓库——维度表一致性 墨染丶eye 背诵数据仓库
    数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
  • Rust基础知识 GRKF15 rust开发语言后端
    1.Rust语言简介1.1基础语法变量声明：let关键字用于声明变量，可以指定或不指定类型，如leta=10;和letmutc=30i32;。函数定义：使用fn关键字定义函数，并指定参数类型及返回类型，如fnadd(i:i32,j:i32)->i32{i+j}。控制流：包括if、else等，控制语句后需要使用;来结束语句。1.2数据类型整数类型：i8、i16、i32、i64、i128，以及无符号的
  • Faiss：高效相似性搜索与聚类的利器 网络·魚 大数据faiss
    Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
  • 18、架构-可观测性之聚合度量 大树~~ 架构javapython后端架构
    聚合度量聚合度量是指对系统运行时产生的各种指标数据进行收集、聚合和分析，以了解系统的健康状况和性能表现。聚合度量是可观测性的关键组成部分，通过对度量数据的分析，可以及时发现系统中的异常和瓶颈。以下是对聚合度量各个方面的详细解析，并结合具体的数据案例和技术支撑。指标收集收集系统运行时产生的各种指标数据是聚合度量的基础。常见的指标包括CPU使用率、内存使用率、请求处理时间、请求数、错误率等。以下是指标
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（1） 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
  • 广州会刊小程序开发公司哪家好｜开发多少钱费用｜专业外包服务 红匣子实力推荐
    在选择广州会刊小程序开发公司时，有几个关键因素需要考虑。首先，您应该确定自己的需求和目标，以便找到最合适的开发公司。其次，您需要考虑公司的经验和专业知识。最后，您还应该考虑公司的信誉和口碑。开发-联系电话：13642679953（微信同号）首先，您应该明确自己的需求和目标。会刊小程序是一种用于展示会议信息和日程安排的应用程序。在选择开发公司之前，您应该明确自己的需求，包括功能要求、设计风格和用户体
  • 2021-08-09 杜永鹏
    京❤️达总店：杜永鹏2021年8月9日落地真经严格就是爱，放纵既是害目标确认目标:产值目标165000台次目标100油卡目标10体验：在工作中遇到问题不要盲目的去干，要多方面考虑问题，找到问题的关键克服困难并解决问题！
  • 剧本杀《鲸鱼马戏团》剧本杀剧透+真相答案复盘解析攻略 VX搜_奶茶剧本杀
    本文为剧本杀《鲸鱼马戏团》剧本杀测评+部分真相复盘，获取完整真相复盘只需两步：①、关注微信公众号【奶茶剧本杀】→②、回复剧本杀《鲸鱼马戏团》即可获取查看剧本杀《鲸鱼马戏团》剧本杀真相答案复盘+凶手剧透：以下是玩家评测+部分关键证据，凶手，时间线，复盘解析，推理逻辑--------------------------------------------------------------------
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞 文章永久免费只为良心 oracle数据库
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
  • 数据结构之哈希表 X同学的开始 数据结构数据结构散列表
    哈希表(散列表)出现的原因在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，
  • 高仿包包批发在哪里买最便宜?推荐6个购买渠道 鸿运工作室
    高仿包包作为一种时尚单品，受到很多人的喜爱。然而，对于批发高仿包包的人来说，如何找到最便宜的购买渠道是一个关键问题。本文将为您推荐6个购买高仿包包最便宜的渠道，帮助您更好地满足批发需求。咨询加微信：FB2260(下单赠送精美礼品)1.义乌国际商贸城义乌国际商贸城是中国最大的小商品批发市场之一，也是高仿包包批发的热门地点。这里有众多的批发商聚集，提供了各种各样的高仿包包，价格相对较低。您可以在这里找
  • insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
    前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
  • 基本数据类型和引用类型的初始值 3213213333332132 java基础
    package com.array; /** * @Description 测试初始值 * @author FuJianyong * 2015-1-22上午10:31:53 */ public class ArrayTest { ArrayTest at; String str; byte bt; short s; int i; long
  • 摘抄笔记--《编写高质量代码：改善Java程序的151个建议》 白糖_ 高质量代码
            记得3年前刚到公司，同桌同事见我无事可做就借我看《编写高质量代码：改善Java程序的151个建议》这本书，当时看了几页没上心就没研究了。到上个月在公司偶然看到，于是乎又找来看看，我的天，真是非常多的干货，对于我这种静不下心的人真是帮助莫大呀。           看完整本书，也记了不少笔记
  • 【备忘】Django 常用命令及最佳实践 dongwei_6688 django
    注意：本文基于 Django 1.8.2 版本   生成数据库迁移脚本（python 脚本） python manage.py makemigrations polls  说明：polls 是你的应用名字，运行该命令时需要根据你的应用名字进行调整   查看该次迁移需要执行的 SQL 语句（只查看语句，并不应用到数据库上）： python manage.p
  • 阶乘算法之一N! 末尾有多少个零 周凡杨 java算法阶乘面试效率
                                     &n
  • spring注入servlet g21121 Spring注入
    传统的配置方法是无法将bean或属性直接注入到servlet中的，配置代理servlet亦比较麻烦，这里其实有比较简单的方法，其实就是在servlet的init()方法中加入要注入的内容： ServletContext application = getServletContext(); WebApplicationContext wac = WebApplicationContextUtil
  • Jenkins 命令行操作说明文档 510888780 centos
    假设Jenkins的URL为http://22.11.140.38:9080/jenkins/ 基本的格式为 java 基本的格式为 java -jar jenkins-cli.jar [-s JENKINS_URL] command [options][args] 下面具体介绍各个命令的作用及基本使用方法 1. &nb
  • UnicodeBlock检测中文用法 布衣凌宇 UnicodeBlock
    /**  * 判断输入的是汉字  */ public static boolean isChinese(char c) {        Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);    
  • java下实现调用oracle的存储过程和函数 aijuans javaorale
    1.创建表：STOCK_PRICES     2.插入测试数据：     3.建立一个返回游标：  PKG_PUB_UTILS   4.创建和存储过程：P_GET_PRICE     5.创建函数：   6.JAVA调用存储过程返回结果集 JDBCoracle10G_INVO
  • Velocity Toolbox antlove 模板toolboxvelocity
    velocity.VelocityUtil package velocity; import org.apache.velocity.Template; import org.apache.velocity.app.Velocity; import org.apache.velocity.app.VelocityEngine; import org.apache.velocity.c
  • JAVA正则表达式匹配基础 百合不是茶 java正则表达式的匹配
      正则表达式;提高程序的性能,简化代码,提高代码的可读性,简化对字符串的操作   正则表达式的用途; 字符串的匹配 字符串的分割 字符串的查找 字符串的替换       正则表达式的验证语法     [a] //[]表示这个字符只出现一次 ,[a] 表示a只出现一
  • 是否使用EL表达式的配置 bijian1013 jspweb.xmlELEasyTemplate
            今天在开发过程中发现一个细节问题，由于前端采用EasyTemplate模板方法实现数据展示，但老是不能正常显示出来。后来发现竟是EL将我的EasyTemplate的${...}解释执行了，导致我的模板不能正常展示后台数据。         网
  • 精通Oracle10编程SQL(1-3)PLSQL基础 bijian1013 oracle数据库plsql
    --只包含执行部分的PL/SQL块 --set serveroutput off begin dbms_output.put_line('Hello,everyone!'); end; select * from emp; --包含定义部分和执行部分的PL/SQL块 declare v_ename varchar2(5); begin select
  • 【Nginx三】Nginx作为反向代理服务器 bit1129 nginx
    Nginx一个常用的功能是作为代理服务器。代理服务器通常完成如下的功能：   接受客户端请求 将请求转发给被代理的服务器 从被代理的服务器获得响应结果 把响应结果返回给客户端 实例 本文把Nginx配置成一个简单的代理服务器 对于静态的html和图片，直接从Nginx获取 对于动态的页面，例如JSP或者Servlet，Nginx则将请求转发给Res
  • Plugin execution not covered by lifecycle configuration: org.apache.maven.plugin blackproof maven报错
    转：http://stackoverflow.com/questions/6352208/how-to-solve-plugin-execution-not-covered-by-lifecycle-configuration-for-sprin   maven报错： Plugin execution not covered by lifecycle configuration:
  • 发布docker程序到marathon ronin47 docker 发布应用
    1 发布docker程序到marathon 1.1 搭建私有docker registry 1.1.1 安装docker regisry docker pull docker-registry docker run -t -p 5000:5000 docker-registry 下载docker镜像并发布到私有registry docker pull consol/tomcat-8.0
  • java-57-用两个栈实现队列&&用两个队列实现一个栈 bylijinnan java
    import java.util.ArrayList; import java.util.List; import java.util.Stack; /* * Q 57 用两个栈实现队列 */ public class QueueImplementByTwoStacks { private Stack<Integer> stack1; pr
  • Nginx配置性能优化 cfyme nginx
    转载地址：http://blog.csdn.net/xifeijian/article/details/20956605   大多数的Nginx安装指南告诉你如下基础知识——通过apt-get安装，修改这里或那里的几行配置，好了，你已经有了一个Web服务器了。而且，在大多数情况下，一个常规安装的nginx对你的网站来说已经能很好地工作了。然而，如果你真的想挤压出Nginx的性能，你必
  • [JAVA图形图像]JAVA体系需要稳扎稳打,逐步推进图像图形处理技术 comsci java
         对图形图像进行精确处理，需要大量的数学工具，即使是从底层硬件模拟层开始设计，也离不开大量的数学工具包，因为我认为，JAVA语言体系在图形图像处理模块上面的研发工作，需要从开发一些基础的，类似实时数学函数构造器和解析器的软件包入手，而不是急于利用第三方代码工具来实现一个不严格的图形图像处理软件......   &nb
  • MonkeyRunner的使用 dai_lm androidMonkeyRunner
    要使用MonkeyRunner，就要学习使用Python，哎 先抄一段官方doc里的代码 作用是启动一个程序（应该是启动程序默认的Activity），然后按MENU键，并截屏 # Imports the monkeyrunner modules used by this program from com.android.monkeyrunner import MonkeyRun
  • Hadoop-- 海量文件的分布式计算处理方案 datamachine mapreducehadoop分布式计算
    csdn的一个关于hadoop的分布式处理方案，存档。 原帖：http://blog.csdn.net/calvinxiu/article/details/1506112。     Hadoop 是Google MapReduce的一个Java实现。MapReduce是一种简化的分布式编程模式，让程序自动分布到一个由普通机器组成的超大集群上并发执行。就如同ja
  • 以資料庫驗證登入 dcj3sjt126com yii
    以資料庫驗證登入 由於 Yii 內定的原始框架程式, 採用綁定在UserIdentity.php 的 demo 與 admin 帳號密碼:    public function authenticate()    {        $users=array( &nbs
  • github做webhooks：[2]php版本自动触发更新 dcj3sjt126com githubgitwebhooks
    上次已经说过了如何在github控制面板做查看url的返回信息了。这次就到了直接贴钩子代码的时候了。 工具/原料 git github 方法/步骤   在github的setting里面的webhooks里把我们的url地址填进去。   钩子更新的代码如下： error_reportin
  • Eos开发常用表达式 蕃薯耀 Eos开发Eos入门Eos开发常用表达式
    Eos开发常用表达式 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2014年8月18日 15:03:35 星期一     &
  • SpringSecurity3.X--SpEL 表达式 hanqunfeng SpringSecurity
    使用 Spring 表达式语言配置访问控制，要实现这一功能的直接方式是在<http>配置元素上添加 use-expressions 属性：   <http auto-config="true" use-expressions="true"> 这样就会在投票器中自动增加一个投票器：org.springframework
  • Redis vs Memcache IXHONG redis
    1. Redis中，并不是所有的数据都一直存储在内存中的，这是和Memcached相比一个最大的区别。 2. Redis不仅仅支持简单的k/v类型的数据，同时还提供list，set，hash等数据结构的存储。 3. Redis支持数据的备份，即master-slave模式的数据备份。 4. Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用。 Red
  • Python - 装饰器使用过程中的误区解读 kvhur JavaScriptjqueryhtml5css
    大家都知道装饰器是一个很著名的设计模式，经常被用于AOP(面向切面编程)的场景，较为经典的有插入日志，性能测试，事务处理，Web权限校验， Cache等。 原文链接：http://www.gbtags.com/gb/share/5563.htm Python语言本身提供了装饰器语法（@），典型的装饰器实现如下：   @function_wrapper de
  • 架构师之mybatis-----update 带case when 针对多种情况更新 nannan408 case when
    1.前言.    如题. 2. 代码.   <update id="batchUpdate" parameterType="java.util.List"> <foreach collection="list" item="list" index=&
  • Algorithm算法视频教程 栏目记者 Algorithm算法
    课程：Algorithm算法视频教程 百度网盘下载地址： http://pan.baidu.com/s/1qWFjjQW 密码: 2mji 程序写的好不好,还得看算法屌不屌！Algorithm算法博大精深。 一、课程内容： 课时1、算法的基本概念 + Sequential search 课时2、Binary search 课时3、Hash table 课时4、Algor
  • C语言算法之冒泡排序 qiufeihu c算法
    任意输入10个数字由小到大进行排序。 代码： #include <stdio.h> int main() { int i,j,t,a[11]; /*定义变量及数组为基本类型*/ for(i = 1;i < 11;i++){ scanf("%d",&a[i]); /*从键盘中输入10个数*/ } for
  • JSP异常处理 wyzuomumu Webjsp
    1.在可能发生异常的网页中通过指令将HTTP请求转发给另一个专门处理异常的网页中: <%@ page errorPage="errors.jsp"%>   2.在处理异常的网页中做如下声明： errors.jsp: <%@ page isErrorPage="true"%>，这样设置完后就可以在网页中直接访问exc
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他