您最多选择25个主题
主题必须以字母或数字开头，可以包含连字符 (-)，并且长度不得超过35个字符
417 行
12 KiB
417 行
12 KiB
//
|
|
// Created by fox on 2017/10/10.
|
|
// Skip Lists: A Probabilistic Alternative to Balanced Trees
|
|
// indexable skip list
|
|
// duplicated score and node
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <limits.h>
|
|
#include <string.h>
|
|
#include "skiplist.h"
|
|
#include <time.h>
|
|
|
|
// from 0 to n
|
|
#define SKIPLIST_MAX_LEVEL 15
|
|
#define LEVEL_SIZE (SKIPLIST_MAX_LEVEL+1)
|
|
#define RAND_UNIFORM(x) (int)((double)rand() / RAND_MAX * (x))
|
|
|
|
/* Create a skiplist node with the specified number of levels. */
|
|
snode *skiplistCreateNode(int level, int score, vtype value) {
|
|
snode *zn =
|
|
(snode *)icalloc(sizeof(*zn)+level*sizeof(struct skiplistLevel));
|
|
zn->score = score;
|
|
zn->value = value;
|
|
return zn;
|
|
}
|
|
|
|
skiplist *skiplist_init(void)
|
|
{
|
|
time_t t;
|
|
srand((unsigned)(time(&t)));
|
|
|
|
snode *header = skiplistCreateNode(LEVEL_SIZE, INT_MAX, INT_MAX);
|
|
for (int i = 0; i < LEVEL_SIZE; ++i) {
|
|
header->level[i].span = 1;
|
|
}
|
|
|
|
skiplist *list = (skiplist *)imalloc(sizeof(skiplist));
|
|
list->header = header;
|
|
list->level = 0;
|
|
list->size = 0;
|
|
|
|
return list;
|
|
}
|
|
|
|
static int rand_level()
|
|
{
|
|
int level = 0;
|
|
while (rand() < RAND_MAX / 2 && level < SKIPLIST_MAX_LEVEL)
|
|
// while (arc4random() < INT_MAX && level < SKIPLIST_MAX_LEVEL)
|
|
level++;
|
|
return level;
|
|
}
|
|
|
|
// insert score,node into a skiplist, return 0
|
|
int skiplist_insert(skiplist *list, int score, vtype value)
|
|
{
|
|
snode **update = (snode **)imalloc(sizeof(snode*) * (list->level + 1));
|
|
unsigned int *fore_width = (unsigned int *)imalloc(sizeof(unsigned int) * (list->level + 1));
|
|
snode *x = list->header;
|
|
int i;
|
|
for (i = list->level; i >= 0; i--) {
|
|
fore_width[i] = 0;
|
|
while (x->level[i].forward && x->level[i].forward->score <= score) {
|
|
fore_width[i] += x->level[i].span;
|
|
x = x->level[i].forward;
|
|
}
|
|
update[i] = x;
|
|
}
|
|
// assert(x->score <= score);
|
|
|
|
int level = rand_level();
|
|
list->size = list->size+1;
|
|
|
|
x = skiplistCreateNode(level+1, score, value);
|
|
|
|
// the lowest layer is one by one
|
|
x->level[0].forward = update[0]->level[0].forward;
|
|
x->level[0].span = 1;
|
|
update[0]->level[0].forward = x;
|
|
|
|
unsigned int temp_width;
|
|
for (i = 1; i <= (list->level < level ? list->level : level); i++) {
|
|
temp_width = fore_width[i-1] + update[i-1]->level[i-1].span;
|
|
x->level[i].forward = update[i]->level[i].forward;
|
|
x->level[i].span = update[i]->level[i].span + 1 - temp_width;
|
|
update[i]->level[i].forward = x;
|
|
update[i]->level[i].span = temp_width;
|
|
}
|
|
|
|
if (level > list->level) {
|
|
// complete the new level
|
|
temp_width = fore_width[list->level] + update[list->level]->level[list->level].span;
|
|
for (i = list->level+1; i <= level; i++) {
|
|
list->header->level[i].span = temp_width;
|
|
list->header->level[i].forward = x;
|
|
x->level[i].forward = NULL;
|
|
x->level[i].span = list->size + 1 - temp_width;
|
|
}
|
|
list->level = level;
|
|
}
|
|
else {
|
|
// complete the unreached level
|
|
for (; i <= list->level; ++i) {
|
|
update[i]->level[i].span++;
|
|
}
|
|
}
|
|
|
|
ifree(update);
|
|
ifree(fore_width);
|
|
return 0;
|
|
}
|
|
|
|
int skiplist_update(skiplist *list, int score, vtype value, int old_score)
|
|
{
|
|
skiplist_delete(list, old_score, value);
|
|
return skiplist_insert(list, score, value);
|
|
}
|
|
|
|
// search score in skiplist.
|
|
// set the struct with index and first node if exists, otherwise set index 0
|
|
void skiplist_search(skiplist *list, int score, skiplist_search_ret *ret)
|
|
{
|
|
snode *x = list->header;
|
|
int temp_width = 1;
|
|
for (int i = list->level; i >= 0; i--) {
|
|
while (x->level[i].forward && x->level[i].forward->score < score) {
|
|
temp_width += x->level[i].span;
|
|
x = x->level[i].forward;
|
|
}
|
|
}
|
|
x = x->level[0].forward;
|
|
|
|
ret->index = temp_width;
|
|
ret->node = x;
|
|
}
|
|
|
|
// first index of score
|
|
int skiplist_index_of_score(skiplist *list, int score)
|
|
{
|
|
snode *x = list->header;
|
|
int temp_width = 1;
|
|
for (int i = list->level; i >= 0; i--) {
|
|
while (x->level[i].forward && x->level[i].forward->score < score) {
|
|
|
|
temp_width += x->level[i].span;
|
|
x = x->level[i].forward;
|
|
}
|
|
}
|
|
x = x->level[0].forward;
|
|
|
|
// check if existed score
|
|
if (x && x->score == score) {
|
|
return temp_width;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// search skiplist by index. Return the node if exists, otherwise NULL
|
|
snode *skiplist_at(skiplist *list, int index)
|
|
{
|
|
snode *x = list->header;
|
|
for (int i = list->level; i >= 0; i--) {
|
|
while (x->level[i].forward) {
|
|
if (x->level[i].span == index) {
|
|
return x->level[i].forward;
|
|
}
|
|
if (x->level[i].span < index) {
|
|
index -= x->level[i].span;
|
|
x = x->level[i].forward;
|
|
}
|
|
else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void skiplist_node_free(snode *x)
|
|
{
|
|
if (x) {
|
|
ifree(x);
|
|
}
|
|
}
|
|
|
|
// delete by score,node. Return 0 if success, 1 if fail.
|
|
int skiplist_delete(skiplist *list, int score, vtype value)
|
|
{
|
|
int i;
|
|
snode **update = (snode **)imalloc(sizeof(snode*) * (list->level + 1));
|
|
snode *x = list->header;
|
|
|
|
// find every level before the specified node
|
|
for (i = list->level; i >= 0; --i) {
|
|
while (1) {
|
|
if (!(x->level[i].forward) || x->level[i].forward->score > score) {
|
|
update[i] = x;
|
|
break;
|
|
}
|
|
|
|
if (x->level[i].forward->score < score) {
|
|
x = x->level[i].forward;
|
|
continue;
|
|
}
|
|
|
|
// find the first node with same score
|
|
int j;
|
|
update[i] = x;
|
|
for (j = i-1; j >= 0; --j) {
|
|
while (x->level[j].forward->score < score)
|
|
x = x->level[j].forward;
|
|
|
|
update[j] = x;
|
|
}
|
|
x = x->level[0].forward;
|
|
snode *x_start_search = x;
|
|
|
|
// find the first node with same score and node
|
|
while (x && x->value != value && x->score == score) {
|
|
x = x->level[0].forward;
|
|
}
|
|
if (x && x->score == score) {
|
|
// now x is the node to find
|
|
// find nodes for every level before the node to find
|
|
if (x == x_start_search) {
|
|
// done
|
|
i = 0;
|
|
break;
|
|
}
|
|
|
|
// j is used to judge if change the x_start_search
|
|
j = 0;
|
|
snode *iter;
|
|
for (; i >= 0; --i)
|
|
{
|
|
if (j) {
|
|
update[i] = x_start_search;
|
|
iter = x_start_search->level[0].forward;
|
|
} else{
|
|
iter = x_start_search;
|
|
}
|
|
|
|
while (iter != x) {
|
|
if (iter == update[i]->level[i].forward) {
|
|
j = 1;
|
|
x_start_search = iter;
|
|
iter = iter->level[0].forward;
|
|
update[i] = update[i]->level[i].forward;
|
|
continue;
|
|
}
|
|
|
|
iter = iter->level[0].forward;
|
|
}
|
|
}
|
|
i = 0;
|
|
break;
|
|
}
|
|
else {
|
|
// not found the node
|
|
ifree(update);
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (x->score != score) {
|
|
// not found the node
|
|
ifree(update);
|
|
return 1;
|
|
}
|
|
|
|
for (i = 0; i <= list->level && update[i]->level[i].forward == x; i++) {
|
|
update[i]->level[i].forward = x->level[i].forward;
|
|
update[i]->level[i].span += x->level[i].span - 1;
|
|
}
|
|
for (; i <= list->level; i++) {
|
|
--(update[i]->level[i].span);
|
|
}
|
|
skiplist_node_free(x);
|
|
|
|
while (list->level > 0 && list->header->level[list->level].forward == NULL)
|
|
list->level--;
|
|
list->size--;
|
|
|
|
ifree(update);
|
|
return 0;
|
|
}
|
|
|
|
// ifree the skiplist
|
|
void skiplist_free(skiplist *list)
|
|
{
|
|
snode *current_node = list->header->level[0].forward;
|
|
while(current_node != NULL) {
|
|
snode *next_node = current_node->level[0].forward;
|
|
skiplist_node_free(current_node);
|
|
current_node = next_node;
|
|
}
|
|
ifree(list);
|
|
}
|
|
|
|
// print the skip list, just for test.
|
|
static void skiplist_dump(skiplist *list)
|
|
{
|
|
int *width = (int *)imalloc(sizeof(int) * (list->level + 1) * list->size);
|
|
memset(width, 0, sizeof(int) * (list->level + 1) * list->size);
|
|
snode **tempn = (snode **)imalloc(sizeof(snode*) * (list->level + 1));
|
|
int i = 0, j;
|
|
snode *x = list->header->level[0].forward;
|
|
|
|
for (j = 0; j <= list->level; ++j) {
|
|
tempn[j] = list->header->level[j].forward;
|
|
}
|
|
|
|
while (tempn[0] != NULL) {
|
|
for (j = 1; j <= list->level; ++j) {
|
|
if (tempn[j] == tempn[0]) {
|
|
width[list->size * j + i] = tempn[j]->level[j].span;
|
|
tempn[j] = tempn[j]->level[j].forward;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
tempn[0] = tempn[0]->level[0].forward;
|
|
++i;
|
|
}
|
|
|
|
for (j = list->level; j > 0; --j) {
|
|
for (i = 0; i < list->size; ++i) {
|
|
if (width[j * list->size + i] == 0)
|
|
printf(" ");
|
|
else
|
|
printf("%d ", width[j * list->size + i]);
|
|
}
|
|
printf("\n");
|
|
}
|
|
while (x != NULL) {
|
|
printf("%d:%d->", x->score, x->value);
|
|
x = x->level[0].forward;
|
|
}
|
|
printf("NIL\n");
|
|
|
|
ifree(width);
|
|
ifree(tempn);
|
|
}
|
|
|
|
void test_skiplist(void) {
|
|
time_t t;
|
|
srand((unsigned)(time(&t)));
|
|
|
|
int arr[][2] = { {3, 1}, {3,2}, {6,6}, {9,9}, {3, 3}, {1, 1}, {4, 4}, {8, 8}, {7, 7}, {5,5}}, i;
|
|
// int arr[] = { 3, 6, 9}, i;
|
|
skiplist_search_ret tempx;
|
|
|
|
skiplist *list = skiplist_init();
|
|
|
|
printf("search empty:--------------------\n");
|
|
skiplist_search(list, 5, &tempx);
|
|
if (tempx.index > 0) {
|
|
printf("error, found not existed item!\n");
|
|
}
|
|
|
|
printf("delete empty:--------------------\n");
|
|
skiplist_delete(list, 5, 2);
|
|
|
|
printf("Insert:--------------------\n");
|
|
for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) {
|
|
skiplist_insert(list, arr[i][0], arr[i][1]);
|
|
}
|
|
skiplist_dump(list);
|
|
|
|
printf("search empty:--------------------\n");
|
|
skiplist_search(list, 5, &tempx);
|
|
printf("index = %d\n", tempx.index);
|
|
|
|
printf("Search by index:-----------\n");
|
|
int indexes[] = { 11, 3, 10 };
|
|
|
|
for (i = 0; i < sizeof(indexes) / sizeof(indexes[0]); i++) {
|
|
snode *tempnode = skiplist_at(list, indexes[i]);
|
|
if (tempnode) {
|
|
printf("index = %d, score = %d, value = %d\n", indexes[i], tempnode->score, tempnode->value);
|
|
} else {
|
|
printf("no index = %d\n", indexes[i]);
|
|
}
|
|
}
|
|
|
|
printf("Delete:--------------------\n");
|
|
skiplist_delete(list, 3, 2);
|
|
skiplist_delete(list, 3, 1);
|
|
skiplist_delete(list, 6, 6);
|
|
skiplist_dump(list);
|
|
|
|
clock_t start, finish;
|
|
start = clock();
|
|
for (i = 0; i < 30*1000; ++i) {
|
|
if (rand() < RAND_MAX / 5 * 3) {
|
|
skiplist_insert(list, RAND_UNIFORM(100), RAND_UNIFORM(20));
|
|
}
|
|
else {
|
|
skiplist_delete(list, RAND_UNIFORM(100), RAND_UNIFORM(20));
|
|
}
|
|
}
|
|
finish = clock();
|
|
double duration = (double)(finish - start) / CLOCKS_PER_SEC;
|
|
printf( "%f seconds\n", duration );
|
|
|
|
printf("Search:--------------------\n");
|
|
int keys[] = { 0, 3, 7, 100, 11 };
|
|
|
|
for (i = 0; i < sizeof(keys) / sizeof(keys[0]); i++) {
|
|
printf("index = %d, score = %d\n", skiplist_index_of_score(list, keys[i]), keys[i]);
|
|
}
|
|
|
|
skiplist_free(list);
|
|
};
|