跳跃表以及C++实现

最新推荐文章于 2024-05-15 07:53:39 发布
最新推荐文章于 2024-05-15 07:53:39 发布
阅读量1.3w 收藏 56
点赞数 12
分类专栏： 数据结构 文章标签： c++ 跳跃表 skip list
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yinlili2010/article/details/39503655
版权

      首先为了方便，我大概在博友林子的博客基础上进行编辑，今天我将跳跃表实现了一下，算法导论公开课的那位年轻教授说他花了半个小时写好半个小时调试好，我的时间估计是他的4倍吧，只有结构实现看了这篇博客的插入代码，了解了只需要在n空间大小构建跳跃表的结构。对于自己几乎独立的实现了这个算法，虽然简单，但是还是很有成就感的。需要自己注意的是在独立实现代码的时候不仅仅只是需要简单的了解大概的算法，而是

1）确定需要使用的数据结构，如今天的代码中的SKNode, SkipList. 

2)如何初始化这个数据结构，这样才能得到求解问题循环结束条件。（初始化条件很重要）

3）先自己按照算法流程，插入、查找、删除一个一个写好伪代码，这样才不至于在写代码的时候没有关注点，思维混乱。可以先从最简单也是最和核心的查找算法写起。

4）最后是调试，碰到不对的步骤，可以添加打印，我现在对于数据结构还有太底层的调试时看不出来太多信息的，只能一步一步的试探。这也是一个软肋，以后有空一定要再学学编程范式这种比较底层的东西，还有内存管理也很重要。

参考的博文地址如：

跳跃链表简介

           二叉树是一种常见的数据结构。它支持包括查找、插入、删除等一系列操作。但它有一个致命的弱点，就是当数据的随机性不够时，会导致其树形结构的不平衡，从而直接影响算法的效率。

              跳跃链表（Skip List）是1987年才诞生的一种崭新的数据结构，它在进行查找、插入、删除等操作时的期望时间复杂度均为O(logn),有着近乎替代平衡树的本领。而且最重要的一点，就是它的编程复杂度较同类的AVL树，红黑树等要低得多，这使得其无论是在理解还是在推广性上，都有着十分明显的优势。

              跳跃链表的最大优势在于无论是查找、插入和删除都是O(logn)，不过由于跳跃链表的操作是基于概率形成的，那么它操作复杂度大于O(logn)的概率为，可以看出当n越大的时候失败的概率越小。

              另外跳跃链表的实现也十分简单，在平衡树中是最易实现的一种结构。例如像复杂的红黑树，你很难在不依靠工具书的帮助下实现该算法，但是跳跃链表不一样，你可以很容易在半个小时内就完成其实现。

              跳跃链表的空间复杂度的期望为O(n)，链表的层数期望为O(logn).

如何改进普通的链表？

             我们先看看一个普通的链表


            可以看出查询这个链表O(n),插入和删除也是O(n).因此链表这种结构虽然节省空间，但是效率不高，那有没有什么办法可以改进呢？

            我们可以增加一条链表做为快速通道。这样我们使用均匀分布，从图中可以看出L1层充当L0层的快速通道，底层的结点每隔固定的几个结点出现在上面一层。


            我们这里主要以查找操作来介绍，因为插入和删除操作主要的复杂度也是取决于查找，那么两条链表查找的最好的时间复杂度是多少呢？

            一次查找操作首先要在上层遍历<=|L1|次操作,然后在下层遍历<=(L0/L1)次操作,至多要经历


            次操作，其中|L1|为L1的长度,n为L0的长度.

            那么最好的时间复杂度,也就怎么设置间隔距离才能使查找次数最少有

            我们对|L1|的长度求导得


            把上式代入函数,查找次数最小也就是.这意味着下层每隔个结点在上层就有一个结点作为快速跑道。

那么三条链表呢



同理那么我们让L2/L1=L1/L0,然后同样列出方程，求导可得L2=，查找次数为3*

........................................................................

第k条链条.....查找次数为

我们这里取k=logn，代入的查找次数为2logn.

