前言

对于有序集合这个名词来说，大家可能会有一些陌生，对于前面的字符串、列表、哈希、集合类型大家肯定多多少少在其他方面都有一些了解。那么什么是有序集合呢？有序集合保留了集合可以去重的特性，但与集合不同的是，有序集合中每个都有一个唯一的浮点类型的分数与之关联，也正是因为这个唯一的浮点数使得有序集合中的元素是可以维护有序性的，但这个有序不是用下标作为排序依据而是用这个分数。

列表、集合、有序集合的异同点：

数据结构	是否允许重复元素	是否有序	有序依据	应用场景
列表	是	是	索引下标	时间轴、消息队列等
集合	否	否		标签、社交等
有序集合	否	是	分数	排⾏榜系统、社交等

zset 中的有序指的是集合中的元素的大小顺序是一定的，默认是按照分数的升序排列的。zset 中的分数只是起到辅助排序的作用。

命令

ZADD

ZADD 命令添加或者更新指定的元素以及关联的分数到 zset 中，分数应该符合 double 类型，+inf/-inf 作为正负极限也是合法的。
ZADD key [NX | XX] [GT | LT] [CH] [INCR] score member[score member...]

选项：

• 默认不添加 NX 或者 XX 选项的情况下，如果要添加的元素不存在，则会将该元素添加到 zset 中，如果存在则会修改该元素
• NX，当要添加的元素在 zset 中不存在时才添加成功，不存在时直接返回，也就是使用 NX 选项不会修改已存在的元素的值
• XX，当要添加的元素不存在时，直接返回，之后当元素已经存在的时候才会修改已存在的元素的值，也就是说使用XX元素只会修改元素，而不会添加新的元素
• LT/GT：LT(less than)选项只有当前已经存在的元素的值大于要修改的值的时候才会对元素的值进行修改，GT则相反
• CH：默认情况下，ZADD 返回的值是本次操作添加的元素的个数，但指定这个选项之后，返回的值就还包括本次更新的元素的个数
• INCR：此时命令类似 ZINCRBY 的效果，将元素的分数加上指定的分数。此时只能指定一个元素和分数

时间复杂度：O(logN)
返回值：本次添加成功的元素的个数

之前的 string、list、hash 和 set 类型添加元素的时间复杂度都是 O(1)，而 zset 添加元素的时间复杂度之所以是 logN 是因为 zset 的内部编码是由跳表实现的，而为了保证 zset 的有序性，新添加进去的元素需要放到指定的位置，所以时间复杂度就是 O(logN)。

