Redis之 有序集合（SortedSets）

最新推荐文章于 2025-06-23 12:43:47 发布
最新推荐文章于 2025-06-23 12:43:47 发布
阅读量2.2k 收藏 2
点赞数 2
CC 4.0 BY-SA版权
分类专栏： Redis 文章标签： c# hash List Sets redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wdeng2011/article/details/78524619

有序集合是一个数据类型，这是一种类似于集和哈希的混合。像集合一样，排序集由唯一的、不重复的字符串元素组成，因此在某种意义上，排序集也是一组集合。

虽然set中的元素没有被排序，但排序集中的每个元素都与一个浮点值相关联，这个值称为得分（这也是为什么该类型与哈希类似，因为每个元素都映射到一个值）。

Sorted sets,类似Sets,但是每个字符串元素都关联到一个叫score浮动数值（floating number value）。里面的元素总是通过score进行着排序，所以不同的是，它是可以检索的一系列元素。（例如你可能会问：给我前面10个或者后面10个元素）。

1、添加

        /// <summary>
        /// 添加setId/value，默认分数是从1.多*10的9次方以此递增的,自带自增效果
        /// 将所有指定成员添加到键为key有序集合（sorted set）里面。 添加时可以指定多个分数/成员（score/member）对。 
        /// 如果指定添加的成员已经是有序集合里面的成员，则会更新改成员的分数（scrore）并更新到正确的排序位置。
        /// 原指令：ZADD key [NX|XX] [CH] [INCR] score member [score member ...]
        /// 时间复杂度：O(log(N)) 
        /// 参考：http://www.redis.cn/commands/zadd.html
        /// </summary>
        public bool AddItemToSortedSet(string setId, string value)
        {
            return Redis.AddItemToSortedSet(setId, value);
        }
        /// <summary>
        /// 添加setId/value,并设置value的分数
        /// </summary>
        public bool AddItemToSortedSet(string setId, string value, double score)
        {
            return Redis.AddItemToSortedSet(setId, value, score);
        }
        /// <summary>
        /// 为setId添加values集合，values集合中每个value的分数设置为score
        /// </summary>
        public bool AddRangeToSortedSet(string setId, List<string> values, double score)
        {
            return Redis.AddRangeToSortedSet(setId, values, score);
        }
        /// <summary>
        /// 为setId添加values集合，values集合中每个value的分数设置为score
        /// </summary>
        public bool AddRangeToSortedSet(string setId, List<string> values, long score)
        {
            return Redis.AddRangeToSortedSet(setId, values, score);
        }

        /// <summary>
        /// 以setId集合为value的数据，分数加scoreby，返回相加后的分数
        /// 原指令：ZINCRBY key increment member
        /// 时间复杂度：O(log(N)) 
        /// 参考：http://www.redis.cn/commands/zincrby.html
        /// </summary>
        public double IncrementItemInSortedSet(string setId, string value, double scoreBy)
        {
            return Redis.IncrementItemInSortedSet(setId, value, scoreBy);
        }