到此为主，我们应该知道了，期望上最好的层数是logn层,而且上下层结点数比为2，这样查找次数常数最小,复杂度保持在O(logn)。

跳跃链表的结构

跳跃表由多条链构成（L0，L1，L2 ……，Lh），且满足如下三个条件：

  • 每条链必须包含两个特殊元素：+∞ 和 -∞(可以需要，可以不需要，我的实现是采用了-∞作为header之后的 节点，即第一个节点，+∞作为最后一个节点)
  • L0包含所有的元素，并且所有链中的元素按照升序排列。
  • 每条链中的元素集合必须包含于序数较小的链的元素集合。


结点结构源代码

   我觉得如果不考虑空间效率是可以将数据在每层上面分开存储，但是也可以办到在一个n的空间存储，跳跃表就是在这些数据之间建立links，使用links替代树形结构，如Btreap树堆，R-B Trees, AVL trees。 现在我给的是基于一个n空间存储。


class SKNode   
{   
public:  
    int key;                  
    SKNode* forward[MAXLEVEL];  
  
    SKNode()  
    {  
        key=0;        
        for(int i =0;i<MAXLEVEL;i++)  
        {             
            forward[i]= NULL;  
        }    
    }   
    SKNode& operator=(const SKNode* & node)  
    {  
        key=node->key;  
        for(int i=0;i<MAXLEVEL;i++)  
        {  
            forward[i] = node->forward[i];  
        }  
        return *this;  
    }  
};        
//skip list, it has a header, this header have maxlevel pointers   
class SkipList  
{   
public:  
    SKNode *hdr;              /* list Header */    
    int listLevel;              /* current level of list */    
    int insert(int key);   
    SKNode* search(int key);  
    int deleteNode(int key);  
    void printList();  
    SkipList()  
    {  
        hdr = new SKNode;  
        listLevel = 0;  
        hdr->key = -INT_MAX;  
        SKNode* end = new SKNode;  
        SKNode* first = new SKNode;  
        first->key=-INT_MAX;  
        end->key=INT_MAX;  
        for(int i =0;i<MAXLEVEL;i++)  
        {     
            hdr->forward[i]=first;  
            hdr->forward[i]->forward[i] = end;  
        }  
        printList();  
    }  
    ~SkipList()  
    {  
        delete hdr;  
    }  
};

MAXlevel可以是log(n)/log(2)

跳跃链表查找操作

目的：在跳跃表中查找一个元素x

   在跳跃表中查找一个元素x，按照如下几个步骤进行：

      1、 p = hdr; 从最上层的链（Lh）的开头开始,进入到各层

      2、 for i(listLevel-1, 0) ， 从最上层的链（Lh）的开头开始， 如L3到L0

      3、假设当前位置为p，p初始值为hdr, p在i层的下一个节点为q = p->forward[i], 它向右指向的节点为q（p与q不一定相邻）。将x和q.key做比较

          (1)if  x>q.key 在i层继续向右走，

               then    p = p->forward[i].

          (2) else x<=q.key,  

             then   i--， 即将当前指针直接下移到下一层。

      for循环结束，i变为了0， 即在最后一层， p = p->foward[0]

    4、判断p,

         (1) if p!= NULL && p->key = x

                 return p

         (2) return NULL

如我们查找29， 先从入口到l3,29>11，p = 11， 判断知道往下走L2，29<30， 继续往下L1，29<30，L1，29>15， 前进，29<=29， 结束， p在15的位置，所以最后指针调整到p = p->forward[0], 判断p值。

(今天因为我从listLevel开始，浪费了好多调试时间。。。。)


元素53的查找路径

    下面是C++实现代码：

SKNode*  SkipList::search(int key)   
{      
    SKNode* current = new SKNode;  
    current = hdr;  
    int i = listLevel-1;  
    for(;i>=0;i--)  
    {  
        while(current->forward[i]->key != INT_MAX && key>current->forward[i]->key)//key大于下一个数据的值。转到本层下一个元素  
        {  
            current = current->forward[i];  
        }
		//否则i--，转到下一层
    }  
    current = current->forward[0];  
    if(current!= NULL && current->key == key)  
    {  
        cout<<"find"<<key<<endl;  
        return current;  
    }  
    return NULL;  
    
}