127.0.0.1:6379> zadd key 92 zhangsan 93.5 lisi 95 wangwu
3
127.0.0.1:6379> zrange key 0 -1 withscores #该命令获取zset中的元素，后面为大家详细讲
zhangsan
92
lisi
93.5
wangwu
95
127.0.0.1:6379> ZADD key nx 100 zhangsan #使用了nx选项因为zhangsan已经存在了，所以修改数据失败
0
127.0.0.1:6379> zrange key 0 -1 withscores
zhangsan
92
lisi
93.5
wangwu
95
127.0.0.1:6379> ZADD key nx 100 zhaoliu #zhaoliu不存在，所以添加成功
1
127.0.0.1:6379> zrange key 0 -1 withscores
zhangsan
92
lisi
93.5
wangwu
95
zhaoliu
100
127.0.0.1:6379> ZADD key xx 95 xiaoming #使用xx选项意味着就是修改zset中元素的值，但是xiaoming不存在与zset中，所以修改失败
0
127.0.0.1:6379> zrange key 0 -1 withscores
zhangsan
92
lisi
93.5
wangwu
95
zhaoliu
100
127.0.0.1:6379> ZADD key xx 95 zhangsan #zhangsan存在于zset中，所以修改成功，但是这里返回的值是0，为了能够体现出来修改成功，我们再加上CH选项
0
127.0.0.1:6379> zrange key 0 -1 withscores
lisi
93.5
wangwu
95
zhangsan
95
zhaoliu
100
127.0.0.1:6379> ZADD key xx ch 93.5 zhangsan #添加选项ch使得返回的值包括了更新的元素的个数
1
127.0.0.1:6379> zrange key 0 -1 withscores
lisi
93.5
zhangsan
93.5
wangwu
95
zhaoliu
100
redis> zadd key lt 90 zhangsan #使用lt选项之后添加的元素的值小于已经存在的元素的值，修改成功
(integer) 0
redis> zrange key 0 -1 withscores
1) "zhangsan"
2) "90"
3) "lisi"
4) "93.5"
5) "wnagwu"
6) "95"
7) "zhaoliu"
8) "100"
redis> zadd key lt 95 zhangsan #要修改的值大于已经存在的元素的值，添加失败
(integer) 0
redis> zrange key 0 -1 withscores
1) "zhangsan"
2) "90"
3) "lisi"
4) "93.5"
5) "wnagwu"
6) "95"
7) "zhaoliu"
8) "100"
redis> zadd key gt 96 wangwu #使用gt选项，要添加的值小于已经存在的元素的值，修改元素失败
(integer) 0
redis> zrange key 0 -1 withscores
1) "zhangsan"
2) "90"
3) "lisi"
4) "93.5"
5) "wangwu"
6) "98"
7) "zhaoliu"
8) "100"
redis> zadd key gt 99 wangwu #添加成功
(integer) 0
1) "zhangsan"
2) "90"
3) "lisi"
4) "93.5"
5) "wangwu"
6) "99"
7) "zhaoliu"
8) "100"
127.0.0.1:6379> ZADD key xx incr 5 zhangsan #使用incr选项可以不必知道需要修改的元素的值，然后直接讲zset中元素的值加上指定元素
98.5
127.0.0.1:6379> zrange key 0 -1 withscores
lisi
93.5
wangwu
95
zhangsan
98.5
zhaoliu
100

如果 zset 中存在分数相同的元素，那么会以 member 的字典序进行排序。

ZCARD

ZCARD 命令获取一个 zset 的基数，即 zset 中元素的个数。ZCARD key

时间复杂度：O(1)，这里之所以是O(1)是因为用了一个变量来维护元素个数
返回值：zset 内元素的个数

127.0.0.1:6379> zrange key 0 -1 withscores
1) "lisi"
2) "93.5"
3) "wangwu"
4) "95"
5) "zhangsan"
6) "98.5"
7) "zhaoliu"
8) "100"
127.0.0.1:6379> ZCARD key
(integer) 4

ZCOUNT

ZCOUNT 命令返回分数在 min 和 max 之间的元素的个数，默认情况下 min 和 max 都是包含的，可以通过 ( 排除。ZCOUNT key min max

时间复杂度：O(logN)
返回值：min 到 max 之间元素的个数

这里的时间复杂度为什么不是O(logN + M)，M为区间大小呢？这是因为 zcount 在找 min 和 max 之间元素的个数的时候，会先去找到 min 和 max 所对应的元素的“下标”，然后用 max 的下标减去 min 的下标就得到 min 和 max 之间元素的个数了，而不是找到 min 元素之后继续向后找，遍历一个元素 count++，直到找到 max 元素所在的位置。

127.0.0.1:6379> zrange key 0 -1 withscores
1) "lisi"
2) "93.5"
3) "wangwu"
4) "95"
5) "zhangsan"
6) "98.5"
7) "zhaoliu"
8) "100"
127.0.0.1:6379> zcount key 95 100 #范围值包括95和100
(integer) 3
127.0.0.1:6379> zcount key (95 100 #范围内的值不包括95
(integer) 2
127.0.0.1:6379> zcount key -inf inf #获取负无穷到正无穷之间的元素的个数，也可以理解为zset中所有元素的个数
(integer) 4

ZRANGE

ZRANGE 命令返回指定区间之间的元素，分数按照升序。带上 WITHSCORES 可以将对应的分数也返回。ZRANGE key start end [WITHSCORES]

这里有人可能会问了，这不是集合吗，集合为什么会有下标这样的说法呢？是的，这里虽然是集合，但是这个集合是有序集合，元素之间是有先后顺序的，谁在前，谁在后都是由明确的顺序的，所以这个有序集合也就可以有下标这样的概念了。同样这里的下标也是支持负数的。

时间复杂度：O(logN+M)，N为zset中元素个数，M为区间范围
返回值：区间之内的元素

127.0.0.1:6379> zrange key 1 2
wangwu
zhangsan
127.0.0.1:6379> zrange key 1 2 withscores
wangwu
95
zhangsan
98.5
127.0.0.1:6379> zrange key 0 -1 withscores
lisi
93.5
wangwu
95
zhangsan
98.5
zhaoliu
100

ZREVRANGE

ZREVRANGE 命令获取指定区间的元素，但是结果是按照分数的降序显示的，同样的带上 WITHSCORES 也可将对应的分数返回。备注：这个命令可能在6.2.0之后废弃，并且功能合并到RANGE中。ZREVRANGE key start end [WITHSCORES]

时间复杂度：O(logN+M)，N为zset中元素个数，M为区间范围
返回值：区间内的元素

127.0.0.1:6379> zrange key 0 -1 withscores
1) "lisi"
2) "93.5"
3) "wangwu"
4) "95"
5) "zhangsan"
6) "98.5"
7) "zhaoliu"
8) "100"
127.0.0.1:6379> ZREVRANGE key 0 -1 withscores
1) "zhaoliu"
2) "100"
3) "zhangsan"
4) "98.5"
5) "wangwu"
6) "95"
7) "lisi"
8) "93.5"
127.0.0.1:6379> ZREVRANGE key 1 3 withscores
1) "zhangsan"
2) "98.5"
3) "wangwu"
4) "95"
5) "lisi"
6) "93.5"

