精华内容
下载资源
问答
  • 比较两个有序集合

    2015-04-22 16:39:25
    * 两个集合有序的,从大到小的 * * 1).集合now有集合old没有的 ,添加 * * 2).集合now有集合old有的的 ,舍弃 * * 3).集合now没有但是集合old有的 ,数量标志位0 * * 4).集合now有集合old也有的 ...

    运用场景(交易所深度增量推送)

    1. [[411.8,6],[411.75,11],[411.6,22],[411.5,9],[411.3,16]]
    2. [[411.8,5],[411.7,11],[411.5,22],[411.5,9],[411.3,1]]
    import java.util.ArrayList;
    import java.util.List;
    
    public class two {
    
        public static void main(String[] args) {
    
            /**
             * 两个集合是有序的,从大到小的
             * 
             * 1).集合now有集合old没有的 ,添加
             * 
             * 2).集合now有集合old有的的 ,舍弃
             * 
             * 3).集合now没有但是集合old有的 ,数量标志位0
             * 
             * 4).集合now有集合old也有的 但是数量不一致的 变更
             */
    
            //String[] 长度为2 第一个数据为价格,第二个数据为数量
            List<String[]> now = new ArrayList<String[]>();
            List<String[]> old = new ArrayList<String[]>();
    
            StringBuilder data = new StringBuilder();// 用于拼接最后的数据
            int oldSize = old.size();
            int nowSize = now.size();
            int index = 0; // now 集合索引
            int last_index = 0;// old 集合索引
            for (int i = 0, size = oldSize + nowSize; i < size; i++) {
                if (last_index >= oldSize && index >= nowSize) {//如果两个数据的每个元素都一致
                    break;
                }
                double price = -1d;
                String amount = "";
                if (index < nowSize) { 
                    price = Double.parseDouble(now.get(index)[0]);
                    amount = now.get(index)[1];
                }
                double lastPrice = -1d;
                String lastAmount = "";
                if (last_index < oldSize) {
                    lastPrice = Double.parseDouble(old.get(last_index)[0]);
                    lastAmount = old.get(last_index)[1];
                }
    
                if (price == lastPrice) {
                    if (!amount.equals(lastAmount)) {
                        data.append("[" + price + "," + amount + "],");
                    }
                    last_index++;
                    index++;
                } else if (price > lastPrice) {
                    data.append("[" + price + "," + amount + "],");
                    index++;
                } else if (price < lastPrice) {
                    data.append("[" + price + "," + 0 + "],");
                    last_index++;
                }
    
            }
    
        }
    }
    展开全文
  • 两个有序集合之间可能进行一一对应的计算,比如两个集合如何比较大小,怎样判断集合是否相等?如何简便快捷的处理集合间的对位运算,这里为你全程解析,并提供 esProc 示例代码。有序集合间的对位运算 有序集合...

    【摘要】
        两个有序集合之间可能进行一一对应的计算,比如两个集合如何比较大小,怎样判断集合是否相等?如何简便快捷的处理集合间的对位运算,这里为你全程解析,并提供 esProc 示例代码。有序集合间的对位运算


     

    有序集合间的对位运算,包括比较运算(>,<, 等于)和四则运算(+,-,*,/,%,\)。本问中讨论的集合,都是有序集合,有序集合的成员是有次序的。有序集合间的对位运算,会按照顺序使用对位成员进行比较或者四则运算。

    1. 比较两个集合的大小

    集合可以使用符号 ">" 或 "<" 比较大小,从第一个成员开始按照顺序比较对位成员。例如 [1,3,1] 与[1,2,2]比较大小时,首先比较各自的第一个成员,1 与 1 相等;继续比较各自的第二个成员,因为 3>2,所以 [1,3,1] 大于[1,2,2],无需比较后面的成员了。

    【例 1】 以奥运会奖牌榜为例,查询哪几届奥运会中国奖牌榜排名比俄罗斯靠前。部分数据如下:

     

    Game Nation Medal Game
    30 USA 46,29,29 30
    30 China 38,27,23 30
    30 UK 29,17,19 30
    30 Russia 24,26,32 30
    30 Korea 13,8,7 30

    奥运奖牌榜的规则是:首先对比金牌数量,金牌数高的排名靠前,金牌数低的排名靠后,金牌数相同的将会按照银牌数再次对比排名。银牌数高的排名靠前,银牌数低的排名靠后,银牌数相同的将会按照铜牌数再次对比排名。以此类推,铜牌数也相同的国家排名并列。

    【SPL 脚本】

      A B
    1 =file("Olympic.csv").import@cqt() /导入奥运会历届排名
    2 =A1.run(Medal=Medal.split@c()) /奖牌字段按逗号拆分为奖牌数集合
    3 =A2.group(Game) /按每届分组
    4 =A3.select(~.select(Nation=="China").Medal>~.select(Nation=="Russia").Medal) /用 ">" 符号比较中俄的奖牌数集合大小,会按顺序依次比较金牌、银牌和铜牌数量,并选出中国排名更高的届。
    5 =A4.(Game) /列出共有哪几届

    A5的执行结果如下:

    Game
    23
    25
    28
    29
    30

     

    2. 比较两个集合是否相等

    比较两个集合是否相等是很常见的需求,比如比较文件内容是否相同,比较数据表的数值是否发生变化等。例如比较集合 [1,2,3] 和[2,1,3]是否相等。通常来说,集合的的对位成员不完全一致,认为两个集合是不相等的。但是也有时候并不在意集合的成员顺序,只需要比较两个集合是否包含了同样的成员。

    【例 2】 下面是随机抽样后生成的文件,比较两次随机抽样是否选出了相同的序号。部分数据如下:

     

    ID Predicted_Y Original_Y
    10 0.012388464367608093 0.0
    11 0.01519899123978988 0.0
    13 0.0007920238885061248 0.0
    19 0.0012656367468159102 0.0
    21 0.009460545997473379 0.0
    23 0.024176791871681664 0.0

    【SPL 脚本】

      A B
    1 =file("p_old.csv").import@ct() /读取第一次输出的文件
    2 =file("p_new.csv").import@ct() /读取第二次输出的文件
    3 =cmp(A1.(ID),A2.(ID)) /使用函数 cmp() 比较两次生成的 ID 是否完全相同(成员值相等且顺序一致)

    A3的执行结果如下:

    Member
    0

    结果为 0 表示两个文件 ID 完全一致。

        如果 ID 的顺序可能不同,可以使用函数 eq() 比较两个集合的成员是否相同:

      A B
    3 =A1.(ID).eq(A2.(ID)) /使用函数 eq() 比较两次生成的 ID 值是否相同,不要求顺序一致。

     

     

    3. 集合成员的对位计算

    集合成员的对位计算,支持 +,-,*,/,%,\ 等四则运算。例如 3 天内 A 商店的销售额集合是 [2,3,4],B 商店的销售额集合是 [3,1,3],我们希望得到两个商店的销售额之和的集合 [5,4,7]。

    【例 3】 求 2019 年 12 月 24 日到 26 日深证 300 (399007) 对深证成指 (399001) 的每日相对收益率。部分数据如下:

     

    Date Code Name Open Close Amount
    2020/2/18 399001 Shenzhen 11244.7651 11306.4863 3.19E+11
    2020/2/17 399001 Shenzhen 10974.9328 11241.4993 3.12E+11
    2020/2/14 399001 Shenzhen 10854.4551 10916.3117 2.77E+11
    2020/2/13 399001 Shenzhen 10936.5011 10864.3222 2.87E+11
    2020/2/12 399001 Shenzhen 10735.0475 10940.7952 2.66E+11

    【SPL脚本】

      A B
    1 =connect("db") /连接数据源
    2 =["399007","399001"].(A1.query("select   * from StockIndex where code=? and date between'2019-12-23'and  '2019-12-26'",~)) /读取深证 300 和深证成指在 2019 年 12 月 23 日到 26 日的数据,取 23 日是为了计算涨幅
    3 =A2.(~.calc(to(2,4),Close/Close[-1])) /分别计算 24 到 26 日每天的涨幅
    4 =A3(1)--A3(2) /使用符号 "--" 将两个集合对位相减,即是相对收益率。符号??(?∈{+,-,*,/,%,\})用于两个集合中成员的对位计算。

    A4的执行结果如下:

    Member
    0.0031349096521252617
    0.0011897141619391371
    -4.4910504685946595E-4

     

    SPL CookBook》中还有更多相关计算示例。

    展开全文
  • redis有序集合的理解

    2019-10-17 14:41:52
    Redis 有序集合和集合一样也是 string 类型元素的集合,且不允许重复的成员。 不同的是每个元素都会关联一个 double 类型的分数(不是1/3,1/2这种分数,是一个用来比较大小的数字)。redis 正是通过分数来为集合中...

    Redis 有序集合和集合一样也是 string 类型元素的集合,且不允许重复的成员。

    不同的是每个元素都会关联一个 double 类型的分数(不是1/3,1/2这种分数,是一个用来比较大小的数字)。redis 正是通过分数来为集合中的成员进行从小到大的排序。

    有序集合的成员是唯一的,但分数 (score) 却可以重复。

    集合是通过哈希表实现的,所以添加,删除,查找的复杂度都是 O (1)。 集合中最大的成员数为 2^32 - 1^ (4294967295, 每个集合可存储 40 多亿个成员)。

    有序集合首先是集合,其成员(member)具有唯一性,其次,每个成员关联了一个分数(score),使得成员可以按照分数排序。

    需求描述

    设想在一个游戏中,有上百万的玩家数据,如果现在需要你根据玩家的经验值整理一个前 10 名的排行榜,你会怎么做呢?一般的做法是写一条类似下面这条 sql 语句的方式来获取:

    1

    select * from game_socre order by score desc limit 0,20

    这种方式在数据量较小的情况下可行,但是在数据量大的情况下查询速度将变慢,特别是还需要联表查询时,速度下降的就更明显了。

    实现

    这时你可以考虑使用 redis 来实现这个功能。

    实现这个功能主要用到的 redis 数据类型是 redis 的有序集合 zset。zset 是 set 类型的一个扩展,比原有的类型多了一个顺序属性。此属性在每次插入数据时会自动调整顺序值,保证 value 值按照一定顺序连续排列。

    主要的实现思路是:

    1、在一个新的玩家参与到游戏中时,在 redis 中的 zset 中新增一条记录(记录内容看具体的需求)score 为 0

    2、当玩家的经验值发生变化时,修改该玩家的 score 值

    3、使用 redis 的 ZREVRANGE 方法获取排行榜

    返回有序集 key 中,指定区间内的成员。其中成员的位置按 score 值递减 (从大到小) 来排列。具有相同 score 值的成员按字典序的反序排列。 除了成员按 score 值递减的次序排列这一点外,ZREVRANGE 命令的其他方面和 ZRANGE 命令一样。

    1

    redis 127.0.0.1:6379> ZADD KEY_NAME SCORE1 VALUE1.. SCOREN VALUEN

    1、数据准备

    b9c118380d12cbd9350fb4b7f028b3c.png

    2、获取 score 高分 top10 排名 (ZREVRANGE 为降序,ZRANGE 为升序)

    1e8c358b8a6d91ebb01119036852138.png

    3、查看用户 ee 的实际排名 (ZREVRANK 为降序,ZRANK 为升序)、实时分数

    54cae0fd18770201b8dbb09cff6f856.png

    展开全文
  • TreeSet有序集合

    2018-12-08 20:12:00
    TreeSet是一个能够有序存储的容器,里面的元素都按照从小到大排列。 里面元素的能比较大小,是由于这些元素实现了Comparable<T>接口,实现这一接口要求实现int compareTo(T t)方法。 假设A实现了Comparable<...

    TreeSet是一个能够有序存储的容器,里面的元素都按照从小到大排列。

    里面元素的能比较大小,是由于这些元素实现了Comparable<T>接口,实现这一接口要求实现int compareTo(T t)方法。

    假设A实现了Comparable<A>, a和b为A的对象,则:
    a.compareTo(b),若返回:

    • 正数说明 a>b
    • 负数说明 a<b
    • 0则说明 a=b

    如果想让a,b在TreeSet里排列顺序为a --> b,则让a.compareTo(b)返回负数

    转载于:https://www.cnblogs.com/xuejianbest/p/10285294.html

    展开全文
  • 将两个有序字符串集合排序成一个新的有序集合: 思路:这里采用指针的形式,如果两个指针没有指到’\0’,则通过比较得出先后顺序,另外就是两中情况,分别在下面代码中体现出来了。 #include <stdio.h> void ...
  • 【摘要】 ...定位成员是指在有序集合中通过比较成员来查找位置。 【例 1】 下面任课教师表中,第一列是教师姓名,第二列是学科,后面是课程代码(null 表示空)。任课教师表部分数据如下: Teachers...
  • 两个有序集合求交集

    2020-06-23 16:43:30
    有序集合1{1,3,5,7,8,9} 有序集合2{2,3,4,5,6,7} 两个指针指向首元素,比较元素的大小: (1)如果相同,放入结果集,随意移动一个指针; (2)否则,移动值较小的一个指针,直到队尾; 这种方法的好处是: (1)...
  • •在集合类型的基础上,有序集合类型为集合中的每个元素都关联了一个分数,使得在完成插入、删除的集合类型的操作时,还能够获得分数最高(或最低)的前N个元素等与分数有关的操作。 •集合元素具有唯一性,但是分数...
  • Redis使用跳跃表作为有序集合键的的底层实现,如果一个有序集合包含的元素数量比较多,又或者有序集合中元素的成员是比较长的字符串时Redis就会使用跳跃表 来作为有序集合键的底层实现 Redis只在两个地方用到了跳跃...
  • 在集合的基础上,为每元素排序,元素的排序需要根据另外一个值来进行比较,所以,对于有序集合,每一个元素有两个值,即:值和分数,分数专门用来做排序。 zadd(name, *args, **kwargs) #在name对应的有序集合中添加...
  • 今天来剖析一个比较有意思的数据类型—— 有序集合zset,说实话,它的源码真的是多,而且繁琐,不过,其中的一部分在Redis源码剖析–跳跃表zskiplist中分析过了。有序集合到底是什么呢?有序集合里面存放的元素都...
  • 在集合类型的基础上,有序集合类型为集合中的每个元素都关联了一个分数,使得在完成插入、删除的集合类型的操作时,还能够获得分数最高(或最低)的前N个元素等与分数有关的操作。 集合元素具有唯一性,但是分数可以...
  • Spring cloud是一系列框架的有序集合。它基于Spring boot,简化了分布式系统基础设施的开发:服务注册、配置中心、消息总线、负载均衡、数据监控等。Spring cloud将各种比较成熟的服务框架组合起来,通过Springboot...
  • Redis跳表与有序集合实现

    千次阅读 2018-10-21 15:06:01
    为了大家看整体源码方便,我将加上了完整注释的代码传到了我的github上供...在Redis中提供了有序集合,从它的命令之多就可以知道它的功能是比较强大的,当然实现也是比较复杂的,ZSET底层使用跳表SKIP LIST实现,...
  • 有两点让我认为TreeSet能够帮我快速获得有序的学生集合: (1)TreeSet基于红黑树实现,而红黑树是一个平衡二叉树,也就说,它的排序时间复杂度是nlognnlogn; (2)在插入的初期lognlogn较小。
  • reids缓存数据库-zset(有序集合)操作 有序集合,在集合的基础上,为每个元素添加分值再排序;而元素的排序需要根据另一个值来进行比较 所以,对于有序集合,每个元素都有两个值,即:值和分数,分数是专门来用来...
  • Redis 有序集合和集合一样也是string类型元素的集合,且不允许重复的成员。 不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。 有序集合的成员是唯一的,但...
  • 元素的排序需要根据另外一个值来进行比较,所以,对于有序集合,每一个元素有两个值,即:值和分数,分数专门用来做排序。 zadd(name, *args, **kwargs) # 在name对应的有序集合中添加元素 # 如: # zadd('zz...
  • Redis 当一个有序集合包含的元素数量多,又或者有序集合中的元素的成员是比较长的字符串时,Redis就会使用跳跃表作为有序集合键的底层实现 跳跃表的基本思想 首先我们看一个普通的链表结构: 这个链表中,如果要...
  • 集合 VS 有序集合 列表 VS 有序集合 重要API,有序集合的操作以Z为开头的命令。 这里score可以重复,element不可以重复。 实战: 其他操作: 案例演示: ...
  • 在集合的基础上,为每元素排序,元素的排序需要根据另外一个值来进行比较,所以,对于有序集合,每一个元素有两个值,即:值和分数,分数专门用来做排序。 有序集合常用方法 zadd(name, mapping):在name对应的...
  • 有序集合对象的底层实现类型如下表: 编码—encoding 对象—ptr OBJ_ENCODING_SKIPLIST 跳跃表和字典实现的有序集合对象 OBJ_ENCODING_ZIPLIST 压缩列表实现的有序集合对象 关于底层的数据...
  • 文章目录1. 跳跃表的实现2. 跳跃表节点2.1 层2.2 前进指针2.3 跨度...Redis 使用跳跃表作为有序集合键的底层实现之一: 如果一个有序集合包含的元素数量比较多, 又或者有序集合中元素的成员(member)是比较长的字符
  • 元素的排序需要根据另外一个值来进行比较,所以,对于有序集合,每一个元素有两个值,即:值和分数,分数专门用来做排序。 zadd(name, *args, **kwargs) #在name对应的有序集合中添加元素 --------------------...
  • 在Redis中的有序集合(Sorted Set)就是用跳表来实现的。 二 跳表 对于一个存储的数据是有序的链表来说,如果我们想要在该链表中查找某个数据,也必须从头到尾遍历链表,这样查询的效率就会很低,时间复杂度为O(n)...
  • Redis最后一种类型是有序集合类型ZSet,即排序的Set,但又与Set不同的是,它比Set多一个字段分数(score)用于排序等操作,从这点来看,相当于Java中的TreeMap,但与Java的TreeMap不同的是,TreeMap排序是指定...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,135
精华内容 1,254
关键字:

有序集合比较