rediszset跳表 redis 跳表实现

转载

mob64ca140f67e3 2024-04-18 10:38:29

文章标签 rediszset跳表数据结构 redis 跳跃表构造函数 文章分类 Redis 数据库

文章目录

4. 跳表实现 redis.h 和 t_zset.c

数据结构定义
Helper函数（可跳过，需要时阅读）
node 构造函数 O(1)
构造函数 O(1)
node 析构函数 O(1)
析构函数 O(n)
insert object O(logn)
delete object O(logn)
根据score，范围删除 O(logn)
根据rank，范围删除 O(logn)
获取 rank O(logn)
get by rank O(logn)

4. 跳表实现 redis.h 和 t_zset.c

数据结构定义

object

// 包含 meta 和 数据 指针
#define REDIS_LRU_BITS 24
typedef struct redisObject {
    unsigned type:4;				// 类型
    unsigned encoding:4;  			// 编码
    unsigned lru:REDIS_LRU_BITS; 	// 对象最后一次被访问的时间
    int refcount;					// 引用计数
    void *ptr;						// 指向实际值的指针
} robj;

跳表节点 value 为 object*

typedef struct zskiplistNode {
    robj *obj; 							// 成员对象
    double score; 						// 分值
    struct zskiplistNode *backward;		// 后退指针
    struct zskiplistLevel {
        struct zskiplistNode *forward; 	// 前进指针
        unsigned int span;				// 跨度
    } level[]; 							// 层
} zskiplistNode;

跳表

// meta 和 首尾指针
typedef struct zskiplist {
    struct zskiplistNode *header, *tail;	// 表头节点和表尾节点
    unsigned long length;					// 表中节点的数量
    int level;								// 表中层数最大的节点的层数
} zskiplist;

Helper函数（可跳过，需要时阅读）

生成随机层数 O(1)

// 介于 1 - ZSKIPLIST_MAXLEVEL
// 层数越大，生成概率越小
int zslRandomLevel(void) {
    int level = 1;
    while ((random()&0xFFFF) < (ZSKIPLIST_P * 0xFFFF))
        level += 1;
    return (level<ZSKIPLIST_MAXLEVEL) ? level : ZSKIPLIST_MAXLEVEL;
}

范围判断O(1)

// 数据结构
// 开区间/闭区间范围
typedef struct {
    // 最小值和最大值
    double min, max;
    // 指示最小值和最大值是否*不*包含在范围之内
    // 值为 1 表示不包含，值为 0 表示包含
    int minex, maxex; 
} zrangespec;

// 大于等于最小值
static int zslValueGteMin(double value, zrangespec *spec) {
    return spec->minex ? (value > spec->min) : (value >= spec->min);
}
// 小于等于最大值
static int zslValueLteMax(double value, zrangespec *spec) {
    return spec->maxex ? (value < spec->max) : (value <= spec->max);
}

// 此处往下的范围函数，只展示其一
typedef struct {
    robj *min, *max;  
    int minex, maxex; 
} zlexrangespec;

static int zslLexValueGteMin(robj *value, zlexrangespec *spec) {
    return spec->minex ?
        (compareStringObjectsForLexRange(value,spec->min) > 0) :
        (compareStringObjectsForLexRange(value,spec->min) >= 0);
}

static int zslLexValueLteMax(robj *value, zlexrangespec *spec) {
    return spec->maxex ?
        (compareStringObjectsForLexRange(value,spec->max) < 0) :
        (compareStringObjectsForLexRange(value,spec->max) <= 0);
}

list 和范围是否有交集 O(1)

// 全list score 范围判断，是否有交集
int zslIsInRange(zskiplist *zsl, zrangespec *range) {
    zskiplistNode *x;
    // 先排除总为空的范围值
    if (range->min > range->max ||
            (range->min == range->max && (range->minex || range->maxex)))
        return 0;
    // list 按照 score 升序排序
    // 检查最大分值
    x = zsl->tail;
    if (x == NULL || !zslValueGteMin(x->score,range))
        return 0;
    // 检查最小分值
    x = zsl->header->level[0].forward;
    if (x == NULL || !zslValueLteMax(x->score,range))
        return 0;
    return 1;
}

