客服电话
APP下载
迪恩网络APP
随时随地掌握行业动态
官方微信
扫描二维码
关注迪恩网络微信公众号
一、简介Redis中所有的的数据结构都是通过一个唯一的字符串key来获取相应的value数据。
其中list、set、hash、zset这四种数据结构是容器型数据结构，它们共享下面两条通用规则：
本文将详细讲述的是Redis的5种基础数据结构。 二、string（字符串）1、string(字符串)相关介绍1.1 string(字符串)的内部结构string(字符串)是Redis最简单也是使用最广泛的数据结构，它的内部是一个字符数组。如图所示： Redis中 1.2 string(字符串)的扩容当string(字符串)的大小达到扩容阈值时，将会对
2、string(字符串)的指令2.1 单个键值对增删改查操作set -> key 不存在则新增，存在则修改
get -> 查询，返回对应key的value，不存在返回(nil)
del -> 删除指定的key(key可以是多个)
示例： 1127.0.0.1:6379> set name liziba 2OK 3127.0.0.1:6379> get name 4"liziba" 5127.0.0.1:6379> set name liziba001 6OK 7127.0.0.1:6379> get name 8"liziba001" 9127.0.0.1:6379> del name 10(integer) 1 11127.0.0.1:6379> get name 12(nil) 2.2 批量键值对批量键值读取和写入最大的优势在于节省网络传输开销 mset -> 批量插入
mget -> 批量获取
示例： 1127.0.0.1:6379> mset name1 liziba1 name2 liziba2 name3 liziba3 2OK 3127.0.0.1:6379> mget name1 name2 name3 41) "liziba1" 52) "liziba2" 63) "liziba3" 2.3 过期set命令过期set是通过设置一个缓存key的过期时间，使得缓存到期后自动删除从而失效的机制。
示例： 1127.0.0.1:6379> set name liziba 2OK 3127.0.0.1:6379> get name 4"liziba" 5127.0.0.1:6379> expire name 10 # 10s 后get name 返回 nil 6(integer) 1 7127.0.0.1:6379> get name 8(nil) 方式二：
示例： 1127.0.0.1:6379> setex name 10 liziba # 10s 后get name 返回 nil 2OK 3127.0.0.1:6379> get name 4(nil) 2.4 不存在创建存在不更新上面的set操作不存在创建，存在则更新；此时如果需要存在不更新的场景，那么可以使用如下这个指令
示例： 1127.0.0.1:6379> get name 2(nil) 3127.0.0.1:6379> setnx name liziba 4(integer) 1 5127.0.0.1:6379> get name 6"liziba" 7127.0.0.1:6379> setnx name liziba_98 # 已经存在再次设值，失败 8(integer) 0 9127.0.0.1:6379> get name 10"liziba" 2.5计数string(字符串)也可以用来计数，前提是value是一个整数，那么可以对它进行自增的操作。自增的范围必须在signed long的区间访问内，[-9223372036854775808,9223372036854775808] incr -> 自增1
示例： 1127.0.0.1:6379> set fans 1000 2OK 3127.0.0.1:6379> incr fans # 自增1 4(integer) 1001 incrby -> 自定义累加值 1127.0.0.1:6379> set fans 1000 2OK 3127.0.0.1:6379> incr fans 4(integer) 1001 5127.0.0.1:6379> incrby fans 999 6(integer) 2000 测试value为整数的自增区间 最大值： 1127.0.0.1:6379> set fans 9223372036854775808 2OK 3127.0.0.1:6379> incr fans 4(error) ERR value is not an integer or out of range 最小值： 1127.0.0.1:6379> set money -9223372036854775808 2OK 3127.0.0.1:6379> incrby money -1 4(error) ERR increment or decrement would overflow 三、list（列表）1、list(列表)相关介绍1.1 list(列表)的内部结构Redis的列表相当于Java语言中的LinkedList，它是一个双向链表数据结构（但是这个结构设计比较巧妙，后面会介绍），支持前后顺序遍历。链表结构插入和删除操作快，时间复杂度O(1)，查询慢，时间复杂度O(n)。 1.2 list(列表)的使用场景根据Redis双向列表的特性，因此其也被用于异步队列的使用。实际开发中将需要延后处理的任务结构体序列化成字符串，放入Redis的队列中，另一个线程从这个列表中获取数据进行后续处理。其流程类似如下的图： 2、list(列表)的指令2.1 右进左出—队列队列在结构上是先进先出（FIFO）的数据结构（比如排队购票的顺序），常用于消息队列类似的功能，例如消息排队、异步处理等场景。通过它可以确保元素的访问顺序。
rpush -> 从右边添加元素
llen -> 获取列表的长度
lpop -> 从左边弹出元素
1127.0.0.1:6379> rpush code java c python # 向列表中添加元素 2(integer) 3 3127.0.0.1:6379> llen code # 获取列表长度 4(integer) 3 5127.0.0.1:6379> lpop code # 弹出最先添加的元素 6"java" 7127.0.0.1:6379> lpop code 8"c" 9127.0.0.1:6379> lpop code 10"python" 11127.0.0.1:6379> llen code 12(integer) 0 13127.0.0.1:6379> lpop code 14(nil) 2.2 右进右出——栈栈在结构上是先进后出（FILO）的数据结构（比如弹夹压入子弹，子弹被射击出去的顺序就是栈），这种数据结构一般用来逆序输出。
rpush -> 从右边添加元素
rpop -> 从右边弹出元素
1127.0.0.1:6379> rpush code java c python 2(integer) 3 3127.0.0.1:6379> rpop code # 弹出最后添加的元素 4"python" 5127.0.0.1:6379> rpop code 6"c" 7127.0.0.1:6379> rpop code 8"java" 9127.0.0.1:6379> rpop code 10(nil) 2.3 慢操作列表(list)是个链表数据结构，它的遍历是慢操作，所以涉及到遍历的性能将会遍历区间range的增大而增大。注意list的索引运行为负数，-1代表倒数第一个，-2代表倒数第二个，其它同理。
lrange -> 获取从索引start到stop处的全部值
ltrim -> 截取索引start到stop处的全部值，其它将会被删除
1127.0.0.1:6379> rpush code java c python 2(integer) 3 3127.0.0.1:6379> lindex code 0 # 获取索引为0的数据 4"java" 5127.0.0.1:6379> lindex code 1 # 获取索引为1的数据 6"c" 7127.0.0.1:6379> lindex code 2 # 获取索引为2的数据 8"python" 9127.0.0.1:6379> lrange code 0 -1 # 获取全部 0 到倒数第一个数据 == 获取全部数据 101) "java" 112) "c" 123) "python" 13127.0.0.1:6379> ltrim code 0 -1 # 截取并保理 0 到 -1 的数据 == 保理全部 14OK 15127.0.0.1:6379> lrange code 0 -1 161) "java" 172) "c" 183) "python" 19127.0.0.1:6379> ltrim code 1 -1 # 截取并保理 1 到 -1 的数据 == 移除了索引为0的数据 java 20OK 21127.0.0.1:6379> lrange code 0 -1 221) "c" 232) "python" 3、list(列表)深入理解Redis底层存储list(列表)不是一个简单的LinkedList，而是quicklist ——“快速列表”。关于quicklist是什么，下面会简单介绍，具体源码我也还在学习中，后面大家一起探讨。 3.1 常见的链表结构示意图每个node节点元素，都会持有一个prev->执行前一个node节点和next->指向后一个node节点的指针（引用），这种结构虽然支持前后顺序遍历，但是也带来了不小的内存开销，如果node节点仅仅是一个int类型的值，那么可想而知，引用的内存比例将会更大。 3.2 ziplist示意图ziplist是一块连续的内存地址，他们之间无需持有prev和next指针，能通过地址顺序寻址访问。 3.3 quicklist示意图quicklist是由多个ziplist组成的双向链表。 四、hash（字典）1、hash(字典)相关介绍1.1 hash(字典)的内部结构Redis的hash(字典)相当于Java语言中的HashMap，它是根据散列值分布的无序字典，内部的元素是通过键值对的方式存储。 hash(字典)的实现与Java中的HashMap（JDK1.7）的结构也是一致的，它的数据结构也是数组+链表组成的二维结构，节点元素散列在数组上，如果发生hash碰撞则使用链表串联在数组节点上。 1.2 hash(字典)扩容Redis中的hash(字典)存储的value只能是字符串值，此外扩容与Java中的HashMap也不同。Java中的HashMap在扩容的时候是一次性完成的，而Redis考虑到其核心存取是单线程的性能问题，为了追求高性能，因而采取了渐进式rehash策略。 1.3 hash(字典)的相关使用场景hash(字典)可以用来存储对象的相关信息，一个hash(字典)代表一个对象，hash的一个key代表对象的一个属性，key的值代表属性的值。hash(字典)结构相比字符串来说，它无需将整个对象进行序列化后进行存储。这样在获取的时候可以进行部分获取。所以相比之下hash(字典)具有如下的优缺点：
2 hash(字典)相关指令2.1 hash(字典)常用指令hset -> hash(字典)插入值，字典不存在则创建 key代表字典名称，field 相当于 key，value是key的值
hmset -> 批量设值
示例： 17.0.0.1:6379> hset book java "Thinking in Java" # 字符串包含空格需要""包裹 2(integer) 1 3127.0.0.1:6379> hset book python "Python code" 4(integer) 1 5127.0.0.1:6379> hset book c "The best of c" 6(integer) 1 7127.0.0.1:6379> hmset book go "concurrency in go" mysql "high-performance MySQL" # 批量设值 8OK hget -> 获取字典中的指定key的value
hgetall -> 获取字典中所有的key和value，换行输出 hgetall key 示例： 1127.0.0.1:6379> hget book java 2"Thinking in Java" 3127.0.0.1:6379> hgetall book 41) "java" 52) "Thinking in Java" 63) "python" 74) "Python code" 85) "c" 96) "The best of c" hlen -> 获取指定字典的key的个数
举例： 1127.0.0.1:6379> hlen book 2(integer) 5 2.2 hash(字典)使用小技巧在string(字符串)中可以使用incr和incrby对value是整数的字符串进行自加操作，在hash(字典)结构中如果单个子key是整数也可以进行自加操作。
1127.0.0.1:6379> hset liziba money 10 2(integer) 1 3127.0.0.1:6379> hincrby liziba money -1 4(integer) 9 5127.0.0.1:6379> hget liziba money 6"9" 注意如果不是整数会报错。 1127.0.0.1:6379> hset liziba money 10.1 2(integer) 1 3127.0.0.1:6379> hincrby liziba money 1 4(error) ERR hash value is not an integer 五、set（集合）1、set(集合)相关介绍1.1 set(集合)的内部结构Redis的set(集合)相当于Java语言里的HashSet，它内部的键值对是无序的、唯一的。它的内部实现了一个所有value为null的特殊字典。 1.2 set(集合)的使用场景set(集合)由于其特殊去重复的功能，我们可以用来存储活动中中奖的用户的ID，这样可以保证一个用户不会中奖两次。 2、set(集合)相关指令sadd -> 添加集合成员，key值集合名称，member值集合元素，元素不能重复
1127.0.0.1:6379> sadd name zhangsan 2(integer) 1 3127.0.0.1:6379> sadd name zhangsan # 不能重复，重复返回0 4(integer) 0 5127.0.0.1:6379> sadd name lisi wangwu liumazi # 支持一次添加多个元素 6(integer) 3 smembers -> 查看集合中所有的元素，注意是无序的
1127.0.0.1:6379> smembers name # 无序输出集合中所有的元素 21) "lisi" 32) "wangwu" 43) "liumazi" 54) "zhangsan" sismember -> 查询集合中是否包含某个元素
127.0.0.1:6379> sismember name lisi # 包含返回1 (integer) 1 127.0.0.1:6379> sismember name tianqi # 不包含返回0 (integer) 0 scard -> 获取集合的长度
1127.0.0.1:6379> scard name 2(integer) 4 spop -> 弹出元素，count指弹出元素的个数
127.0.0.1:6379> spop name # 默认弹出一个 "wangwu" 127.0.0.1:6379> spop name 3 1) "lisi" 2) "zhangsan" 3) "liumazi 六、zset（有序集合）1、zset(有序集合)相关介绍1.1 zset(有序集合)的内部结构zset(有序集合)是Redis中最常问的数据结构。它类似于Java语言中的SortedSet和HashMap的结合体，它一方面通过set来保证内部value值的唯一性，另一方面通过value的score（权重）来进行排序。这个排序的功能是通过Skip List（跳跃列表）来实现的。 1.2 zset(有序集合)的相关使用场景利用zset的去重和有序的效果可以由很多使用场景，举两个例子：
2、zset(有序集合)相关指令1、zadd -> 向集合中添加元素，集合不存在则新建，key代表zset集合名称，score代表元素的权重，member代表元素
127.0.0.1:6379> zadd name 10 zhangsan (integer) 1 127.0.0.1:6379> zadd name 10.1 lisi (integer) 1 127.0.0.1:6379> zadd name 9.9 wangwu (integer) 1 2、zrange -> 按照score权重从小到大排序输出集合中的元素，权重相同则按照value的字典顺序排序([lexicographical order])
127.0.0.1:6379> zrange name 0 -1 # 获取所有元素，按照score的升序输出 1) "wangwu" 2) "zhangsan" 3) "lisi" 127.0.0.1:6379> zrange name 0 1 # 获取第一个和第二个slot的元素 1) "wangwu" 2) "zhangsan" 127.0.0.1:6379> zadd name 10 tianqi # 在上面的基础上添加score为10的元素 (integer) 1 127.0.0.1:6379> zrange name 0 2 # key相等则按照value字典排序输出 1) "wangwu" 2) "tianqi" 3) "zhangsan" 127.0.0.1:6379> zrange name 0 -1 WITHSCORES # WITHSCORES 输出权重 1) "wangwu" 2) "9.9000000000000004" 3) "tianqi" 4) "10" 5) "zhangsan" 6) "10" 7) "lisi" 8) "10.1" 3、zrevrange -> 按照score权重从大到小输出集合中的元素，权重相同则按照value的字典逆序排序
127.0.0.1:6379> zrevrange name 0 -1 WITHSCORES 1) "lisi" 2) "10.1" 3) "zhangsan" 4) "10" 5) "tianqi" 6) "10" 7) "wangwu" 8) "9.9000000000000004" 4、zcard -> 当 key 存在且是有序集类型时，返回有序集的基数。 当 key 不存在时，返回 0
127.0.0.1:6379> zcard name (integer) 4 5、zscore -> 返回有序集 key 中，成员 member 的 score 值，如果 member 元素不是有序集 key 的成员，或 key 不存在，返回 nil
127.0.0.1:6379> zscore name zhangsan "10" 127.0.0.1:6379> zscore name liziba (nil) 6、zrank -> 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列。
127.0.0.1:6379> zrange name 0 -1 1) "wangwu" 2) "tianqi" 3) "zhangsan" 4) "lisi" 127.0.0.1:6379> zrank name wangwu (integer) 0 7、zrangebyscore -> 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。
127.0.0.1:6379> zrange name 0 -1 WITHSCORES # 输出全部元素 1) "wangwu" 2) "9.9000000000000004" 3) "tianqi" 4) "10" 5) "zhangsan" 6) "10" 7) "lisi" 8) "10.1" 127.0.0.1:6379> zrangebyscore name 9 10 1) "wangwu" 2) "tianqi" 3) "zhangsan" 127.0.0.1:6379> zrangebyscore name 9 10 WITHSCORES # 输出分数 1) "wangwu" 2) "9.9000000000000004" 3) "tianqi" 4) "10" 5) "zhangsan" 6) "10" 127.0.0.1:6379> zrangebyscore name -inf 10 # -inf 从负无穷开始 1) "wangwu" 2) "tianqi" 3) "zhangsan" 127.0.0.1:6379> zrangebyscore name -inf +inf # +inf 直到正无穷 1) "wangwu" 2) "tianqi" 3) "zhangsan" 4) "lisi" 127.0.0.1:6379> zrangebyscore name (10 11 # 10 < score <=11 1) "lisi" 127.0.0.1:6379> zrangebyscore name (10 (10.1 # 10 < socre < -11 (empty list or set) 127.0.0.1:6379> zrangebyscore name (10 (11 1) "lisi" 8、zrem -> 移除有序集 key 中的一个或多个成员，不存在的成员将被忽略
127.0.0.1:6379> zrange name 0 -1 1) "wangwu" 2) "tianqi" 3) "zhangsan" 4) "lisi" 127.0.0.1:6379> zrem name zhangsan # 移除元素 (integer) 1 127.0.0.1:6379> zrange name 0 -1 1) "wangwu" 2) "tianqi" 3) "lisi" 七、Skip List1、简介
Skip List(跳跃列表)这种随机的数据结构，可以看做是一个二叉树的变种，它在性能上与红黑树、AVL树很相近；但是Skip List(跳跃列表)的实现相比前两者要简单很多，目前Redis的zset实现采用了Skip List(跳跃列表)（其它还有LevelDB等也使用了跳跃列表）。 RBT红黑树与Skip List(跳跃列表)简单对比：
Skip List跳跃列表
2、Skip List算法分析2.1 Skip List论文这里贴出Skip List的论文，需要详细研究的请看论文，下文部分公式、代码、图片出自该论文。
2.2 Skip List动态图先通过一张动图来了解Skip List的插入节点元素的流程，此图来自维基百科。 2.3 Skip List算法性能分析2.3.1 计算随机层数算法首先分析的是执行插入操作时计算随机数的过程，这个过程会涉及层数的计算，所以十分重要。对于节点他有如下特性：
计算随机层数的伪代码：
public int randomLevel(){
int level = 1;
// random()返回一个[0...1)的随机数
while (random() < p && level < MaxLevel){
level += 1;
}
return level;
}
代码中包含两个变量P和MaxLevel，在Redis中这两个参数的值分别是： 1p = 1/4 2MaxLevel = 64 2.3.2 节点包含的平均指针数目Skip List属于空间换时间的数据结构，这里的空间指的就是每个节点包含的指针数目，这一部分是额外的内内存开销，可以用来度量空间复杂度。random()是个随机数，因此产生越高的节点层数，概率越低（Redis标准源码中的晋升率数据1/4，相对来说Skip List的结构是比较扁平的，层高相对较低）。其定量分析如下：
得出节点的平均层数（节点包含的平均指针数目）：
2.3.3 时间复杂度计算以下推算来自论文内容 1 / p = n * (p^L-1) n = (1/p)^L L = log(1/p)^n 所以我们应该选择MaxLevel = log(1/p)^n 推算Skip List的时间复杂度，可以用逆向思维，从层数为i的节点x出发，返回起点的方式来回溯时间复杂度，节点x点存在两种情况：
C(0)=0 C(k)=(1-p)×(情况b的查找长度) + p×(情况c的查找长度) C(k)=(1-p)(C(k)+1) + p(C(k-1)+1) C(k)=1/p+C(k-1) C(k)=k/p 上面推演的结果可知，爬升k个level的预期长度为k/p，爬升一个level的长度为1/p。 由于MaxLevel = L(n)， C(k) = k / p，因此期望值为：(L(n) – 1) / p；将L(n) = log(1/p)^n 代入可得：(log(1/p)^n - 1) / p；将p = 1 / 2 代入可得：2 * log2^n - 2，即O(logn)的时间复杂度。 3、Skip List特性及其实现2.1 Skip List特性Skip List跳跃列表通常具有如下这些特性 Skip List包含多个层，每层称为一个level，level从0开始递增Skip List 0层，也就是最底层，应该包含所有的元素每一个level/层都是一个有序的列表level小的层包含level大的层的元素，也就是说元素A在X层出现，那么 想X>Z>=0的level/层都应该包含元素A每个节点元素由节点key、节点value和指向当前节点所在level的指针数组组成 2.2 Skip List查询假设初始Skip List跳跃列表中已经存在这些元素，他们分布的结构如下所示： 此时查询节点88，它的查询路线如下所示： 从Skip List跳跃列表最顶层level3开始，往后查询到10 < 88 && 后续节点值为null && 存在下层level2level2 10往后遍历，27 < 88 && 后续节点值为null && 存在下层level1level1 27往后遍历，88 = 88，查询命中 2.3 Skip List插入Skip List的初始结构与2.3中的初始结构一致，此时假设插入的新节点元素值为90，插入路线如下所示： 查询插入位置，与Skip List查询方式一致，这里需要查询的是第一个比90大的节点位置，插入在这个节点的前面， 88 < 90 < 100构造一个新的节点Node(90)，为插入的节点Node(90)计算一个随机level，这里假设计算的是1，这个level时随机计算的，可能时1、2、3、4…均有可能，level越大的可能越小，主要看随机因子x ，层数的概率大致计算为 (1/x)^level ，如果level大于当前的最大level3，需要新增head和tail节点节点构造完毕后，需要将其插入列表中，插入十分简单步骤 -> Node(88).next = Node(90); Node(90).prev = Node(80); Node(90).next = Node(100); Node(100).prev = Node(90); 2.4 Skip List删除删除的流程就是查询到节点，然后删除，重新将删除节点左右两边的节点以链表的形式组合起来即可，这里不再画图 4、手写实现一个简单Skip List实现一个Skip List比较简单，主要分为两个步骤：
3.1 定义Node节点Node节点类主要包括如下重要属性：
package com.liziba.skiplist;
/**
* <p>
* 跳表节点元素
* </p>
*
* @Author: Liziba
* @Date: 2021/7/5 21:01
*/
public class Node {
/** 节点的分数值，根据分数值来排序 */
public Double score;
/** 节点存储的真实数据 */
public String value;
/** 当前节点的 前、后、下、上节点的引用 */
public Node prev, next, down, up;
public Node(Double score) {
this.score = score;
prev = next = down = up = null;
}
public Node(Double score, String value) {
this.score = score;
this.value = value;
}
}
3.2 SkipList节点元素的操作类SkipList主要包括如下重要属性：
package com.liziba.skiplist;
import java.util.Random;
/**
* <p>
* 跳表实现
* </p>
*
* @Author: Liziba
*/
public class SkipList {
/** 最上层头节点 */
public Node head;
/** 最上层尾节点 */
public Node tail;
/** 总层数 */
public int level;
/** 元素个数 */
public int size;
public Random random;
public SkipList() {
level = size = 0;
head = new Node(null);
tail = new Node(null);
head.next = tail;
tail.prev = head;
}
/**
* 查询插入节点的前驱节点位置
*
* @param score
* @return
*/
public Node fidePervNode(Double score) {
Node p = head;
for(;;) {
// 当前层(level)往后遍历，比较score，如果小于当前值，则往后遍历
while (p.next.value == null && p.prev.score <= score)
p = p.next;
// 遍历最右节点的下一层(level)
if (p.down != null)
p = p.down;
else
break;
}
return p;
}
/**
* 插入节点，插入位置为fidePervNode(Double score)前面
*
* @param score
* @param value
*/
public void insert(Double score, String value) {
// 当前节点的前置节点
Node preNode = fidePervNode(score);
// 当前新插入的节点
Node curNode = new Node(score, value);
// 分数和值均相等则直接返回
if (curNode.value != null && preNode.value != null && preNode.value.equals(curNode.value)
&& curNode.score.equals(preNode.score)) {
return;
}
preNode.next = curNode;
preNode.next.prev = curNode;
curNode.next = preNode.next;
curNode.prev = preNode;
int curLevel = 0;
while (random.nextDouble() < 1/2) {
// 插入节点层数(level)大于等于层数(level)，则新增一层(level)
if (curLevel >= level) {
Node newHead = new Node(null);
Node newTail = new Node(null);
newHead.next = newTail;
newHead.down = head;
newTail.prev = newHead;
newTail.down = tail;
head.up = newHead;
tail.up = newTail;
// 头尾节点指针修改为新的，确保head、tail指针一直是最上层的头尾节点
head = newHead;
tail = newTail;
++level;
}
while (preNode.up == null)
preNode = preNode.prev;
preNode = preNode.up;
Node copy = new Node(null);
copy.prev = preNode;
copy.next = preNode.next;
preNode.next.prev = copy;
preNode.next = copy;
copy.down = curNode;
curNode.up = copy;
curNode = copy;
++curLevel;
}
++size;
}
/**
* 查询指定score的节点元素
* @param score
* @return
*/
public Node search(double score) {
Node p = head;
for (;;) {
while (p.next.score != null && p.next.score <= score)
p = p.next;
if (p.down != null)
p = p.down;
else // 遍历到最底层
if (p.score.equals(score))
return p;
return null;
}
}
/**
* 升序输出Skip List中的元素 （默认升序存储，因此从列表head往tail遍历）
*/
public void dumpAllAsc() {
Node p = head;
while (p.down != null) {
p = p.down;
}
while (p.next.score != null) {
System.out.println(p.next.score + "-->" + p.next.value);
p = p.next;
}
}
/**
* 降序输出Skip List中的元素
*/
public void dumpAllDesc() {
Node p = tail;
while (p.down != null) {
p = p.down;
}
while (p.prev.score != null) {
System.out.println(p.prev.score + "-->" + p.prev.value);
p = p.prev;
}
}
/**
* 删除Skip List中的节点元素
* @param score
*/
public void delete(Double score) {
Node p = search(score);
while (p != null) {
p.prev.next = p.next;
p.next.prev = p.prev;
p = p.up;
}
}
}
到此这篇关于多维度深入分析Redis的5种基本数据结构的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持极客世界。 |
请发表评论