Redis SortedSet实现原理

最新推荐文章于 2024-06-23 00:30:00 发布
最新推荐文章于 2024-06-23 00:30:00 发布
阅读量2.2w 收藏 15
点赞数 5
分类专栏： redis

Redis中支持的数据结构比Memcached要多的多啦，如基本的字符串、哈希表、列表、集合、可排序集，在这些基本数据结构上也提供了针对该数据结构的各种操作，这也是Redis之所以流行起来的一个重要原因,当然Redis能够流行起来的原因，远远不只这一个,如支持高并发的读写、数据的持久化、高效的内存管理及淘汰机制...

从Redis的git提交历史中，可以查到，2009/10/24在1.050版本，Redis开始支持可排序集,在该版本中，只提供了一条命令zadd,宏定义如下所示:

1     {"zadd",zaddCommand,4,REDIS_CMD_BULK|REDIS_CMD_DENYOOM},

那么什么是可排序集呢? 从Redis 1.0开始就给我们提供了集合(Set)这种数据结构，集合就跟数学上的集合概念是一个道理【无序性，确定性，互异性】,集合里的元素无法保证元素的顺序，而业务上的需求，可能不止是一个集合，而且还要求能够快速地对集合元素进行排序，于是乎，Redis中提供了可排序集这么一种数据结构，似乎也是合情合理,无非就是在集合的基础上增加了排序功能,也许有人会问，Redis中不是有Sort命令嘛，下面的操作不也是同样可以达到对无序集的排序功能嘛，是的,是可以，但是在这里我们一直强调的是快速这两个字，而Sort命令的时间复杂度为O(N+M*Log(M)),可排序集获取一定范围内元素的时间复杂度为O(log(N) + M)

复制代码 
root@bjpengpeng-VirtualBox:/home/bjpengpeng/redis-3.0.1/src# ./redis-cli 
127.0.0.1:6379> sort set
1) "1"
2) "2"
3) "3"
4) "5"
127.0.0.1:6379> sort set desc
1) "5"
2) "3"
3) "2"
4) "1"
127.0.0.1:6379>
复制代码

在了解可排序集是如何实现之前，需要了解一种数据结构跳表(Skip List),跳表与AVL、红黑树...等相比，数据结构简单，算法易懂，但查询的时间复杂度与平衡二叉树/红黑树相当,跳表的基本结构如下图所示

上图中整个跳表结构存放了4个元素5->10->20->30,图中的红色线表示查找元素30时，走的查找路线,从Head指针数组里最顶层的指针所指的20开始比较，与普通的链表查找相比，跳表的查询可以跳跃元素，上图中查询30，发现30比20大，则查找就是20开始，而普通链表的查询必须一个元素一个元素的比较，时间复杂度为O(n)

有了上图所示的跳表基本结构，再看看如何向跳表中插入元素，向跳表中插入元素，由于元素所在层级的随机性，平均起来也是O(logn)，说白了，就是查找元素应该插入在什么位置，然后就是普通的移动指针问题，再想想往有序单链表的插入操作吧，时间复杂度是不是也是O(n),下图所示是往跳表中插入元素28的过程,图中红色线表示查找插入位置的过程，绿色线表示进行指针的移动，将该元素插入

 

有了跳表的查找及插入那么就看看在跳表中如何删除元素吧，跳表中删除元素的个程，查找要删除的元素，找到后，进行指针的移动，过程如下图所示，删除元素30

有了上面的跳表基本结构图及原理，自已设计及实现跳表吧，这样当看到Redis里面的跳表结构时我们会更加熟悉，更容易理解些,【下面是对Redis中的跳表数据结构及相关代码进行精减后形成的可运行代码】,首先定义跳表的基本数据结构如下所示

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include<stdio.h>
#include<stdlib.h>
 
#define ZSKIPLIST_MAXLEVEL 32
#define ZSKIPLIST_P 0.25
#include <math.h>
 
//跳表节点
typedef  struct  zskiplistNode {
     int  key;
     int  value;
     struct  zskiplistLevel {
         struct  zskiplistNode *forward;
     } level[1];
} zskiplistNode;
 
//跳表
typedef  struct  zskiplist {
     struct  zskiplistNode *header;
     int  level;
} zskiplist;

 