第一个范围内的 node O(logn)

zskiplistNode *zslFirstInRange(zskiplist *zsl, zrangespec *range) {
    zskiplistNode *x;
    int i;
    if (!zslIsInRange(zsl,range)) return NULL;
    // 遍历跳跃表，查找符合范围 min 项的节点 T_wrost = O(N), T_avg = O(log N)
    x = zsl->header;
    for (i = zsl->level-1; i >= 0; i--) {
        while (x->level[i].forward &&
            !zslValueGteMin(x->level[i].forward->score,range))
                x = x->level[i].forward;
    }
    x = x->level[0].forward;
    redisAssert(x != NULL);
    // 检查节点是否符合范围的 max 项
    if (!zslValueLteMax(x->score,range)) return NULL;
    return x;
}

最后一个范围内的 node O(logn)

zskiplistNode *zslLastInRange(zskiplist *zsl, zrangespec *range) {
    zskiplistNode *x;
    int i;
    // 确保跳跃表中至少有一个节点符合 range 指定的范围，
    if (!zslIsInRange(zsl,range)) return NULL;

    // 遍历跳跃表，查找符合范围 max 项的节点 T_wrost = O(N), T_avg = O(log N)
    x = zsl->header;
    for (i = zsl->level-1; i >= 0; i--) {
        /* Go forward while *IN* range. */
        while (x->level[i].forward &&
            zslValueLteMax(x->level[i].forward->score,range))
                x = x->level[i].forward;
    }
    redisAssert(x != NULL);
    // 检查节点是否符合范围的 min 项
    if (!zslValueGteMin(x->score,range)) return NULL;
    return x;
}

node 构造函数 O(1)

// 分配 skiplist node的内存，设置 meta
zskiplistNode *zslCreateNode(int level, double score, robj *obj) {
    zskiplistNode *zn = zmalloc(sizeof(*zn)+level*sizeof(struct zskiplistLevel));  // 分配空间
    zn->score = score;	// 设置属性
    zn->obj = obj;
    return zn;
}

构造函数 O(1)

zskiplist *zslCreate(void) {
    int j;
    zskiplist *zsl;
    zsl = zmalloc(sizeof(*zsl));	// 分配空间
    zsl->level = 1; 				// 设置高度和起始层数
    zsl->length = 0;
    zsl->header = zslCreateNode(ZSKIPLIST_MAXLEVEL,0,NULL); // 初始化表头节点，具有最大level，辅助节点不设值
    for (j = 0; j < ZSKIPLIST_MAXLEVEL; j++) {
        zsl->header->level[j].forward = NULL;
        zsl->header->level[j].span = 0;
    }
    zsl->header->backward = NULL;	// 初始无值
    zsl->tail = NULL;				// 表尾初始为 NULL
    return zsl;
}

node 析构函数 O(1)

不负责 object 的析构，只减少引用计数

void zslFreeNode(zskiplistNode *node) {
    decrRefCount(node->obj);
    zfree(node);
}

析构函数 O(n)

只负责本身和所有 node 的析构

不负责 object 的析构，只减少引用计数

void zslFree(zskiplist *zsl) {
    // level 0 可遍历所有节点
    zskiplistNode *node = zsl->header->level[0].forward, *next;
    zfree(zsl->header);		// 释放表头
    while(node) { 			// 释放表中所有节点
        next = node->level[0].forward;
        zslFreeNode(node);
        node = next;
    }
    zfree(zsl);				// 释放跳跃表结构
}

insert object O(logn)