2、获取 

        /// <summary>
        /// 获取key的所有集合
        /// 原指令：ZRANK key member
        /// 时间复杂度：O(log(N)) 
        /// 参考：http://www.redis.cn/commands/zrank.html
        /// </summary>
        public List<string> GetAllItemsFromSortedSet(string setId)
        {
            return Redis.GetAllItemsFromSortedSet(setId);
        }
        /// <summary>
        /// 获取key的所有集合，倒序输出
        /// </summary>
        public List<string> GetAllItemsFromSortedSetDesc(string setId)
        {
            return Redis.GetAllItemsFromSortedSetDesc(setId);
        }

        /// <summary>
        /// 获取所有的集合，带分数
        /// </summary>
        public IDictionary<string, double> GetAllWithScoresFromSortedSet(string setId)
        {
            return Redis.GetAllWithScoresFromSortedSet(setId);
        }
        /// <summary>
        /// 获取key为value的下标值
        /// </summary>
        public long GetItemIndexInSortedSet(string setId, string value)
        {
            return Redis.GetItemIndexInSortedSet(setId, value);
        }
        /// <summary>
        /// 倒序排列获取key为value的下标值
        /// </summary>
        public long GetItemIndexInSortedSetDesc(string setId, string value)
        {
            return Redis.GetItemIndexInSortedSetDesc(setId, value);
        }

        /// <summary>
        /// 获取key为value的分数
        /// 原指令：ZSCORE key member
        /// 时间复杂度：O(1) 
        /// 参考：http://www.redis.cn/commands/zscore.html
        /// </summary>
        public double GetItemScoreInSortedSet(string setId, string value)
        {
            return Redis.GetItemScoreInSortedSet(setId, value);
        }

        /// <summary>
        /// 获取key集合从低分到高分排序数据，分数从fromscore到分数为toscore的数据
        /// 元素被认为是从低分到高分排序的。
        /// 原指令：ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]
        /// 时间复杂度：O(log(N)+M)
        /// 参考：http://www.redis.cn/commands/zrangebyscore.html
        /// </summary>
        public List<string> GetRangeFromSortedSetByLowestScore(string setId, double fromScore, double toScore)
        {
            return Redis.GetRangeFromSortedSetByLowestScore(setId, fromScore, toScore);
        }

        /// <summary>
        /// 获取key集合从高分到低分排序数据，分数从fromscore到分数为toscore的数据
        /// </summary>
        public List<string> GetRangeFromSortedSetByHighestScore(string setId, double fromScore, double toScore)
        {
            return Redis.GetRangeFromSortedSetByHighestScore(setId, fromScore, toScore);
        }

        /// <summary>
        /// 获取key集合从高分到低分排序数据，分数从fromscore到分数为toscore的数据，带分数
        /// </summary>
        public IDictionary<string, double> GetRangeWithScoresFromSortedSetByHighestScore(string setId, double fromScore, double toScore)
        {
            return Redis.GetRangeWithScoresFromSortedSetByHighestScore(setId, fromScore, toScore);
        }
        /// <summary>
        /// 获取key集合从低分到高分排序数据，分数从fromscore到分数为toscore的数据，带分数
        /// </summary>
        public IDictionary<string, double> GetRangeWithScoresFromSortedSetByLowestScore(string setId, double fromScore, double toScore)
        {
            return Redis.GetRangeWithScoresFromSortedSetByLowestScore(setId, fromScore, toScore);
        }


        /// <summary>
        /// 获取key集合数据，下标从fromRank到分数为toRank的数据
        /// 原指令：ZRANGEBYLEX key min max [LIMIT offset count]
        /// 时间复杂度：O(log(N)+M)
        /// 参考：http://www.redis.cn/commands/zrangebylex.html
        /// </summary>
        public List<string> GetRangeFromSortedSet(string setId, int fromRank, int toRank)
        {
            return Redis.GetRangeFromSortedSet(setId, fromRank, toRank);
        }
        /// <summary>
        /// 获取key集合倒叙排列数据，下标从fromRank到分数为toRank的数据
        /// </summary>
        public List<string> GetRangeFromSortedSetDesc(string setId, int fromRank, int toRank)
        {
            return Redis.GetRangeFromSortedSetDesc(setId, fromRank, toRank);
        }
        /// <summary>
        /// 获取key集合数据，下标从fromRank到分数为toRank的数据，带分数
        /// </summary>
        public IDictionary<string, double> GetRangeWithScoresFromSortedSet(string setId, int fromRank, int toRank)
        {
            return Redis.GetRangeWithScoresFromSortedSet(setId, fromRank, toRank);
        }
        /// <summary>
        ///  获取key集合倒叙排列数据，下标从fromRank到分数为toRank的数据，带分数
        /// </summary>
        public IDictionary<string, double> GetRangeWithScoresFromSortedSetDesc(string setId, int fromRank, int toRank)
        {
            return Redis.GetRangeWithScoresFromSortedSetDesc(setId, fromRank, toRank);
        }


