redis源码阅读-数据结构篇-跳表

@

目录

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;				// 没找到目标节点
}
posted @ 2021-06-09 23:17  Jamgun  阅读(71)  评论(0)  编辑  收藏  举报