zskiplistNode *zslInsert(zskiplist *zsl, double score, robj *obj) {
   	zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
    unsigned int rank[ZSKIPLIST_MAXLEVEL];
    int i, level;
    x = zsl->header;	// 在各个层查找节点的插入位置 T_wrost = O(N), T_avg = O(log N)
    for (i = zsl->level-1; i >= 0; i--) {
        // 如果 i 不是 zsl->level-1 层
        // 那么 i 层的起始 rank 值为 i+1 层的 rank 值
        // 各个层的 rank 值一层层累积
        // 最终 rank[0] 的值加一就是新节点的前置节点的排位
        // rank[0] 会在后面成为计算 span 值和 rank 值的基础
        rank[i] = i == (zsl->level-1) ? 0 : rank[i+1];
        // 沿着前进指针遍历跳跃表, T_wrost = O(N^2), T_avg = O(N log N)
        while (x->level[i].forward && 					// 非空
            (x->level[i].forward->score < score ||		// score 大 或者
                (x->level[i].forward->score == score && // score 相等 并且 obj 大
                compareStringObjects(x->level[i].forward->obj,obj) < 0))) {
            rank[i] += x->level[i].span; 				// 记录沿途跨越了多少个节点
            x = x->level[i].forward;  					// 移动至下一指针
        }												// 直到 x 的 score 大 或者 obj 大
        update[i] = x; 	// 记录将要和新节点相连接的节点
    }
    level = zslRandomLevel();   // 获取一个随机值作为新节点的层数
    if (level > zsl->level) {	// 出现新level，注意初始level为1
        for (i = zsl->level; i < level; i++) {// 初始化未使用层
            rank[i] = 0;
            update[i] = zsl->header;
            update[i]->level[i].span = zsl->length;
        }
        zsl->level = level;	// 更新表中节点最大层数
    }
    x = zslCreateNode(level,score,obj); // 创建新节点
    for (i = 0; i < level; i++) {		// 将前面记录的指针指向新节点，并做相应的设置
        x->level[i].forward = update[i]->level[i].forward;// 设置新节点的 forward 指针
        update[i]->level[i].forward = x;// 将沿途记录的各个节点的 forward 指针指向新节点
        x->level[i].span = update[i]->level[i].span - (rank[0] - rank[i]);// 计算新节点跨越的节点数量
        update[i]->level[i].span = (rank[0] - rank[i]) + 1;// 更新新节点插入之后，沿途节点的 span 值
    }
    for (i = level; i < zsl->level; i++) {// 未接触的节点的 span 值也需要增一，这些节点直接从表头指向新节点
        update[i]->level[i].span++;
    }
    x->backward = (update[0] == zsl->header) ? NULL : update[0];// 设置新节点的后退指针
    if (x->level[0].forward)
        x->level[0].forward->backward = x;
    else
        zsl->tail = x;
    zsl->length++;	// 跳跃表的节点计数增一
    return x;
}

delete object O(logn)

// O（1）
// 确定的node，带有 insert 时相同的 update数组，仅删除链表结构，不涉及内存
void zslDeleteNode(zskiplist *zsl, zskiplistNode *x, zskiplistNode **update) {
    int i;
    for (i = 0; i < zsl->level; i++) {  // 更新所有和被删除节点 x 有关的节点的指针，解除它们之间的关系
        if (update[i]->level[i].forward == x) {
            update[i]->level[i].span += x->level[i].span - 1;
            update[i]->level[i].forward = x->level[i].forward;
        } else {
            update[i]->level[i].span -= 1;
        }
    }
    if (x->level[0].forward) {// 更新被删除节点 x 的前进和后退指针
        x->level[0].forward->backward = x->backward;
    } else {
        zsl->tail = x->backward;
    }
    // 更新跳跃表最大层数（只在被删除节点是跳跃表中最高的节点时才执行）
    while(zsl->level > 1 && zsl->header->level[zsl->level-1].forward == NULL)
        zsl->level--;
    // 跳跃表节点计数器减一
    zsl->length--;
}

// 寻找并删除带有 score 的 obj，释放 node 内存
int zslDelete(zskiplist *zsl, double score, robj *obj) {
    zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
    int i;
    // 遍历跳跃表，查找目标节点，并记录所有沿途节点， T_wrost = O(N), T_avg = O(log N)
    x = zsl->header;
    for (i = zsl->level-1; i >= 0; i--) {
        while (x->level[i].forward &&
            (x->level[i].forward->score < score || 		 // 比对分值
                (x->level[i].forward->score == score &&	  // 比对对象
                compareStringObjects(x->level[i].forward->obj,obj) < 0)))
            x = x->level[i].forward;												// 比较继续
        update[i] = x;	// 此节点小于目标节点
    }
    //检查找到的元素 x ，只有在它的分值和对象都相同时，才将它删除。
    x = x->level[0].forward;
    if (x && score == x->score && equalStringObjects(x->obj,obj)) {
        zslDeleteNode(zsl, x, update);
        zslFreeNode(x);
        return 1;
    } else {
        return 0; 
    }
    return 0; 
}