ZRANGEBYSCORE

ZRANGEBYSCORE 命令返回分数在 min 到 max 之间的元素，默认情况下 min 和 max 都是包含的。可以通过 ( 排除。备注：这个命令可能在6.2.0之后废弃，并且功能合并到RANGE中。

时间复杂度：O(logN + M)，N为zset中元素的个数，M为区间范围
返回值：区间内的元素

127.0.0.1:6379> zrange key 0 -1 withscores
1) "lisi"
2) "93.5"
3) "wangwu"
4) "95"
5) "zhangsan"
6) "98.5"
7) "zhaoliu"
8) "100"
127.0.0.1:6379> ZRANGEBYSCORE key 95 100 withscores
1) "wangwu"
2) "95"
3) "zhangsan"
4) "98.5"
5) "zhaoliu"
6) "100"
127.0.0.1:6379> ZRANGEBYSCORE key (95 (100 withscores #通过加上(可以排除掉min或者max的值
1) "zhangsan"
2) "98.5"

ZPOPMAX

ZPOPMAX 命令删除并返回分数最高的 count 个元素。ZPOPMAX key [count]

时间复杂度：O(logN * M)，M为要删除的元素的个数
返回值：分数和元素列表

127.0.0.1:6379> ZPOPMAX key
1) "zhaoliu"
2) "100"
127.0.0.1:6379> ZPOPMAX key 2
1) "zhangsan"
2) "98.5"
3) "wangwu"
4) "95"

因为 zset 的有序性，默认将分数最大的元素放在最后面，那么这个 ZPOPMAX 每次删除最大的元素，也就是最末尾的元素，这属于是一个特殊的位置，为什么不使用一个特殊的变量来存储这个位置呢？这样不就可以使得么每次删除一个最大值的时间复杂度都是 O(1)呢？其实 redis 底层使用了一个特殊的变量来标记末尾的位置，但是具体为啥 redis 没有这样用，我们也不知道，换句话说，ZPOPMAX 命令是可以优化的。

ZPOPMIN

ZPOPMIN 命令删除并返回 count 个分数最低的元素。ZPOPMIN key [count]

时间复杂度：O(logN * M)，M为要删除的元素的个数
返回值：分数和列表元素