3、总记录数 

        /// <summary>
        /// 获取key所有集合的数据总数
        /// 原指令：ZCARD key
        /// 时间复杂度：O(1) 
        /// 参考：http://www.redis.cn/commands/zcard.html
        /// </summary>
        public long GetSortedSetCount(string setId)
        {
            return Redis.GetSortedSetCount(setId);
        }

        /// <summary>
        /// key集合数据从分数为fromscore到分数为toscore的数据总数
        /// </summary>
        public long GetSortedSetCount(string setId, double fromScore, double toScore)
        {
            return Redis.GetSortedSetCount(setId, fromScore, toScore);
        }

        public long GetSortedSetCount(string setId, long fromScore, long toScore)
        {
            return Redis.GetSortedSetCount(setId, fromScore, toScore);
        }

        /// <summary>
        /// 用于计算有序集合中指定成员之间的成员数量。
        /// 原指令：ZLEXCOUNT key min max
        /// 时间复杂度：O(log(N))
        /// 参考：http://www.redis.cn/commands/zlexcount.html
        /// </summary>
        /// <param name="key"></param>
        /// <param name="fromScore"></param>
        /// <param name="toScore"></param>
        /// <returns></returns>
        public long GetSortedSetCount(string setId, string fromScore, string toScore)
        {
            return Redis.GetSortedSetCount(setId, fromScore, toScore);
        }

4、删除 

        /// <summary>
        /// 删除key为value的数据
        /// 原指令：ZREM key member [member ...]
        /// 时间复杂度：O(M*log(N)) 
        /// 参考：http://www.redis.cn/commands/zrem.html
        /// </summary>
        public bool RemoveItemFromSortedSet(string setId, string value)
        {
            return Redis.RemoveItemFromSortedSet(setId, value);
        }

        /// <summary>
        /// 删除下标从minRank到maxRank的key集合数据
        /// 原指令：ZREMRANGEBYRANK key start stop
        /// 时间复杂度：O(M*log(N)) 
        /// 参考：http://www.redis.cn/commands/zremrangebyrank.html
        /// </summary>
        public long RemoveRangeFromSortedSet(string setId, int minRank, int maxRank)
        {
            return Redis.RemoveRangeFromSortedSet(setId, minRank, maxRank);
        }

        /// <summary>
        /// 删除分数从fromscore到toscore的key集合数据
        /// 原指令：ZREMRANGEBYSCORE key min max
        /// 时间复杂度：O(M*log(N)) 
        /// 参考：http://www.redis.cn/commands/zremrangebyscore.html
        /// </summary>
        public long RemoveRangeFromSortedSetByScore(string setId, double fromscore, double toscore)
        {
            return Redis.RemoveRangeFromSortedSetByScore(setId, fromscore, toscore);
        }
        /// <summary>
        /// 删除key集合中分数最大的数据 
        /// </summary>
        public string PopItemWithHighestScoreFromSortedSet(string setId)
        {
            return Redis.PopItemWithHighestScoreFromSortedSet(setId);
        }
        /// <summary>
        /// 删除key集合中分数最小的数据
        /// </summary>
        public string PopItemWithLowestScoreFromSortedSet(string setId)
        {
            return Redis.PopItemWithLowestScoreFromSortedSet(setId);
        }

5、获取交集 并集 


        /// <summary>
        /// 获取keys多个集合的交集，并把交集添加的newkey集合中，返回交集数据的总数
        /// 计算给定的numkeys个有序集合的交集，并且把结果放到destination中。 在给定要计算的key和其它参数之前，必须先给定key个数(numberkeys)。
        /// 默认情况下，结果中一个元素的分数是有序集合中该元素分数之和，前提是该元素在这些有序集合中都存在。
        /// 因为交集要求其成员必须是给定的每个有序集合中的成员，结果集中的每个元素的分数和输入的有序集合个数相等。
        /// 原指令：ZINTERSTORE destination numkeys key [key ...] [WEIGHTS weight] [SUM|MIN|MAX]
        /// 时间复杂度：O(N*K)+O(M*log(M))
        /// 参考：http://www.redis.cn/commands/zinterstore.html
        /// </summary>
        public long StoreIntersectFromSortedSets(string newSetId, string[] keys)
        {
            return Redis.StoreIntersectFromSortedSets(newSetId, keys);
        }


        /// <summary>
        /// 获取keys多个集合的并集，并把并集数据添加到newkey集合中，返回并集数据的总数
        /// 原指令：ZUNIONSTORE destination numkeys key [key ...] [WEIGHTS weight] [SUM|MIN|MAX]
        /// 时间复杂度：O(N*K)+O(M*log(M))
        /// 参考：http://www.redis.cn/commands/zunionstore.html
        /// </summary>
        public long StoreUnionFromSortedSets(string newSetId, string[] keys)
        {
            return Redis.StoreUnionFromSortedSets(newSetId, keys);
        }

