1. 什么是跳表
skiplist本质上也是一种查找结构,用于解决算法中的查找问题,跟平衡搜索树和哈希表的价值是一样的,可以作为key或者key/value的查找模型。
skiplist,顾名思义,首先它是一个list。实际上,它是在有序链表的基础上发展起来的。如果是一个有序的链表,查找数据的时间复杂度是O(N)。
- 1. 假如我们每相邻两个节点升高一层,增加一个指针,让指针指向下下个节点,如上图所示。这样所有新增加的指针连成了一个新的链表,但它包含的节点个数只有原来的一半。由于新增加的指针,我们不再需要与链表中每个节点逐个进行比较了,需要比较的节点数大概只有原来的一半。
- 2. 以此类推,我们可以在第二层新产生的链表上,继续为每相邻的两个节点升高一层,增加一个指针,从而产生第三层链表。如下图c,这样搜索效率就进一步提高了。
如果我们要找上图中的19,先从cur的结点的最上层开始,下一个结点是9比19小,则到9结点的位置,继续判断,19比21小,所以应该到9的第二层再判断,比17大,cur就到了17结点的位置,继续判断,比21小,所以应该到17的第三层,最后17的next就是19,成功找到。
skiplist正是受这种多层链表的想法的启发而设计出来的。实际上,按照上面生成链表的方式,上面每一层链表的节点个数,是下面一层的节点个数的一半,这样查找过程就非常类似二分查找,使得查找的时间复杂度可以降低到O(log n)。但是这个结构在插入删除数据的时候有很大的问题,插入或者删除一个节点之后,就会打乱上下相邻两层链表上节点个数严格的2:1的对应关系。如果要维持这种对应关系,就必须把新插入的节点后面的所有节点(也包括新插入的节点)重新进行调整,这会让时间复杂度重新蜕化成O(n)。
skiplist的设计为了避免这种问题,做了一个大胆的处理,不再严格要求对应比例关系,而是插入一个节点的时候随机出一个层数。这样每次插入和删除都不需要考虑其他节点的层数,这样就好处理多了。细节过程入下图:
2. skiplist的效率
skiplist插入一个节点时随机出一个层数,这里的随机并不是完全的随机,一般跳表会设计一个最大层数maxLevel的限制,其次会设置一个多增加一层的概率p。那么计算这个随机层数的伪代码如下图:
根据前面randomLevel()的伪码,我们很容易看出,产生越高的节点层数,概率越低。定量的分析如下:
- 节点层数至少为1。而大于1的节点层数,满足一个概率分布。
- 节点层数恰好等于1的概率为1-p。
- 节点层数大于等于2的概率为p,而节点层数恰好等于2的概率为p(1-p)。
- 节点层数大于等于3的概率为p^2,而节点层数恰好等于3的概率为p^2*(1-p)。节点层数大于等于4的概率为p^3,而节点层数恰好等于4的概率为p^3*(1-p)。……
因此,一个节点的平均层数(也即包含的平均指针数目),计算如下:
现在很容易计算出:
- 当p=1/2时,每个节点所包含的平均指针数目为2;
- 当p=1/4时,每个节点所包含的平均指针数目为1.33。
跳表的平均时间复杂度为O(logN),证明过程较复杂,有兴趣的可以去搜一下。
3. skiplist的实现
用一道题来实现skiplist。
题目链接:1206. 设计跳表 - 力扣(LeetCode)
题目描述:
我们可以先来看一下整体框架。
struct SkiplistNode
{
int _value; //关键字
vector<SkiplistNode*> _nextV; //下一个节点的数组
SkiplistNode(int value, int leavel)
: _value(value)
, _nextV(leavel, nullptr)
{
}
};
class Skiplist {
public:
Skiplist() {
_head = new SkiplistNode(-1, 1);
srand(time(0));
}
bool search(int target); //查找
void add(int num); //新增
bool erase(int num); //删除
public:
SkiplistNode* _head; //头节点
size_t _maxLeavel = 32; //最大层数
double _p = 0.25; //增加一层的概率
};
因为我们的层数是随机的,所以要在Skiplist的构造函数添加一段随机数种子的代码。
3.1 search
bool search(int target) {
SkiplistNode* cur = _head; //从头节点开始判断
int leavel = cur->_nextV.size() - 1; //头节点的最高层
while (leavel >= 0)
{
//如果比目标值小,就降一层
if (cur->_nextV[leavel] && cur->_nextV[leavel]->_value < target)
{
cur = cur->_nextV[leavel];
}
//如果比目标值大,就向右走
else if (cur->_nextV[leavel] == nullptr || cur->_nextV[leavel]->_value > target)
{
--leavel;
}
//找到了目标值,返回true
else
{
return true;
}
}
return false;
}
我们从头节点的最高层开始判断,初始位置如下。
每次与cur->_nextV[leavel]进行比较,也就是说每次都是与当前层的右边节点进行比较。如果比右边的小,说明目标就在当前节点和右边节点之间,所以我们需要降层,也就是--leavel;如果比右边的大,说明目标在右边节点的右边,我们需要向右走,也就是让cur = cur->_nextV[leavel];
3.2 add
void add(int num)
{
SkiplistNode* cur = _head;
int leavel = cur->_nextV.size() - 1;
vector<SkiplistNode*> prevV;
prevV.resize(leavel + 1, nullptr);
//将目标节点的前节点全部保存在prevV中
while (leavel >= 0)
{
//如果比目标值小,就向右走
if (cur->_nextV[leavel] != nullptr && cur->_nextV[leavel]->_value < num)
{
cur = cur->_nextV[leavel];
}
//如果比目标值大,说明要插入的节点就在cur右边,将cur保存起来并降层
else if (cur->_nextV[leavel] == nullptr || cur->_nextV[leavel]->_value >= num)
{
prevV[leavel] = cur;
--leavel;
}
}
//获取一个随机的层数
size_t n = RandomLeavel();
SkiplistNode* newnode = new SkiplistNode(num, n);
//如果n超过了当前最高层,就要更新head和prevV
if (_head->_nextV.size() < n)
{
_head->_nextV.resize(n);
prevV.resize(n, _head);
}
//将前后指针进行连接,插入成功
for (size_t i = 0; i < n; i++)
{
newnode->_nextV[i] = prevV[i]->_nextV[i];
prevV[i]->_nextV[i] = newnode;
}
}
插入一个节点的过程,首先要获取这个节点的前驱节点,然后每一层进行单链表的链接就行。举个例子,如果我们要插入20这个节点,并且随机的层数是4层,我们将20前面的节点保存起来,也就是9,17和19三个节点。
但是由于当前最高节点是3(头节点的层数),而要新插入一个4层的节点,就要将头节点的最高层数改为4,然后将前面保存起来的节点和20节点的前后指针链接完成,如下图所示。
3.3 erase
bool erase(int num)
{
SkiplistNode* cur = _head; //头节点
int leavel = cur->_nextV.size() - 1; //头节点的最高层数
vector<SkiplistNode*> prevV(leavel + 1, nullptr); //将前一个结点保存起来
while (leavel >= 0)
{
//如果右边的结点比目标值小,就向右走
if (cur->_nextV[leavel] != nullptr && cur->_nextV[leavel]->_value < num)
{
cur = cur->_nextV[leavel];
}
//如果右边的结点比目标值大,就保存当前结点并降层
else if (cur->_nextV[leavel] == nullptr || cur->_nextV[leavel]->_value >= num)
{
prevV[leavel] = cur;
--leavel;
}
}
//判断要删除的数是否存在
if (prevV[0]->_nextV[0] == nullptr || prevV[0]->_nextV[0]->_value != num)
{
return false;
}
else
{
SkiplistNode* del = prevV[0]->_nextV[0]; //要删除的结点
for (size_t i = 0; i < del->_nextV.size(); i++)
{
prevV[i]->_nextV[i] = del->_nextV[i];
}
delete del;
return true;
}
}
和add一样,我们需要找到要删除结点的前一个,然后将链表的指针进行修改即可,当然我们也需要先判断删除的结点是否存在,只需要判断prevV[0]的下一个是不是要删除的结点。
因为前面的代码和add一样,所以我们可以将前面的代码提取出来,写成一个函数,增大复用性。
void GetPrevV(vector<SkiplistNode*>& prevV, int num)
{
SkiplistNode* cur = _head; //头节点
int leavel = cur->_nextV.size() - 1; //头节点的最高层数
prevV.resize(leavel + 1, nullptr); //将前一个结点保存起来
while (leavel >= 0)
{
//如果右边的结点比目标值小,就向右走
if (cur->_nextV[leavel] != nullptr && cur->_nextV[leavel]->_value < num)
{
cur = cur->_nextV[leavel];
}
//如果右边的结点比目标值大,就保存当前结点并降层
else if (cur->_nextV[leavel] == nullptr || cur->_nextV[leavel]->_value >= num)
{
prevV[leavel] = cur;
--leavel;
}
}
}
bool erase(int num)
{
vector<SkiplistNode*> prevV;
GetPrevV(prevV, num);
//判断要删除的数是否存在
if (prevV[0]->_nextV[0] == nullptr || prevV[0]->_nextV[0]->_value != num)
{
return false;
}
else
{
SkiplistNode* del = prevV[0]->_nextV[0];
for (size_t i = 0; i < del->_nextV.size(); i++)
{
prevV[i]->_nextV[i] = del->_nextV[i];
}
delete del;
return true;
}
}
3.4 RandomeLeavel
int RandomLeavel()
{
size_t leavel = 1;
while (rand() < RAND_MAX * _p && leavel <= _maxLeavel)
{
++leavel;
}
return leavel;
}
获取一个随机数,方法如上,rand()的取值范围是[0,RAND_MAX],而rand() < RAND_MAX * p的意思就是概率小于p,与前面的伪代码一样。
3.5 最终代码
struct SkiplistNode
{
int _value;
vector<SkiplistNode*> _nextV;
SkiplistNode(int value, int leavel)
: _value(value)
, _nextV(leavel, nullptr)
{
}
};
class Skiplist {
public:
Skiplist() {
_head = new SkiplistNode(-1, 1);
srand(time(0));
}
bool search(int target) {
SkiplistNode* cur = _head;
int leavel = cur->_nextV.size() - 1;
while (leavel >= 0)
{
if (cur->_nextV[leavel] && cur->_nextV[leavel]->_value < target)
{
cur = cur->_nextV[leavel];
}
else if (cur->_nextV[leavel] == nullptr || cur->_nextV[leavel]->_value > target)
{
--leavel;
}
else
{
return true;
}
}
return false;
}
void GetPrevV(vector<SkiplistNode*>& prevV, int num)
{
SkiplistNode* cur = _head; //头节点
int leavel = cur->_nextV.size() - 1; //头节点的最高层数
prevV.resize(leavel + 1, nullptr); //将前一个结点保存起来
while (leavel >= 0)
{
//如果右边的结点比目标值小,就向右走
if (cur->_nextV[leavel] != nullptr && cur->_nextV[leavel]->_value < num)
{
cur = cur->_nextV[leavel];
}
//如果右边的结点比目标值大,就保存当前结点并降层
else if (cur->_nextV[leavel] == nullptr || cur->_nextV[leavel]->_value >= num)
{
prevV[leavel] = cur;
--leavel;
}
}
}
void add(int num)
{
vector<SkiplistNode*> prevV;
GetPrevV(prevV, num);
//获取一个随机的层数
size_t n = RandomLeavel();
SkiplistNode* newnode = new SkiplistNode(num, n);
//如果n超过了当前最高层,就要更新head和prevV
if (_head->_nextV.size() < n)
{
_head->_nextV.resize(n);
prevV.resize(n, _head);
}
//将前后指针进行连接,插入成功
for (size_t i = 0; i < n; i++)
{
newnode->_nextV[i] = prevV[i]->_nextV[i];
prevV[i]->_nextV[i] = newnode;
}
}
bool erase(int num)
{
vector<SkiplistNode*> prevV;
GetPrevV(prevV, num);
//判断要删除的数是否存在
if (prevV[0]->_nextV[0] == nullptr || prevV[0]->_nextV[0]->_value != num)
{
return false;
}
else
{
SkiplistNode* del = prevV[0]->_nextV[0];
for (size_t i = 0; i < del->_nextV.size(); i++)
{
prevV[i]->_nextV[i] = del->_nextV[i];
}
delete del;
return true;
}
}
int RandomLeavel()
{
size_t leavel = 1;
while (rand() < RAND_MAX * _p && leavel <= _maxLeavel)
{
++leavel;
}
return leavel;
}
void Print()
{
/*int level = _head->_nextV.size();
for (int i = level - 1; i >= 0; --i)
{
Node* cur = _head;
while (cur)
{
printf("%d->", cur->_val);
cur = cur->_nextV[i];
printf("\n");
}*/
SkiplistNode* cur = _head;
while (cur)
{
printf("%2d\n", cur->_value);
// 打印每个每个cur节点
for (auto e : cur->_nextV)
{
printf("%2s", "↓");
}
printf("\n");
cur = cur->_nextV[0];
}
}
SkiplistNode* _head;
size_t _maxLeavel = 32;
double _p = 0.25;
};
4. 跳表的优缺点
1. skiplist相比平衡搜索树(AVL树和红黑树)对比,都可以做到遍历数据有序,时间复杂度也差不多。skiplist的优势是:a、skiplist实现简单,容易控制。平衡树增删查改遍历都更复杂。b、skiplist的额外空间消耗更低。平衡树节点存储每个值有三叉链,平衡因子/颜色等消耗。skiplist中p=1/2时,每个节点所包含的平均指针数目为2;skiplist中p=1/4时,每个节点所包含的平均指针数目为1.33;
2. skiplist相比哈希表而言,就没有那么大的优势了。相比而言a、哈希表平均时间复杂度是O(1),比skiplist快。b、哈希表空间消耗略多一点。skiplist优势如下:a、遍历数据有序b、skiplist空间消耗略小一点,哈希表存在链接指针和表空间消耗。c、哈希表扩容有性能损耗。d、哈希表再极端场景下哈希冲突高,效率下降厉害,需要红黑树补足接力。