跳跃链表插入操作

目的：向跳跃表中插入一个元素x

     首先明确，向跳跃表中插入一个元素，相当于在表中插入一列从S0中某一位置出发向上的连续一段元素。有两个参数需要确定，即插入列的位置以及它的“高度”。

     1）关于在L0层的插入的位置，我们先利用跳跃表的查找功能， x<=q.key，所以x的位置一定是在x之后，q之前。 同样可以推论在L1,L2 ,L listLevel层的位置是在循环中生成他们这层最后的位置，就是在search的while之后记录一个这个位置为S[i]。最后需要在所有的S[i]之后重连数据之间的链接。 （但是需要注意的是为了，如果我们不想加入重复数据，需要判断p->forward[0]的值，如果相等，就是找到了，不需要再插入。当然如果我们不介意重复数据，也可以不加这个判断。）

     2）需要插入的高度，决定在L1-listLevel的哪些位置加。 而插入列的“高度”较前者来说显得更加重要，也更加难以确定。由于它的不确定性，使得不同的决策可能会导致截然不同的算法效率。为了使插入数据之后，保持该数据结构进行各种操作均为O(logn)复杂度的性质，我们引入随机化算法（Randomized Algorithms）。


伪代码如下：

Skip List Insertion(x)

    p = hdr;

    newlevel = getlevel(); 

    s[listLevel] = hdr(注意需要全部初始化为hdr，为了newlevel增长了，但是增长的层次s[i]却没有数据，没有初始化，应该从头结点开始)

    for i(listLevel-1, 0) 

          while(q!=+∞ && x>key)

                    then    p = p->forward[i].

                   //else x<=q.key,  

                   //then   i--

           s[i]=p; (s[i]为i层探索的最后一个节点，最后需要在这之后插入x)

   last = p->forward[0] //判断是否相等，。。。。

//插入数据，重连链表

if(newlevel>level) level = newlevel