6、其它 

        /// <summary>
        /// 判断key集合中是否存在value数据
        /// </summary>
        public bool SortedSetContainsItem(string setId, string value)
        {
            return Redis.SortedSetContainsItem(setId, value);
        }


有序集合SortedSet实战之简介与常用命令
weixin_37841366的博客
10-18 614
Redis有序集合和集合一样也是string类型元素的集合，且不允许重复的成员 不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序 有序集合的成员是唯一的，但分数（score）却可以是重复的 集合是通过哈希表实现的，所以添加、删除、查找的时间复杂度为O(1)。集合中最大的成员数为2^32 -1，每个集合可存储40多亿个成员。 常见命令 zadd sortset 1 a zadd sortset 2 b zadd sortset 3c .
sortedset
run bird 的专栏
07-01 675
sortedset 是有序set，已经实现类有两个treeset concurrent
Redis Sorted Set（有序集合）从入门到精通：核心原理+实战场景全解析
最新发布
weixin_42148384的博客
06-23 1064
在Redis的六大核心数据结构（String、Hash、List、Set、Sorted Set、Bitmap）中，**Sorted Set（有序集合）** 一直被称为“最全能选手”——它既有Set的元素唯一性，又有List的排序能力，还支持高效的分数操作和范围查询。无论是游戏排行榜、实时热搜，还是延迟队列，Sorted Set都能轻松搞定。本文，笔者将从**核心特性、底层原理、常用命令、实战场景**四个维度，带你彻底掌握Sorted Set，看完直接上手开发！
【Redis缓存机制】7.SortSet排序集合类型操作
程序猿之洞
11-23 7511
Sort Set排序集合类型 (1)介绍 和set一样sorted set也是string类型元素的集合， 不同的是每个元素都会关联一个权。 通过权值可以有序的获取集合中的元素 该Sort Set类型适合场合: 获得热门帖子(回复量)信息:select * from message order by backnum desc linit 5; （以上需求可以通过简单sql
Redis的SortSet(有序集合)
Java面试辅导-海龟老师
12-15 2921
1、 sortedSet存储内容示意图：  sortedSet会按照字段进行排序     2、 往redis库中插入一条sortedset数据 redis 127.0.0.1:6379> zadd nanshen:yanzhi:bang  70 liudehua  90 huangbo  100 weixiaobao  250 yanggang  59 xiaotao
redis-sort set
yxpjx的专栏
05-08 876
有序集合 sorted set和set一样也是string类型元素的集合，不同的是每个元素都会关联一个double类型的score。sorted set的实现是skip list（跳表）和hash table的混合体当元素被添加到集合中时，一个元素到score的映射被添加到hash table中，所以给定一个元素获取score的开销是O(1)，另一个score到元素的映射被添加到skip
redis 运维之道 good
06-09
- **SortedSets**：对于有序集合数据结构，可以通过限制字段和分数的整型表示来提高性能。 - **Hashes**：通过直接将哈希结构存储到RDB中，可以减少内存占用并提高读写效率。 - **RedisCounter**：对于计数器类的...
《Redis实战》电子书
06-19
- **数据类型**：包括字符串（strings）、散列（hashes）、列表（lists）、集合（sets）以及有序集合（sorted sets）等多种类型。 - **持久化**：支持两种持久化方式——RDB（快照）和AOF（日志）。 - **主从同步**...
Redis实战.pdf
11-07
- Redis支持多种数据类型，如字符串(String)、散列(Hash)、列表(List)、集合(Set)、有序集合(Sorted Set)等。 - **1.3.2 持久化** - Redis提供了两种持久化方式：RDB（快照）和AOF（Append Only File），以确保...
redis实战 完整版
10-28
- **zrevrange**: 返回有序集合中指定区间的成员，成员的位置按分数值递减排序。 - **zrangebyscore**: 返回有序集合中指定分数区间内的所有成员。 - **zcount**: 计算在有序集合中指定分数区间内成员的数量。 - **...
redis实战中文 pdf
10-10
- **zincrby**: 对有序集合中的元素的分数进行递增/递减操作。 - **zrank/zrevrank**: 获取成员的排名。 - **zrange/zrevrange**: 获取指定范围内的成员。 - **zrangebyscore**: 获取指定分数范围内的成员。 - **...
Redis 数据结构之有序集合（sort set）
seeingme的博客
01-14 636
有序集合sortset的元素包括score(分数，int/float) ,value（成员，string/int/float） ,rank等三个属性， (1)实际上是score 和 value的映射； (2)value 在有序集合中必须是唯一的，score可以重复； (3)rank 从0 开始，score越大，rank值越大，相同分数，value中的字母在字典中越后，rank值越大； 12
redis sorted_set 命令操作
weixin_34097242的博客
04-05 148
score 是set排序的值，越大越在前 1.添加 成员到sorted_set中，并设置score ZADD key score member [score member ...] summary: Add one or more members to a sorted set, or update its score if it already e...
redis之sortedSet操作
凌夜知惜
02-23 1265
添加一个或多个元素 zadd key score1 member1 [score2 member2] 移除一个或多个元素 ZREM key member [member ...] 显示某一个成员的分值 ZSCORE key member 对某个成员的分值做增减 ZINCRBY key increment member 获取某个元素的索引(实时索引) ZRANK key member 因为Sorte...
redis 学习笔记4--sortset
知行天下
07-26 162
redis学习笔记3--sortSet 终于到最后一个数据结构了，加油！！ 整体结构图： http://dl.iteye.com/upload/picture/pic/115995/0ee3789f-33e1-35ca-ac65-cbd6b4e4e147.jpg     1.ZADD 语法： ZADD key score value  释义：添加执行分数的value， sco...
Redis | Redis基本数据类型命令---Set集合、SortSet集合
quwenjing_blog
11-19 2056
目录 Redis的基本数据类型 1. Set：集合 sadd smembers sismember scard srem srandmember spop smove sinter、sunion、sdiff 2. SortSet：有序集合 zadd zrange zrangebyscore zrem zcard zcount Redis的基本数据类型 1. Set：集合 redis中的set是String类型的无序集合，数据是无序的，并且属性元素是唯一的，意味着.
Redis有序集合（Zset/Sort-set）
YoYuanZhizheng的博客
12-30 1589
内容来源于B站【尚硅谷】Redis 6 入门到精通 超详细 教程，在此仅作为个人的笔记、手册使用 1.简介 1.Sort-set和set非常相似，都是自动去重的字符串集合 2.不同之处在于Sort-set里每个成员关联一个评分Score，由评分从低到高排序，评分是可以重复的，但是元素一定是不重复的 3.元素是有序的，你可以根据评分或者位置（即下标）来快速获取某个范围的元素 4.访问Sort-set的中间元素也是非常快的，这一点比list优秀 ...
Redis 数据类型 sorted sets 类型
PyTi
01-30 451
sorted sets类型及操作 sorted set是set的一个升级版本, 它在set的基础上增加了一个顺序属性. 这一属性在添加修改元素的时候可以指定. 每次指定后, zset会自动重新按新的值调整顺序. 可以理解为有两列单的mysql表, 一列存value, 一列存顺序. 操作中可以理解为zset的名字. zadd 向名称为key的zset中添加元素member, s
Redis 数据类型及操作之 sorted sets 类型
chunqizhi
04-07 418
本文主要参考红丸出品的《Redis实战》，稳定版本为 2.2.12。 sorted sets 类型及操作 1.1 zadd 向 zset 中添加元素 member，score 用于排序。如果改元素已存在，则只更新 score 值。 zadd myzset 10 member 1.2 zrange 返回 zset 中的所有元素，参数 withscore 表示也返回 score 信息，并按照 sco...
Redis 3.0 教程：官方文档中文版解读
- 有序集合(Sortedsets)：带有分数的集合，可以按分数排序。 - 位图(Bitmaps)：利用二进制位表示状态，适合处理布尔值或计数问题。 - 超重对数(HyperLogLogs)：近似计数，低空间需求，适用于统计唯一用户等。 3...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值