上课的时候第一次听说跳表这种数据结构。跳表的出现主要是为了提升顺序链表的查找速度(因为顺序链表不能用二分查找)。实现跳表的思路还是很简单的,就是在链表的基础上,构建一个链表元素的索引,比如下面这个链表:
value:1 value:2 value:3 ...... vlaue:n
pointer-->pointer-->pointer-->......-->pointer-->NULL
以上面这个链表为基础构建的跳表中的一种是这样的:
HEAD-->value:2
pNext -------------------------------> NULL
pDown
|
V
value:2
pNext -------------------------------> NULL
pDown
|
V
value:1 value:2 value:3 ... vlaue:n
pNext ---> pNext ---> pNext --> ...--> pNext --> NULL
pDown:NULL pDown:NULL pDown:NULL pDown:NULL
可以看到,这里将value = 2的节点的“层数”提高到了3层,而其它的元素仍然为1层,查找时,从HEAD指针指向的value = 2 的节点开始,如果带查找的元素大于2,就到2的右边查找;反之就到左边查找,起到一个类似二分查找的作用。
代码如下:
#pragma once
#include
#include
#include
using namespace std;
#define MAX_LEVEL 4
#define MIN 0
#define myCalloc(n) (NODE*)calloc(n,sizeof(NODE))
#define NEXT(p) p + 1
跳表节点定义:
typedef struct node{
int dat;
struct node * pNext;
struct node * pDown;
}NODE;
跳表类定义:
class skipList{
private:
NODE * pSkipL;
int higest;
int random();
void insert(int value, int level);
void myRecalloc(NODE*&p, int n);
public:
skipList();
~skipList();
void buildSkipList(int * arr, int arrSize);
void insert(int value);
void delElement(int value);
void search(int value);
};
构造/析构函数:
skipList::skipList(){
pSkipL = NULL;
higest = 1;
}
skipList::~skipList(){
if (pSkipL != NULL){
try{
free(pSkipL);
}
catch (char * e){
cout << e << endl;
}
}
}
根据输入的数组初始化跳表:
void skipList::buildSkipList( int * arr, int arrSize){
int level;
srand(time(0));
for (int i = 0; i < arrSize; i++){
level = random();
cout << level << endl;
if (pSkipL == NULL){
//如果是第一次创建跳表,需要生成当前最高层数的头节点
pSkipL = myCalloc(MAX_LEVEL);
higest = MAX_LEVEL;
//将头节点用pDown指针连起来
for (int j = 0; j < MAX_LEVEL - 1; j++){
pSkipL[j].dat = MIN;
pSkipL[j].pNext = NULL;
pSkipL[j].pDown = NEXT(pSkipL + j);
}
//最后一个特殊处理
pSkipL[MAX_LEVEL - 1].dat = MIN;
pSkipL[MAX_LEVEL - 1].pDown = NULL;
}
insert(arr[i], level);
}
}
往队列中插入一个元素,插入时若该元素有多层,应该注意上层之间的链接:
void skipList::insert( int value, int level){
NODE *p = myCalloc(level);
int tempLevel = higest;
NODE *pTemp = pSkipL;
//生成一个存储value元素,层数为level的元素列
for (int i = 0; i < level - 1; i++){
p[i].dat = value;
p[i].pDown = NEXT(p + i);
p[i].pNext = NULL;
}
p[level - 1].dat = value;
p[level - 1].pDown = NULL;
p[level - 1].pNext = NULL;
//搜索跳表,找到插入位置
while (pTemp != NULL){
if (tempLevel > level){
//当前所在层数高于带插入元素列的层数,直接进入下一行
pTemp = pTemp->pDown;
tempLevel--;
}
else{
//当前所在层数小于或等于待插入元素列的层数
while (pTemp->pNext != NULL && pTemp->pNext->dat < p->dat){
//横向搜索插入位置
pTemp = pTemp->pNext;
}
if (pTemp->pNext != NULL&&pTemp->pNext->dat == p->dat){
cout << "Already exist" << endl;
break;//跳表中已有该元素,跳出搜索循环(最外层while)
}
else {
//下一个元素大于待插入元素或者没有下一个元素,开始插入
NODE* t = pTemp->pNext;
pTemp->pNext = p + (level - tempLevel);//由于初始化的原因,下标大的是低层
pTemp->pNext->dat = value;
p[level - tempLevel].pNext = t;
//进入下一行
pTemp = pTemp->pDown;
}
tempLevel--;
}
}
}
void skipList::insert(int value){
int level = random();
cout << level << endl;
insert(value, level);
}
删除跳表中的元素,麻烦的地方是删除整列的元素:
void skipList::delElement(int value){
NODE * temp = pSkipL;
while (temp != NULL){
while (temp->pNext != NULL && value > temp->pNext->dat){
temp = temp->pNext;
}
if (temp->pNext != NULL && temp->pNext->dat == value){
//第一次碰到待删除元素,开始删除,函数出口在外层while循环内
NODE*t1 = temp->pNext;
int level = 0;
while (t1 != NULL){
t1 = t1->pDown;
level++;
}
t1 = temp->pNext;//记录此元素列的最高处,以便之后的free
for(int i = 0; i < level; i++){
temp->pNext = t1[i].pNext;
temp = temp->pDown;
if (temp != NULL){
while (temp->pNext != NULL &&temp->pNext->dat != value){
temp = temp->pNext;
}
if (temp->pNext == NULL){
free(t1);
cout << "Delete value: " << value << " successfully!" << endl;
return;
}
}
else{
free(t1);
cout << "Delete value: " << value << " successfully!" << endl;
return;
}
}
}
else{
temp = temp->pDown;
}
}
cout << "value " << value << " not found," << " Delete failed!"<
搜索跳表中的元素:
void skipList::search(int value){
NODE * temp = pSkipL;
while (temp != NULL){
while (temp->pNext != NULL && value > temp->pNext->dat){
temp = temp->pNext;
}
if (temp->pNext != NULL&&temp->pNext->dat == value){
cout << "Found value: " << temp->pNext->dat << endl;
return;
}
else{
temp = temp->pDown;
}
}
cout << "value " << value << " not found!" << endl;
}
随机产生层数:
int skipList::random(){
int level = 1;
while (rand() % 2 == 1 && level < MAX_LEVEL){//几何分布,期望是2层
level++;
}
return level;
}
测试样例
#pragma once
#include"skipChart.h"
int main(){
skipList l;
int arr[5] = {1, 3, 5, 7, 9};
int s = sizeof(arr) / sizeof(int);
l.buildSkipList(arr,s);
l.insert(4);
l.insert(10);
l.insert(6);
l.search(1);
l.delElement(1);
l.search(1);
l.search(3);
l.delElement(3);
l.search(3);
l.search(6);
l.delElement(6);
l.search(6);
l.delElement(-1);
system("pause");
return 0;
}
关于跳表,我刚刚学习的时候有个疑问,就是既然层数是随机的,那么怎么保证调表增删改查的时间复杂度呢?
原来跳表的时间复杂度不是固定的,但是在概率上是确定的,也就是有一个期望的时间复杂度。
其实跳表顺时针旋转90度就像一个多叉树,层数就是叉数,所以层数的期望值x就是查找的时间复杂度的对数底:即时间复杂度是O(logxN).
这里有一篇博客讲的比较清楚:http://m.blog.csdn.net/article/details?id=38706729
我这里实现的跳表比较麻烦,浪费了很多空间,这两天应该会抽时间优化,用指针数组取代真实的层数模拟,从而节省空间。