127.0.0.1:6379> zadd key 93 zhangsan 95 lisi 97.5 wangwu 100 zhaoliu
(integer) 4
127.0.0.1:6379> zrange key 0 -1 withscores
1) "zhangsan"
2) "93"
3) "lisi"
4) "95"
5) "wangwu"
6) "97.5"
7) "zhaoliu"
8) "100"
127.0.0.1:6379> ZPOPMIN key
1) "zhangsan"
2) "93"
127.0.0.1:6379> ZPOPMIN key 2
1) "lisi"
2) "95"
3) "wangwu"
4) "97.5"
127.0.0.1:6379> ZRANGE key 0 -1 withscores
1) "zhaoliu"
2) "100"

两个阻塞版本的POP命令

对于 zset 来说存在两个阻塞版本的 POP 操作，分别是 BZPOPMAX 和 BZPOPMIN。

BZPOPMAX

BZPOPMAX 命令是 ZPOPMAX 的阻塞版本。BZPOPMAX key[key...] timeout

时间复杂度：O(logN)
返回值：元素列表

BZPOPMIN

BZPOPMIN 命令是 ZPOPMIN 的阻塞版本。BZPOPMIN key [key...] timeout

<font color = “CC0000”.时间复杂度：O(logN )
返回值：元素列表

ZRANK

ZRANK 命令返回指定元素的排名(升序)，排名从0开始。ZRANK key member

时间复杂度：O(logN)
返回值：排名

127.0.0.1:6379> zadd key 93 zhangsan 94.5 lisi 97 wnagwu 100 zhaoliu
(integer) 4
127.0.0.1:6379> ZRANK key zhaoliu
(integer) 3

ZREVRANK

ZREVRANK 命令返回指定元素的排名(降序)，排名从0开始。ZREVRANK key member

时间复杂度：O(logN)
返回值：排名

127.0.0.1:6379> ZRANGE key 0 -1 withscores
1) "zhangsan"
2) "93"
3) "lisi"
4) "94.5"
5) "wnagwu"
6) "97"
7) "zhaoliu"
8) "100"
127.0.0.1:6379> ZREVRANK key lisi
(integer) 2
127.0.0.1:6379> 

ZSCORE

ZSCORE 命令返回指定元素的分数。ZSCORE key member

时间复杂度：O(logN)
返回值：分数

127.0.0.1:6379> ZRANGE key 0 -1 withscores
1) "zhangsan"
2) "93"
3) "lisi"
4) "94.5"
5) "wnagwu"
6) "97"
7) "zhaoliu"
8) "100"
127.0.0.1:6379> ZSCORE key lisi
"94.5"

ZREM

ZREM 命令删除指定元素。ZREM key member[member...]

时间复杂度：O(logN)
返回值：本次操作删除的元素的个数

127.0.0.1:6379> ZRANGE key 0 -1 withscores
1) "zhangsan"
2) "93"
3) "lisi"
4) "94.5"
5) "wnagwu"
6) "97"
7) "zhaoliu"
8) "100"
127.0.0.1:6379> ZREM key zhangsan lisi
(integer) 2
127.0.0.1:6379> ZRANGE key 0 -1 withscores
1) "wnagwu"
2) "97"
3) "zhaoliu"
4) "100"

ZREMRANGEBYRANK

ZREMRANGEBYRANK 命令按照排序，升序删除指定排名范围的元素。ZREMRANGEBYRANK key start end

时间复杂度：O(logN + M)，M为区间范围
返回值：本次操作删除的元素的个数

127.0.0.1:6379> ZRANGE key 0 -1 withscores
1) "zhangsan"
2) "93"
3) "lisi"
4) "94.5"
5) "wangwu"
6) "97"
7) "zhaoliu"
8) "100"
127.0.0.1:6379> ZREMRANGEBYRANK key 1 2
(integer) 2
127.0.0.1:6379> ZRANGE key 0 -1 withscores
1) "zhangsan"
2) "93"
3) "zhaoliu"
4) "100"

ZREMRANGEBYSCORE

ZREMRANGEBYSCORE 命令按照顺序，按照分数删除指定范围的元素。ZREMRANGEBYSCORE key start end

时间复杂度：O(logN + M)，M为区间范围
返回值：本次操作删除的元素的个数