for  i(newlevel-1 - 0）

    node->forward[i]= s[i]->forward[i]

    s[i]->forward[i] = node


     我定义一个随机决策模块，它的大致内容如下，但是这个代码不能保证完全随机，其实每次的运行结果都是一样的：

 

int getInsertLevel()  
{  
    int upcount = 0;  
    for(int i=0;i<MAXLEVEL;i++)  
    {  
        int num = rand()%10;  
        if(num<5)  
        {  
            upcount++;  
        }  
    }  
    return upcount;  
}



如插入43，查找路径如下。

                  43的下一个数接到的40下一个数45。

                  40的下一个数接到43


紫色的箭头表示更新过的指针

int SkipList::insert(int key)  
{  
    int level = getInsertLevel();  
    SKNode* node = new SKNode;  
    node->key=key;  
     
    SKNode *s[MAXLEVEL];  
    SKNode* current = new SKNode;  
    SKNode* last = new SKNode;  
    for(int i =0;i<MAXLEVEL;i++)  
    {  
        s[i]=hdr->forward[i];//initiation  
    }  
    current = last = hdr;  
    cout<<"hdr"<<hdr->key<<endl;  
    int i = listLevel-1;  
    for(;i>=0;i--)  
    {  
        while(current->forward[i]->key != INT_MAX && key>current->forward[i]->key)//key大于下一个数据的值。转到本层下一个元素  
        {  
            current = current->forward[i];  
        }  
        s[i] = current;//保存每一层位置上的最后指针的前驱  
    }  
    last=current->forward[0];  
    if(last != NULL && last->key == key)  
    {  
        cout<<"inset key:"<<key<<"already existed"<<endl;  
        return 0;  
    }  
    if(level>listLevel)//更新层数  
    {  
        listLevel = level;  
    }  
  
    for(int k = 0; k <listLevel;k++)  
    {  
        node->forward[k]=s[k]->forward[k];  
        s[k]->forward[k]=node;     
          
    }  
    if(level>listLevel)  
    {  
        listLevel = level;  
    }  
    return 1;  
  
}

跳跃链表的删除

目的：从跳跃表中删除一个元素x

   删除链表和插入几乎一模一样的，只是在最后重接链表不同：

   在跳跃表中查找到这个元素的位置，如果未找到，则退出 

  否则将该元素所在整列从表中删除 

   将多余的“空链”删除 

Skip List Deletion(x)

    p = hdr;

    //newlevel = getlevel(); 

    s[listLevel] = hdr(注意需要全部初始化为hdr，为了newlevel增长了，但是增长的层次s[i]却没有数据，没有初始化，应该从头结点开始)

    fori(listLevel-1, 0) 

          while(q!=+∞ && x>key)

                    then    p = p->forward[i].

                   //else x<=q.key,  

                   //then   i--

           s[i]=p; (s[i]为i层探索的最后一个节点，最后需要在这之后插入x)

   last = p->forward[0] //判断是否相等，。。。。

if(last->key != x)

 return

//删除数据，重连链表

for  i(listlevel-1 - 0）

   s[i]->forward[i]=s[i]->forward[i]->forward[i]; 

这段代码如下：

 

intSkipList::deleteNode(int key)
{
SKNode *s[MAXLEVEL];
SKNode* current = new SKNode;
SKNode* last = new SKNode;
for(inti =0;i<MAXLEVEL;i++)
 {
s[i]=hdr->forward[i];//initiation
 }
current = last = hdr;
for(inti = listLevel-1;i>=0;i--)
 {
while(current->forward[i]->key != INT_MAX && key>current->forward[i]->key)//key大于下一个数据的值。转到本层下一个元素
  {
current = current->forward[i];
  }
  s[i] = current;//保存每一层位置上的最后指针的前驱
 }
last=current->forward[0];
if(last->key != key)
 {
cout<<"delete key:"<<key<<"does not existed"<<endl;

return 0;
 }
for(inti = 0; i<listLevel;i++)
 {
s[i]->forward[i]=s[i]->forward[i]->forward[i];
 }
return 1;
}

整个C++程序如下

#include <iostream>
#include <vector>
using namespace std;  

#define MAXLEVEL 4 //最多2 power n=16个数   
/*skip list node,they are keys and pointers*/
classSKNode
{   
public:  
int key;                  
SKNode* forward[MAXLEVEL];  

SKNode()
    {  
key=0;        
for(inti =0;i<MAXLEVEL;i++)  
        {             
forward[i]= NULL;  
        }    
    }   
SKNode& operator=(constSKNode* & node)  
    {  
key=node->key;  
for(inti=0;i<MAXLEVEL;i++)  
        {  
forward[i] = node->forward[i];  
        }  
return *this;  
    }  
};        
//skip list, it has a header, this header have maxlevel pointers   
classSkipList
{   
public:  
SKNode *hdr;              /* list Header */    
intlistLevel;              /* current level of list */    
int insert(int key);   
SKNode* search(int key);  
intdeleteNode(int key);  
voidprintList();  
SkipList()
    {  
hdr = new SKNode;  
listLevel = 0;  
hdr->key = -INT_MAX;  
SKNode* end = new SKNode;  
SKNode* first = new SKNode;  
first->key=-INT_MAX;  
end->key=INT_MAX;  
for(inti =0;i<MAXLEVEL;i++)  
        {     
hdr->forward[i]=first;  
hdr->forward[i]->forward[i] = end;  
        }  
printList();  
    }  
    ~SkipList()
    {  
deletehdr;  
    }  
};   
intgetInsertLevel()  
{  
intupcount = 0;  
for(inti=0;i<MAXLEVEL;i++)  
    {  
intnum = rand()%10;  
if(num<5)  
        {  
upcount++;  
        }  
    }  
returnupcount;  
}  
SKNode*  SkipList::search(int key)   
{      
SKNode* current = new SKNode;  
current = hdr;  
inti = listLevel-1;  
for(;i>=0;i--)  
    {  
while(current->forward[i]->key != INT_MAX && key>current->forward[i]->key)//key大于下一个数据的值。转到本层下一个元素  
        {  
current = current->forward[i];  
        }
		//否则i--，转到下一层
    }  
current = current->forward[0];  
if(current!= NULL && current->key == key)  
    {  
cout<<"find"<<key<<endl;  
return current;  
    }  
return NULL;  

}   

intSkipList::insert(int key)  
{  
int level = getInsertLevel();  
SKNode* node = new SKNode;  
node->key=key;  

SKNode *s[MAXLEVEL];  
SKNode* current = new SKNode;  
SKNode* last = new SKNode;  
for(inti =0;i<MAXLEVEL;i++)  
    {  
s[i]=hdr->forward[i];//initiation  
    }  
current = last = hdr;  
cout<<"hdr"<<hdr->key<<endl;  
inti = listLevel-1;  
for(;i>=0;i--)  
    {  
while(current->forward[i]->key != INT_MAX && key>current->forward[i]->key)//key大于下一个数据的值。转到本层下一个元素  
        {  
current = current->forward[i];  
        }  
        s[i] = current;//保存每一层位置上的最后指针的前驱  
    }  
last=current->forward[0];  
if(last != NULL && last->key == key)  
    {  
cout<<"inset key:"<<key<<"already existed"<<endl;  
return 0;  
    }  
    if(level>listLevel)//更新层数  
    {  
listLevel = level;  
    }  

for(int k = 0; k <listLevel;k++)  
    {  
node->forward[k]=s[k]->forward[k];  
s[k]->forward[k]=node;     

    }  
if(level>listLevel)  
    {  
listLevel = level;  
    }  
return 1;  

}  
intSkipList::deleteNode(int key)
{
SKNode *s[MAXLEVEL];
SKNode* current = new SKNode;
SKNode* last = new SKNode;
for(inti =0;i<MAXLEVEL;i++)
 {
s[i]=hdr->forward[i];//initiation
 }
current = last = hdr;
for(inti = listLevel-1;i>=0;i--)
 {
while(current->forward[i]->key != INT_MAX && key>current->forward[i]->key)//key大于下一个数据的值。转到本层下一个元素
  {
current = current->forward[i];
  }
  s[i] = current;//保存每一层位置上的最后指针的前驱
 }
last=current->forward[0];
if(last->key != key)
 {
cout<<"delete key:"<<key<<"does not existed"<<endl;

return 0;
 }
for(inti = 0; i<listLevel;i++)
 {
s[i]->forward[i]=s[i]->forward[i]->forward[i];
 }
return 1;
}
voidSkipList::printList()
{
	SKNode* current = hdr;
	for(inti = listLevel -1;i>=0;i--)
	{
		current = hdr->forward[i];
		cout<<"level "<<i<<"................................"<<endl;
		while(current->forward[i] != NULL)//key大于下一个数据的值。转到本层下一个元素
		{
			cout<<" "<<current->key;
			current = current->forward[i];
		}
		cout<<" "<<current->key<<endl; 
	}
}   

int main() 
{ 
	SkipListsk;
	constint n = 7;
	intnum[n]={30,15,45,37,11,53,17};
	cout<<"test insert............."<<endl;
	for(inti = 0;i<n;i++)
	{
		sk.insert(num[i]);
	}
	sk.printList();
	cout<<"test search............"<<endl;
	sk.search(17);
	cout<<"test delete................."<<endl;
	sk.deleteNode(30);
	sk.printList();
	system("pause");
	return 0;
}



 

跳跃链表的搜索时间复杂度为O(logn)

定理：n个元素的跳跃链表的每一次搜索的时间复杂度有很高的概率为O(logn).

高概率:事件E以很高的概率发生意味着对于a>=1,存在一个合适的常数使得事件E发生的概率Pr{E}>=1-O(1/n^a).

其中a是任意选择的一个数，不同的a影响搜索时间复杂度的常数，即a*O(logn),这个在后面介绍.

我们要证跳跃链表的时间复杂度，不能只是证明一次搜索的复杂度为,是要证明全部的搜索都是O(logn),因为这是基于概率的算法，如果光一次有效率并没有多大作用.

我们定义时间Ei为某一次搜索失败的概率，那么假设k次搜素,我们先假定失败的概率为O(1/n^a),其中至少有一次失败的概率为



可以估算出k次有一次失败的概率为1/n^(a-c),那么我们只要让a>=c+1或者a取无穷大，就可以证明每一次搜索都具有高概率成功。



跳跃链表的层数有高概率为O(logn)

            类似上面的方法，对于n个元素，如果有一个层数超过O(logn)就算失败。那么对于某一个元素超过clogn层，即失败的概率为Pr{E}.那么对于一次搜索失败的概率为

令a=c-1,则只要a>=1时，就有高概率的可能使得层数为O(logn)


跳跃链表单次查找复杂度大于O(logn)的概率

每完成一次查找，都肯定要从最顶层移动到最下面一层，这每改变一次层数是由概率选择时候的p处于扔硬币中的正面决定的。.既然上面知道层数高概率为clogn层,那么扔正面的次数为clogn-1次.

我们假设扔了clogn个正面，超过10*clogn次是反面，则有


因为9-log(10e)中的9是线性增长，要远远大于log(10e)中的对数增长，因此超过10clogn的概率随着10的增长变得越来越.所以全部的操作都在10logn以内，我们使用k替代10作为常数，即查找次数为klogn，为O(logn).
Diehard_Yin
关注
  • 12
    点赞
  • 踩
  • 56
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
c++实现跳跃表（Skip List）的方法示例
08-29
跳表（skiplist）是一个非常优秀的数据结构，实现简单，插入、删除、查找的复杂度均为O(logN)，下面这篇文章主要介绍了c++实现跳跃表（Skip List）的相关资料，需要的朋友可以参考借鉴，下面随着小编来一起学习学习...
跳跃表 C++实现
11-23
本篇将详细介绍C++实现跳跃表的原理、步骤以及如何与红黑树进行对比测试。 跳跃表（Skip List）的基本思想是通过在原有有序链表上增加多级索引，使得查找过程可以跳跃性地前进，从而减少查找次数。每条数据记录都有...
数据结构之：跳表
www_tlj的专栏
02-25 2382
跳表（Skip List）是一种概率性数据结构，它通过在普通有序链表的基础上增加多级索引层来实现快速的查找、插入和删除操作。跳表的效率可以与平衡树相媲美，其操作的时间复杂度也是O(log n)，但跳表的结构更简单，更易于实现。
C C++最新洛谷 P2678 跳石头_跳石头 力扣(1)，2024年最新统统都会
最新发布
2401_84975561的博客
05-15 580
Di0DiLDi​(0
Redis知识梳理(30)[ 跳跃列表 ]
cowbin2012的专栏
05-09 1万+
Redis 的 zset 是一个复合结构，一方面它需要一个 hash 结构来存储 value 和 score 的对应关系，另一方面需要提供按照 score 来排序的功能，还需要能够指 定 score 的范围来获取 value 列表的功能，这就需要另外一个结构「跳跃列 表」。 zset 的内部实现是一个 hash 字典加一个跳跃列表 (skiplist)。hash 结构在讲字 典结构时已经详细分析...
跳跃表详解
weixin_51270766的博客
06-26 463
跳跃表[SkipList]是一种基于有序链表的扩展，简称跳表，其就是使用关键节点作为索引的一种数据结构怎样能更快查找到一个【有序链表】的某一节点呢？可以利用类似【索引】的思想，提取出【链表】中的【部分关键节点】比如：给定一个长度是7的有序链表，节点值依次是1->2->3->5->6->7->8 那么我们可以取出所有值为【奇数的节点】作为关键点。此时如果要插入一个值是4的新节点，不再需要和原节点8,7,6,5,3逐一比较，只需要比较关键节点7,5,3。
跳跃游戏（C++解法）
m0_62275194的博客
09-06 300
给你一个非负整数数组 nums，你最初位于数组的 第一个下标。数组中的每个元素代表你在该位置可以跳跃的最大长度。判断你是否能够到达最后一个下标，如果可以，返回 true；否则，返回 false。true可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。false无论怎样，总会到达下标为 3 的位置。但该下标的最大跳跃长度是 0 ， 所以永远不可能到达最后一个下标。
C++实现1-5确定性跳跃表
03-16
C++经典实现1-5确定性跳跃表.本文首先介绍1-5确定性跳跃表，然后采用C++语言对其实现！
c++如何实现跳表
08-18
C++实现跳表的知识点 跳表是一种随机化的数据结构，它允许快速查询一个有序连续元素的数据链表。跳跃列表的平均查找和插入时间复杂度都是O(log n)，优于普通队列的O(n)。性能上和红黑树，AVL树不相上下，但跳表的...
c++如何实现跳表（skiplist）
12-17
二分查找底层依赖的是数组随机访问的特性，所以只能用数组来实现。如果数据存储在链表中，就真的没法用二分查找算法了吗？实际上，只需要对链表稍加改造，就可以支持类似“二分”的查找算法。改造之后的数据结构叫作...
skiplist 跳表C++实现
10-08
skiplist 跳表C++实现,资料参考 en.wikipedia.org/wiki/Skip_list
使用c、c++配合EasyX库实现的模拟数字表盘时钟clock1.rar
01-12
在C++中，这可以通过`<thread>`库实现。 6. **动画效果**：为了使指针平滑地转动，可能采用了帧动画技术。这需要控制指针每次转动的角度，使其看起来平滑而不是瞬间跳跃。可能使用定时器和延时函数（如`Sleep()`）...
基于C++实现的（控制台）密码算法设计【100010672】
02-07
在C++中，可以通过循环和模运算实现这个过程。这种密码易于实现，但也很容易破解，因为加密和解密只需要知道偏移量。 2. **维吉尼亚密码**： 维吉尼亚密码是一种多表替换系统，它使用一个密钥来决定一系列凯撒密码...
基础PageRank 算法 C++实现
08-29
在提供的`PageRank.h`和`PageRank.cpp`文件中，可以看到具体的C++实现细节，包括数据结构设计（可能使用邻接矩阵或邻接表表示链接关系）、迭代更新的逻辑以及收敛条件的判断。通过阅读和分析源代码，我们可以深入...
INVERTED_INDEX:倒排索引结构的实现，用C++编写
07-11
- **查询优化**：为了提高搜索效率，可能需要对词项列表进行压缩，如使用位图（Bitset）表示文档ID，或者对频繁出现的词项采用跳跃表（Skip List）进行加速。 - **内存管理**：倒排索引可能会占用大量内存，因此...
63个Linux基础自测题
test121210的博客
05-26 3万+
文章目录 第1部分 1、什么是Linux内核，有什么作用？ 2、什么是shell，有什么作用？ 3、安装Linux至少需要几个分区？ 4、Swap分区的作用是什么？ 5、什么是运行级别？Linux有几个运行级别？ 6、如何更改默认启动级别？ 第2部分 1、什么是Linux终端？Linux终端又称为什么？ 2、默认情况下，Linux有几个虚拟终端？如何在不同终端之间...
数据结构填空题
热门推荐
qq_40907977的博客
08-07 5万+
1、 2、 3、 4、 5、 6、 7、 8、 9、 10、 11、 12、 13、 14、 15、 16、 17、 18、 19、 20、 21、 22、 23、 24、 25、 26、 27、 28、 29、 30、 31、 32、 33、 34、 35、 36、 37、 38、 39、 40、 41、 42、 43、 44、 45、 46、 47、 48、 49、 50、 51、 52、 53、 54、 55、 56、 57、 58、 59、 60、 61、 62、 63、 64、 65、 66、 6
KMP算法是什么？利用c++实现该算法
09-01
然后，在匹配过程中，通过对模式字符串和主字符串进行逐个字符的比较，当出现不匹配的情况时，根据部分匹配表中的信息，调整模式字符串的对齐位置，从而实现跳跃式的匹配。 以下是利用C语言来实现KMP算法的示例代码...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值