根据score，范围删除 O(logn)

unsigned long zslDeleteRangeByScore(zskiplist *zsl, zrangespec *range, dict *dict){
    zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
    unsigned long removed = 0;
    int i;
    // 记录所有和被删除节点（们）有关的节点 T_wrost = O(N) , T_avg = O(log N)
    x = zsl->header;
    for (i = zsl->level-1; i >= 0; i--) {
        while (x->level[i].forward && (range->minex ?
            x->level[i].forward->score <= range->min :
            x->level[i].forward->score < range->min))
                x = x->level[i].forward;
        update[i] = x;
    }
    x = x->level[0].forward; // 定位到给定范围开始的第一个节点
    while (x && 			// 删除范围中的所有节点
           (range->maxex ? x->score < range->max : x->score <= range->max)){
        // 记录下个节点的指针
        zskiplistNode *next = x->level[0].forward;
        zslDeleteNode(zsl,x,update);
        dictDelete(dict,x->obj);
        zslFreeNode(x);
        removed++;
        x = next;
    }
    return removed;
}

根据rank，范围删除 O(logn)

unsigned long zslDeleteRangeByRank(zskiplist *zsl, unsigned int start, unsigned int end, dict *dict) {
    zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
    unsigned long traversed = 0, removed = 0;
    int i;
    // 找到start，并记录所有沿途指针 T_wrost = O(N) , T_avg = O(log N)
    x = zsl->header;
    for (i = zsl->level-1; i >= 0; i--) {
        while (x->level[i].forward && (traversed + x->level[i].span) < start) {
            traversed += x->level[i].span;
            x = x->level[i].forward;
        }
        update[i] = x;
    }
    traversed++; 						// 移动到排位的起始的第一个节点
    x = x->level[0].forward;
    while (x && traversed <= end) {		// 删除所有在给定排位范围内的节点
        zskiplistNode *next = x->level[0].forward;// 记录下一节点的指针
        zslDeleteNode(zsl,x,update);	// 从跳跃表中删除节点
        dictDelete(dict,x->obj);     	// 从字典中删除节点
        zslFreeNode(x);					// 释放节点结构
        removed++;						// 为删除计数器增一
        traversed++;					// 为排位计数器增一
        x = next;						// 处理下个节点
    }
    return removed;						// 返回被删除节点的数量
}

获取 rank O(logn)

unsigned long zslGetRank(zskiplist *zsl, double score, robj *o) {
    zskiplistNode *x;
    unsigned long rank = 0;
    int i;
    x = zsl->header;
    for (i = zsl->level-1; i >= 0; i--) { 			// 遍历整个跳跃表
        while (x->level[i].forward &&				// 遍历节点并对比元素
            (x->level[i].forward->score < score || 	// 比对分值
                (x->level[i].forward->score == score &&// 比对成员对象
                compareStringObjects(x->level[i].forward->obj,o) <= 0))) {
            rank += x->level[i].span; 				// 累积跨越的节点数量
            x = x->level[i].forward;				// 沿着前进指针遍历跳跃表
        }
        if (x->obj && equalStringObjects(x->obj,o)) {// 确认是否 equal，否则继续
            return rank;
        }
    }
    return 0;
}

get by rank O(logn)

zskiplistNode* zslGetElementByRank(zskiplist *zsl, unsigned long rank) {
    zskiplistNode *x;
    unsigned long traversed = 0;
    int i;
    x = zsl->header;
    for (i = zsl->level-1; i >= 0; i--) {
        while (x->level[i].forward // 遍历跳跃表并累积越过的节点数量
               && (traversed + x->level[i].span) <= rank){
            traversed += x->level[i].span;
            x = x->level[i].forward;
        }
        if (traversed == rank) {	// 找到节点
            return x;
        }
    }
    return NULL;				// 没找到目标节点
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。