127.0.0.1:6379> ZRANGE key 0 -1 withscores
1) "zhangsan"
2) "93"
3) "lisi"
4) "94.5"
5) "wangwu"
6) "97"
7) "zhaoliu"
8) "100"
127.0.0.1:6379> ZREMRANGEBYSCORE key 95 100
(integer) 2
127.0.0.1:6379> ZRANGE key 0 -1 withscores
1) "zhangsan"
2) "93"
3) "lisi"
4) "94.5"

ZINCRBY

ZINCRBY 命令为指定的元素的关联分数添加指定的分数。ZINCRBY key increment member

时间复杂度：O(logN)
返回值：增加后元素的分数

127.0.0.1:6379> ZRANGE key 0 -1 withscores
1) "zhangsan"
2) "93"
3) "lisi"
4) "94.5"
5) "wangwu"
6) "97"
7) "zhaoliu"
8) "100"
127.0.0.1:6379> ZINCRBY key 10 zhaoliu
"110"
127.0.0.1:6379> ZRANGE key 0 -1 withscores
1) "zhangsan"
2) "93"
3) "lisi"
4) "94.5"
5) "wangwu"
6) "97"
7) "zhaoliu"
8) "110"

集合间操作

同样的 zset 也是支持集合间操作的，但是与 set 不同的是，zset 只支持交集和并集的操作，并且对于这些交集和并集的操作，也只支持 store 版本的操作，也就是 ZINTERSTORE 和 ZUNIONSTORE 操作。

ZINTERSTORE

ZINTERSTORE 将给定几个的交集存放在一个指定集合中。ZINTERSTORE destination numkeys key[key...] [WEIGHTS weight[weight...]] [AGGREGATE <SUM | MIN | MAX>]

• numkeys：表示集合的数量，这里为什么需要指定集合的数量呢？这是因为我们后面的 weight 的数量也是不确定的，为了区分出集合名和 weight，所以需要指定出集合的数量 numkeys
• weights：这是集合所占的权重，在进行交集操作的时候，每个集合中的每个元素的分数都需要乘上对应的权重
• aggregate：指明，对于不同集合中求交集的操作，每个元素的分数该怎么计算，sum 表示相同元素分数之和，max 表示取分数最大的，min表示取分数最小的

时间复杂度：O(N*K) + O(M*logM)，N是输入的有序集合中，最小的有序集合的个数，k是集合的数量，M是最终结果的有序集合的元素个数
返回值：目标集合元素个数

127.0.0.1:6379> zadd key 90 zhangsan 93 lisi 97.5 wangwu 96 zhaoliu
(integer) 4
127.0.0.1:6379> zadd key2 89 xiaoming 91 xiaoli 95 wangwu 94 zhangsan
(integer) 4
127.0.0.1:6379> ZINTERSTORE key3 2 key key2
(integer) 2
127.0.0.1:6379> zrange key3 0 -1 withscores #没指定aggregate选项的时候，默认是sum求和
1) "zhangsan"
2) "184"
3) "wangwu"
4) "192.5"
127.0.0.1:6379> ZINTERSTORE key4 2 key key2 weights 4 6 #指定权重之后，对于交集元素key的每个元素会乘上4，key2中的交集元素会乘上6
(integer) 2
127.0.0.1:6379> zrange key4 0 -1 withscores
1) "zhangsan"
2) "924"
3) "wangwu"
4) "960"
127.0.0.1:6379> ZINTERSTORE key5 2 key key2 aggregate max #交集元素的分数取最大值
(integer) 2
127.0.0.1:6379> zrange key5 0 -1 withscores
1) "zhangsan"
2) "94"
3) "wangwu"
4) "97.5"
127.0.0.1:6379> ZINTERSTORE key6 2 key key2 aggregate min #交集元素的分数取最小值
(integer) 2
127.0.0.1:6379> zrange key6 0 -1 withscores
1) "zhangsan"
2) "90"
3) "wangwu"
4) "95"

ZUNIONSTORE

ZUNIONSTORE 命令将给定集合的并集放在指定的集合中。ZUNIONSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE <SUM | MIN | MAX>]

这个命令中各个选项的含义和 ZINTERSTORE 是一样的，这里就不为大家过多展示了。