在代码中我们定义了跳表结构中保存的数据为Key->Value这种形式的键值对，注意的是skiplistNode里面内含了一个结构体,代表的是层级，并且定义了跳表的最大层级为32级,下面的代码是创建空跳表，以及层级的获取方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
//创建跳表的节点
zskiplistNode *zslCreateNode( int  level,  int  key,  int  value) {
     zskiplistNode *zn = (zskiplistNode *) malloc ( sizeof (*zn)+level* sizeof (zn->level));
     zn->key = key;
     zn->value = value;
     return  zn;
}
 
//初始化跳表
zskiplist *zslCreate( void ) {
     int  j;
     zskiplist *zsl;
     zsl = (zskiplist *)  malloc ( sizeof (*zsl));
     zsl->level = 1; //将层级设置为1
     zsl->header = zslCreateNode(ZSKIPLIST_MAXLEVEL,NULL,NULL);
     for  (j = 0; j < ZSKIPLIST_MAXLEVEL; j++) {
         zsl->header->level[j].forward = NULL;
     }
     return  zsl;
}
 
//向跳表中插入元素时，随机一个层级，表示插入在哪一层
int  zslRandomLevel( void ) {
     int  level = 1;
     while  (( rand ()&0xFFFF) < (ZSKIPLIST_P * 0xFFFF))
         level += 1;
     return  (level<ZSKIPLIST_MAXLEVEL) ? level : ZSKIPLIST_MAXLEVEL;
}

在这段代码中，使用了随机函数获取过元素所在的层级，下面就是重点，向跳表中插入元素，插入元素之前先查找插入的位置,代码如下所示，代码中注意update[i]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
//向跳表中插入元素
zskiplistNode *zslInsert(zskiplist *zsl,  int  key,  int  value) {
     zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
     int  i, level;
     x = zsl->header;
     //在跳表中寻找合适的位置并插入元素
     for  (i = zsl->level-1; i >= 0; i--) {
         while  (x->level[i].forward &&
             (x->level[i].forward->key < key ||
                 (x->level[i].forward->key == key &&
                 x->level[i].forward->value < value))) {
             x = x->level[i].forward;
         }
         update[i] = x;
     }
     //获取元素所在的随机层数
     level = zslRandomLevel();
     if  (level > zsl->level) {
         for  (i = zsl->level; i < level; i++) {
             update[i] = zsl->header;
         }
         zsl->level = level;
     }
     //为新创建的元素创建数据节点
     x = zslCreateNode(level,key,value);
     for  (i = 0; i < level; i++) {
         x->level[i].forward = update[i]->level[i].forward;
         update[i]->level[i].forward = x;
     }
     return  x;
}

下面是代码中删除节点的操作，和插入节点类似

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
//跳表中删除节点的操作
void  zslDeleteNode(zskiplist *zsl, zskiplistNode *x, zskiplistNode **update) {
     int  i;
     for  (i = 0; i < zsl->level; i++) {
         if  (update[i]->level[i].forward == x) {
             update[i]->level[i].forward = x->level[i].forward;
         }
     }
     //如果层数变了，相应的将层数进行减1操作
     while (zsl->level > 1 && zsl->header->level[zsl->level-1].forward == NULL)
         zsl->level--;
}
 
//从跳表中删除元素
int  zslDelete(zskiplist *zsl,  int  key,  int  value) {
     zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
     int  i;
     x = zsl->header;
     //寻找待删除元素
     for  (i = zsl->level-1; i >= 0; i--) {
         while  (x->level[i].forward &&
             (x->level[i].forward->key < key ||
                 (x->level[i].forward->key == key &&
                 x->level[i].forward->value < value))) {
             x = x->level[i].forward;
         }
         update[i] = x;
     }
     x = x->level[0].forward;
     if  (x && key == x->key && x->value == value) {
         zslDeleteNode(zsl, x, update);
         //别忘了释放节点所占用的存储空间
         free (x);
         return  1;
     }  else  {
         //未找到相应的元素
         return  0;
     }
     return  0;
}

最后，附上一个不优雅的测试样例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//将链表中的元素打印出来
void  printZslList(zskiplist *zsl) {
     zskiplistNode  *x;
     x = zsl->header;
     for  ( int  i = zsl->level-1; i >= 0; i--) {
         zskiplistNode *p = x->level[i].forward;
         while  (p) {
             printf ( " %d|%d " ,p->key,p->value);
             p = p->level[i].forward;
         }
         printf ( "\n" );
     }
}
 