时间复杂度：O(N) + O(M*logM)，N是输入的结合的所有元素的个数，M是最终集合的元素的个数
返回值：目标集合的元素的个数

命令小结

命令	执行效果	时间复杂度
zadd key score member [score member …]	向zset中添加元素	O(k * log(n))，k 是添加成员的个数，n 是当前有有序集合的元素个数
zcard key	获取zset中元素个数	O(1)
zscore key member	获取指定元素的分数	O(logN)
zrank key member	获取指定元素的排名（升序）	O(logN)
zrevrank key member	获取指定元素的排名（降序）	O(logN)
zrem key member [member …]	删除指定的元素	O(k * log(n))，k 是删除成员的个数，n 是当前有序集合的元素个数
zincrby key increment member	使得zset中指定元素的分数加上指定值	O(log(n))，n 是当前有序集合的元素个数
zrange key start end [withscores]	获取指定下标范围内的元素（升序形式返回）	O(k + log(n))，k 是获区间范围，n 是当前有序集合的元素个数
zrevrange key start end [withscores]	获取指定下标范围内的元素（降序形式返回）	O(k + log(n))，k 是获区间范围，n 是当前有序集合的元素个数
zrangebyscore key min max [withscores]	获取指定分数范围内的元素（升序形式返回）	O(k + log(n))，k 是获区间范围，n 是当前有序集合的元素个数
zrevrangebyscore key max min [withscores]	获取指定分数范围内的元素（降序形式返回）	O(k + log(n))，k 是获区间范围，n 是当前有序集合的元素个数
ZCOUNT key min max	获取min到max分数之间的元素个数	O(log(n))，n 是当前有序集合的元素个数
zremrangebyrank key start end	删除start到end排名之间的元素	O(logN + M)，M为区间范围
zremrangebyscore key min max	删除min到max分数之间的元素	O(logN + M)，M为区间范围
zinterstore destination numkeys key [key …]	将给定集合的交集元素放在指定集合中	O(N*K) + O(M*logM)，N是输入的有序集合中，最小的有序集合的个数，k是集合的数量，M是最终结果的有序集合的元素个数
zunionstore destination numkeys key [key…]	将给定集合的并集元素放在指定集合中	O(N) + O(M*logM)，N是输入的结合的所有元素的个数，M是最终集合的元素的个数

内部编码

有序集合类型的内部编码有两种：

• ziplist：当zset中的元素个数和每个元素的长度较小的时候，redis 底层会用 ziplist 来作为 zset 的颞部实现
• skiplist（跳表）：当 zset 中元素不满足 ziplist 的条件的时候，就会选择 skiplist 来作为 zset 的内部实现

127.0.0.1:6379> zadd key7 1 zhangsan 2 lisi 3 wangwu
(integer) 3
127.0.0.1:6379> OBJECT encoding key7
"ziplist"
127.0.0.1:6379> zadd key7 4 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
(integer) 1
127.0.0.1:6379> OBJECT encoding key7
"skiplist"

使用场景

1. 排行榜系统：zset非常适合用于实现各种排行榜，如游戏排行榜、文章阅读排行榜、电商网站的销售排行榜等。你可以将用户的得分作为分数（score）存储，用户ID作为元素（member）存储。这样，你就可以通过zset的排序特性快速获取排名靠前的用户。
2. 延时队列：zset可以用来实现一个简单且高效的延时队列。你可以将任务作为元素存储，任务的执行时间作为分数存储。当任务到达执行时间时，就可以从zset中取出并执行。这种方式比使用Redis的列表（List）实现延时队列更加灵活和高效。
3. 按时间排序的数据：对于需要按照时间顺序排列的数据，如日志、事件等，zset也是一个很好的选择。你可以将时间戳作为分数存储，数据内容作为元素存储。这样，你就可以按照时间顺序快速地获取数据。
4. 唯一性约束且需要排序的场景：在某些情况下，你可能需要存储一组唯一的数据，并且这些数据还需要按照某种顺序进行排序。例如，你可能需要存储一组唯一的用户名，并且按照用户的注册时间进行排序。这时，你可以使用zset来实现这个需求。