int  main() {
     zskiplist *list = zslCreate();
     zslInsert(list,1,2);
     zslInsert(list,4,5);
     zslInsert(list,2,2);
     zslInsert(list,7,2);
     zslInsert(list,7,3);
     zslInsert(list,7,3);
     printZslList(list);
     //zslDelete(list,7,2);
     printZslList(list);
}

有了上面的跳表理论基础，理解Redis中跳表的实现就不是那么难了，先分析到这，下回续写，【代码以Redis 2.9为例】~


转自：http://www.cnblogs.com/WJ5888/p/4516782.html

linyu19872008
关注
  • 5
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Redis高级玩法之利用SortedSet实现多维度排序的方法
09-09
Redis的SortedSet是可以根据score进行排序的，以手机应用商店的热门榜单排序为例，根据下载量倒序排列。接下来通过本文给大家分享Redis高级玩法之利用SortedSet实现多维度排序的方法，一起看看吧
[转]Redis有序集内部实现原理分析
tpriwwq的专栏
08-12 1034
原文地址：  http://www.cnblogs.com/WJ5888/p/4516782.html Redis中支持的数据结构比Memcached要多的多啦，如基本的字符串、哈希表、列表、集合、可排序集，在这些基本数据结构上也提供了针对该数据结构的各种操作，这也是Redis之所以流行起来的一个重要原因,当然Redis能够流行起来的原因，远远不只这一个,如支持高并发的读写、数据的持久化
Redis—SortedSet数据类型及其常用命令详解
最新发布
喻师傅的学习笔记
06-23 907
Redis--SortedSet数据类型及其常用命令详解
(7)Redis有序集合跳表实现原理
大表哥的博客
09-22 1820
数据结构&算法模块总结 (1)复杂度分析原理与方法 (2)数组与链表原理和使用场景讲解 (3)栈原理与应用场景讲解 (4)队列原理与应用场景讲解 (5)递归原理与虚拟机栈场景应用 (6)二分查找及其应用场景 1.跳表与链表 ①原始链表查找效率为O(N) ②跳表优化思路：每隔两个或两个以上节点时，提取一个节点到上一级，抽取出来的一级称为索引或索引层。down指针，可以指向下一级结点。 这种链表加多级索引的结构，就是跳表。 例如要查找节点16，可以现在...
redis 数据类型及有序集合实现原理图
varfun
01-12 398
数据类型 字符串（strings） 1.1 类型介绍 字符串是 Redis最简单的储存类型,它存储的值可以是字符串、整数或者浮点数,对整个字符串或者字符串的其中一部分执行操作;对整数或者浮点数执行自增( Increment)或者自减( decrement)操作 Redis的字符串是一个由字节组成的序列,跟java里面的 ArrayList有点类似,采用预分配冗余空间的方式来减少内存的频繁分内部为当前字符串实际分配的空间 capacity-般要高于实际字符串长度len。当字符串长度小于1M时,扩容都是加倍 现
redis学习笔记-sorted set原理
万彬学习的博客
03-21 1740
zset 基本使用 我们先来看一下 zset 都有哪些操作： 序号 命令及描述 1 ZADD key score1 member1 [score2 member2] 向有序集合添加一个或多个成员，或者更新已存在成员的分数 2 ZCARD key 获取有序集合的成员数 3 ZCOUNT key min max 计算在有序集合中指定区间分数的成员数 4 ZINCRBY key increment member 有序集合中对指定成员的分数加上增量 increment 5 ZINTE
redis的sorted set实现延时队列
06-03
Redis 是一个高性能的键值数据库，它...以上就是使用 Redis 的有序集合实现延时队列的基本原理和操作流程。实际应用中，根据业务需求，可能还需要对这个基本模型进行扩展和优化，以满足性能、可用性和可扩展性的要求。
Node.js + Redis Sorted Set实现任务队列
10-21
本文给大家分享的是使用Node.js + Redis Sorted Set实现任务队列的方法示例，非常的实用，有需要的小伙伴可以参考下
Redis面试知识点.pdf
04-20
#### 15、是否使用过Redis集群，集群的原理是什么？ Redis集群是一种分布式的部署方案，通过分区（sharding）和复制（replication）机制实现数据的水平扩展和高可用性。每个节点负责一部分数据，客户端请求会被...
Redis之基本数据结构
01-20
相当于LinkedList队列-右边进左边出栈-右边进右边出ltrim截取hash字典-相当于hashmapset集合-相当于hashSetzset有序集合-相当于sortedSet容器型数据结构通用规则 如果不能深入地了解系统，技术和框架背后的深层原理...
Redis
03-17
- 教学示例：在教学环境中，Redis可以用来展示数据操作，帮助学生理解数据库原理。 3. **Redis命令**： - `SET key value`：设置键值对。 - `GET key`：获取键对应的值。 - `HSET key field value`：在哈希表中...
Redis有序集合类型(SortedSet)常用命令演示和实践练习代码
06-23
在JAVA中使用Redis有序集合类型的常用命令的演示及一个简单的实战项目: 具备增删改查和分类查找及按浏览量排序的商品管理功能
Redis Sorted Sets的基本操作，实现原理和应用举例
hqw11的博客
07-27 901
Redis Sorted Sets 基本命令操作 zadd key score member zrem key member --删除指定元素 zincrby key incr member --增加incr幅度 zrank key member --小到大，下标0开始？ zrevrank key member --大到小，下标0开始？ zrange key start ...
Redis Sorted Set 底层实现原理深度解读与排行榜实战
m0_71777195的博客
07-17 225
span 用于计算元素排名(rank)，例如查找 ele = 肖菜鸡、score = 17 的排名，只需要把查找路径经过的节点的 span 相加即可，如下图的红色路径的 span 累加，按照上面的生成链表方式，每次往上增加一层链表的节点个数是下面一层的一半，这样的查找过程就类似于一个二分查找，时间复杂度为 O(log n)。但是，这种方式在插入数据的时候有很大的问题，每次新增一个节点，就会打乱相邻的两层链表节点个数 2:1 的关系，如果要维持这个关系，就需要对链表调整，事件复杂度是 O(n)。
Redis有序集合SortedSet实现原理
甲小蛙战记
03-22 2457
实现原理
redis命令详解与使用场景举例——SortedSet(有序集合)
路漫漫，水迢迢
04-24 4662
ZADD key score member [[score member] [score member] …]将一个或多个 member 元素及其 score 值加入到有序集 key 当中。 如果某个 member 已经是有序集的成员，那么更新这个 member 的 score 值，并通过重新插入这个 member 元素，来保证该 member 在正确的位置上。 score 值可以是整数值或双精
Redis数据结构SortedSet底层原理详解
博客
10-31 3721
概述 一些常用命令： 存储：zadd key score value 获取：zrange key start end 获取：同时获取分数：zrange key start end with score 删除：zrem key value 存储的时候我们可以发现，是有一个score（分数）的，这个就是用来排序的字段。 实现 先说结论，SortedSet底层，根据配置会在不同的时候选用两种不同的数据结构zset，或ziplist进行存储： 首先，我们来看几个参数： zset-max-ziplist-entrie
Redis字符串和sorted set实现原理
m0_56033865的博客
02-14 808
字符串 是Redis中最为常见的数据存储类型，其底层实现是简单动态字符串sds(simple dynamic string)，是可以修改的字符串。 它采用预分配冗余空间的方式来减少内存的频繁分配。 当字符串长度小于 1M 时，扩容都是加倍现有的空间，如果超过 1M，扩容时一次只会多扩 1M 的空间。(字符串最大长度为 512M) 因此当超过512M时会报错 每个sds.h/sdshdr结构表示一个SDS的值 struct sdshdr{ //记录buf数组中已使用的字节的数量 //等于sds所保存字符
redis的数据结构——存储sortedset
玉爷的博客
04-16 432
Sorted-Sets和Sets类型极为相似，它们都是字符串的集合，都不允许重复的成员出 现在一个Set中。它们之间的主要差别是Sorted-Sets中的每一个成员都会有一个分 数(score)与之关联，Redis正是通过分数来为集合中的成员进行从小到大的排序。然 而需要额外指出的是，尽管Sorted-Sets中的成员必须是唯一的，但是分数(score) 却是可以重复的。 在Sorted-Set...
Redis底层详解：协议、数据结构与性能优化
客户端可以通过自定义逻辑实现数据分片（Sharding），通过RedisObject (Redis.h)这一基础数据结构来管理键值对。 Redis的核心命令包括基本的获取（GET）、设置（SET）、存在检查（EXISTS）、仅当不存在时设置...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值