精华内容
下载资源
问答
  • 一、 有序对 、 二、 有序对性质引理、定理 、 三、 有序三元组 、 四、 有序 n 元组性质定理 、





    一、 有序对



    有序对概念 :

    <a,b>={{a},{a,b}}<a, b> = \{ \{ a \} , \{ a , b \} \}

    其中 aa 是第一个元素 , bb 是第二个元素 ;

    记做 <a,b><a, b> , 也可以记做 (a,b)(a , b)


    理解 1 : a,ba, b 是有顺序的 , 单个元素的集合中的元素是第一个元素 , 两个元素集合中的另一个元素是第二个元素 ;

    理解 2 ( 推荐 ) : 第一个元素出现在每个子集合中 , 第二个元素只出现在一个子集合中 , 通过这种方式 , 保证了有序对的定义 , 一前一后两个元素 , 前后顺序不同 , 对应的有序对不同 ;


    下面是相同的两个元素的不同的有序对 :

    有序对 <a,b>={{a},{a,b}}<a, b> = \{ \{ a \} , \{ a , b \} \}

    有序对 <b,a>={{b},{a,b}}<b, a> = \{ \{ b \} , \{ a , b \} \}





    二、 有序对性质的引理、定理



    1. 引理 1 : {x,a}={x,b}\{ x , a \} = \{ x, b \} \Leftrightarrow a=ba=b

    两个集合如果相等 , 当且仅当 a=ba = b ;



    2. 引理 2 :A=B\mathscr{A} = \mathscr{B} \not= \varnothing , 则有

    A=B\bigcup \mathscr{A} = \bigcup \mathscr{B}

    A=B\bigcap \mathscr{A} = \bigcap \mathscr{B}


    说明 : 集族 A\mathscr{A} 与 集族 B\mathscr{B} 相等 , 并且 两个集族都不为空 , 那么 两个集族的广义交相等 , 两个集族的广义并也相等 ;



    3. 定理 : <a,b>=<c,d><a,b> = <c, d> \Leftrightarrow a=cb=da = c \land b = d

    通过上述定理 , 说明有序对是有顺序的 ;



    4. 推论 : aba \not= b \Rightarrow <a,b><b,a><a,b> \not= <b, a>





    三、 有序三元组



    有序三元组 :

    <a,b,c>=<<a,b>,c><a, b, c> = < <a, b> , c >

    有序三元组是有序二元组在前 , 第三个元素在后 , 组成的有序对 ;


    有序 nn 元祖 : n2n \geq 2

    <a1,a2,,an>=<<a1,,an1>,an><a_1, a_2, \cdots , a_n> = < <a_1, \cdots , a_{n-1}> , a_n >

    先拿前 n1n-1 个元素组成一个有序 n1n-1 元祖 , n1n-1 元祖在前 , 然后跟第 nn 个元素 ana_n 在后 , 构成有序对 ;





    四、 有序 n 元组性质定理



    有序 nn 元组性质定理 :

    <a1,a2,,an>=<b1,b2,,bn><a_1, a_2, \cdots , a_n> = <b_1, b_2, \cdots , b_n> \Leftrightarrow ai=bi,i=1,2,,na_i = b_i , i = 1, 2, \cdots , n

    说明 : 两个有序 nn 元祖 , 每个对应位置上的元素两两相同 , 两个 nn 元组有序对才相等 ;

    展开全文
  • 本篇说一下Redis中 有序集合类型,曾几何时,我们想把所有数据存到内存中 数据结构 中,但为了多机器共享内存,不得不将这块内存包装成wcf单独部署,同时还要考虑怎么序列化,烦心事太...

    本篇说一下Redis中的 有序集合类型,曾几何时,我们想把所有数据存到内存中的 数据结构 中,但为了多机器共享内存,不得不将这块内存包装成wcf单独部署,同时还要考虑怎么序列化,烦心事太多太多。。。后来才知道有redis这么????????的东西,能把高级的,低级的数据结构单独包装到一个共享内存中。

    一:有序集合(SortedSet)

    可能有些初次接触SortedSet集合的朋友可能会说,这个集合的使用场景都有哪些???我可以明确的告诉你:范围查找 的天敌就是有序集合,任何大数据量下,查找一个范围的时间复杂度永远都是 O[(LogN)+M],其中M:返回的元素个数,为了从易到难,我们还是先看一下redis手册,挑选几个我们常用的方法观摩观摩效果。

    从上面的17个命令中,毫无疑问,常用的命令为ZADD,ZREM,ZRANGEBYSCORE,ZRANGE。

    1. ZADD

    
    ZADD key score member [[score member] [score member] ...]
    将一个或多个 member 元素及其 score 值加入到有序集 key 当中。
    
    

    这个是官方的解释,赋值方式和hashtable差不多,只不过这里的key是有序的而已。下面我举个例子:我有一个fruits集合,其中记录了每个水果的price,然后我根据price的各种操作来获取对应的水果信息。

    有了上面的基本信息,接下来我逐一送他们到SortedSet中,如下图:

    从上面的图中,不知道你有没有发现到什么异常???至少有两种。

    • 浮点数近似值的问题,比如grape,我在add的时候,写明的是2.8,在redis中却给我显示近似值2.79999....,这个没关系,本来就是这样。

    • 默认情况下,SortedSet是以key的升序排序的方式进行存放。

    2.  ZRANGE,ZREVRANGE

    
    ZRANGE key start stop [WITHSCORES]
    
    返回有序集 key 中,指定区间内的成员。
    
    其中成员的位置按 score 值递增(从小到大)来排序。
    
    

    上面就是ZRange的格式模版,前面我在说ZAdd的时候其实我也已经说了,但是这个不是重点,在说ZAdd的时候留下了一个问题就是ZRange,默认是按照key升序排序的, 对吧,那如果你想倒序显示的话,怎么办呢???其实你可以使用ZRange的镜像方法ZREVRANGE 即可,如下图:

    3. ZRANGEBYSCORE

    
    ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]
    
    返回有序集 key 中,所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。
    
    

    这个算是对SortedSet来说最最重要的方法了,文章开头我也说了,有序集合最利于范围查找,既然是查找,你得有条件对吧,下面我举个例子:

    • 我要找到1-4块钱的水果种类,理所当然,我会找到 葡萄,苹果,如下图:

    
    127.0.0.1:6379> zrangebyscore fruits 1 4  withscores
    1) "grape"
    2) "2.7999999999999998"
    3) "apple"
    4) "3.5"
    127.0.0.1:6379> 
    
    
    • 我要找到1-4区间中最接近4块的水果是哪个???这个问题就是要找到apple这个选项,那如果找到呢???仔细想想我可以这么做,将1-4区间中的所有数倒序再取第一条数据即可,对吧,如下代码。

    
    127.0.0.1:6379> zrevrangebyscore fruits 4 1 withscores
    1) "apple"
    2) "3.5"
    3) "grape"
    4) "2.7999999999999998"
    127.0.0.1:6379> zrevrangebyscore fruits 4 1 withscores limit 0 1
    1) "apple"
    2) "3.5"
    127.0.0.1:6379> 
    
    

    4. ZREM

    
    ZREM key member [member ...]
    
    移除有序集 key 中的一个或多个成员,不存在的成员将被忽略。
    
    当 key 存在但不是有序集类型时,返回一个错误。
    
    

    跟其他方法一样,zrem的目的就是删除指定的value成员,比如这里我要删除scores=3.5 的 apple记录。

    
    127.0.0.1:6379> zrem fruits apple
    (integer) 1
    127.0.0.1:6379> zrange fruits 0 -1 withscores
    1) "grape"
    2) "2.7999999999999998"
    3) "pear"
    4) "4.0999999999999996"
    5) "banana"
    6) "5"
    7) "nut"
    8) "9.1999999999999993"
    127.0.0.1:6379>
    
    

    你会发现,已经没有apple的相关记录了,因为已经被我删除啦。。。

    二:探索原理

    简单的操作都已经演示完毕了,接下来探讨下sortedset到底是由什么数据结构支撑的,大家应该早有耳闻,sortedset在CURD的摊还分析上都是Log(N)的复杂度,可以与平衡二叉树媲美,它就是1987年才出来的新型高效数据结构跳跃表(SkipList),SkipList牛逼的地方在于跳出了树模型的思维,用多层链表的模式构造了Log(N)的时间复杂度,层的高度增加与否,采用随机数的模式,这个和 Treap树 的思想一样,用它来保持或者链表的平衡。

    详细的我就不说了哈,不然的话又是一篇文章啦,如果非要了解的话,大家可以参见一下百度百科:http://baike.baidu.com/link?url=I8F7T W933ZjIeBea_-dW9KeNsfKXMni0IdwNB10N1qnVfrOh_ubzcUpgwNVgRPFw3iCkhewGaYjM_o51xchS8a

    我大概看了下百科里面画的这张图,就像下面这样:

    这幅图中有三条链,对吧,在SkipList中是必须要保证每条链中的数据必须有序才可以,这是必须的。

    • 如果要在level1层中找到节点6,那么你需要逐一遍历,需要6次查找才能正确的找到数据。

    • 如果你在level2层中找到节点6的话,那么你需要4次才能找到。

    • 如果你在level3层中找到节点6的话,那么你需要3次就可以找到。。。。

    现在宏观理解上,是不是有一种感觉,如果level的层数越高,相对找到数据需要遍历的次数就越少,对吧,这就是跳跃表的思想,不然怎么跳哈,接下来我们来看看redis中是怎么定义这个skiplist的,它的源码在redis.h 中:

    
    /* ZSETs use a specialized version of Skiplists */
    typedef struct zskiplistNode {
        robj *obj;
        double score;
        struct zskiplistNode *backward;
        struct zskiplistLevel {
            struct zskiplistNode *forward;
            unsigned int span;
        } level[];
    } zskiplistNode;
    
    typedef struct zskiplist {
        struct zskiplistNode *header, *tail;
        unsigned long length;
        int level;
    } zskiplist;
    
    

    从源码中可以看出如下几点:

    • zskiplistnode就是skiplist中的node节点,节点中有一个level[]数组,如果你够聪明的话,你应该知道这个level[]就是存放着上图中的 level1,level2,level3 这三条链。

    • level[]里面是zskiplistLevel实体,这个实体中有一个 *forward指针,这个指针就是指向同层中的后续节点。

    • 在zskiplistLevel中还有一个 robj类型的*obj指针,这个就是RedisObject对象哈,里面存放的就是我们的value值,接下来还有一个score属性,这个就是key值啦。。。skiplist就是根据它来进行排序的哈。

    • 接下来就是第二个枚举zskiplist,这个没什么意思,纯粹的包装层,比如里面的length是记录skiplist中的节点个数,level记录skiplist当前的层数,用*header,*tail 记录 skiplist 中的首节点和尾节点。。。仅此而已。。。

    展开全文
  • 链表的有序集合

    2018-04-24 18:12:19
    链表的有序集合Time Limit: 1000 msMemory Limit: 65536 KiBProblem Description 集合有一个重要特性:互异性,即集合中任意两个元素都是不同,互异性使得集合元素没有重复。给你 n 个包含重复数字无序...

    链表的有序集合

    Time Limit: 1000 msMemory Limit: 65536 KiB

    Problem Description

      集合有一个重要的特性:互异性,即集合中任意两个元素都是不同的,互异性使得集合中的元素没有重复。给你 n 个包含重复数字的无序正整数序列,建立一个有序链表,链表中的结点按照数值非降序排列且不包含重复元素,输出该有序链表。

    Input

    输入包含多组测试数据,对于每组测试数据:
    输入的第一行为一个正整数 n(1 ≤ n ≤ 100),
    第二行为 n 个正整数 b1,b2,...,bn(0 ≤ bi ≤ 230)。

    Output

    对于每组测试数据,按照非降序输出链表的节点值。

    Sample Input

    1
    2
    2
    1 1
    6
    6 3 5 2 2 3

    Sample Output

    2
    1
    2 3 5 6

    Hint

     

    Source

    qinchuan    

    import java.util.*;
    public class Main {
    	public static void main(String[] args) {
    		Scanner input = new Scanner(System.in);
    	    int n;
    	    int i, j;
    	    int a;
    	    while(input.hasNext()) {
    	    	LinkedList mylist = new LinkedList();
    	    	n = input.nextInt();
    	    	a = input.nextInt();
    	    	mylist.addLast(a);
    	    	for(i = 1; i < n; i++) {
    	    		a = input.nextInt();
    	    		if(!mylist.contains(a)) {
    	    			for(j = 0; j < mylist.size(); j++) {
    		    			if((int)mylist.get(j) >= a) {
    		    				mylist.add(j, a);
    		    				break;
    		    			}
    		    		}
    		    		if(j >= mylist.size()) {
    		    			mylist.addLast(a);
    		    		}
    	    		}
    	    		
    	    	}
    	    	Iterator iter = mylist.iterator();
    	    	a = (int) iter.next();
        		System.out.print(a);
    	    	while(iter.hasNext()) {
    	    		a = (int) iter.next();
    	    		System.out.print(" "+a);
    	    	}
    	    	System.out.println();
    	    }
    	}
    }
    import java.util.*;
    public class Main {
    	public static void main(String[] args) {
    		Scanner input = new Scanner(System.in);
    	    int n;
    	    int i, j;
    	    int a;
    	    while(input.hasNext()) {
    	    	LinkedList mylist = new LinkedList();
    	    	n = input.nextInt();
    	    	a = input.nextInt();
    	    	mylist.addLast(a);
    	    	for(i = 1; i < n; i++) {
    	    		a = input.nextInt();
    	    		if(!mylist.contains(a)) {
    	    			for(j = 0; j < mylist.size(); j++) {
    		    			if((int)mylist.get(j) >= a) {
    		    				mylist.add(j, a);
    		    				break;
    		    			}
    		    		}
    		    		if(j >= mylist.size()) {
    		    			mylist.addLast(a);
    		    		}
    	    		}
    	    		
    	    	}
    	    	Iterator iter = mylist.iterator();
    	    	a = (int) iter.next();
        		System.out.print(a);
    	    	while(iter.hasNext()) {
    	    		a = (int) iter.next();
    	    		System.out.print(" "+a);
    	    	}
    	    	System.out.println();
    	    }
    	}
    }
    

    展开全文
  •  列表(list)类型是用来存储多个字符串,元素从左到右组成一个有序的集合.列表中的每个字符串被称为元素(element),一个列表最多可以存储(2的32次方)-1个元素.在redis中,可以列表两端插入(push)和弹出(pop),还可以...

      原文地址: redis有序集合性能 列表、集合、有序集合

    1.1 列表

      列表(list)类型是用来存储多个字符串,元素从左到右组成一个有序的集合.列表中的每个字符串被称为元素(element),一个列表最多可以存储(2的32次方)-1个元素.在redis中,可以对列表两端插入(push)和弹出(pop),还可以获取指定范围的元素列表、获取指定所有下标的元素等.

      列表类型有两个特点:

        ①列表中的元素是有序的,这就意味着可以通过索引下标获取某个元素或者某个范围内的元素列表.

        ②列表中的元素可以是重复的.

    1.1.1 命令 

      1) 插入命令

        (1) 从右边插入元素.  rpush key value [value...]

        (2) 从左边插入元素.  lpush key value [value....]  使用方法与rpush一样,从左侧插入.
      

      2) 查询命令

        (1) 查询指定范围内的元素列表  lrange key start end  

        lrange操作会获取列表指定索引范围所有的元素.索引下标有两个特点:第一,索引下标从左到右分别是0到N-1,但是从右到左分别是-1到-N.第二,lrange中的end选项包含了自身.

        (2) 获取列表指定索引下的元素  lindex key index

        (3) 获取列表长度  llen key

      3) 删除命令  

        (1) 从列表左侧或右侧弹出元素.  lpop key  rpop key  将列表最左侧与右侧的元素弹出来.

        (2) 删除指定元素  lrem key count value

         lrem命令会从列表中找到等于value的元素进行删除,根据count的不同分为三种:

          count>0,从列表中删除指定数量(count)的元素.

          count<0,从列表中删除count绝对值数量的元素.

          count=0,删除所有.

        (3) 按照索引范围修剪列表  ltrim key start end

      4)修改命令

        修改指定索引下标的元素:  lset key index value

      5) 阻塞操作  

        阻塞式弹出:   blpop key [key...] timeout  brpop key [key...] timeout

        blpop与brpop命令是lpop和rpop命令的阻塞版本,他除了弹出方向不同,使用方法基本相同,所以下面以brpop命令进行说明,

        brpop命令包含两个参数:

        1)列表为空:如果timeout等于3,那么客户端等到三秒后返回,如果timeout=0,那么客户端将一直阻塞,直到弹出成功.

        2)列表不为空:客户端会立刻返回.

      在使用阻塞弹出命令时,有两点需要注意.

      第一点:如果是多个键,那么会从左到右遍历键,一旦有一个键能弹出元素客户端就会立刻返回.
      第二点:如果多个客户端同时对一个键进行操作,那么最先执行命令的客户端可以获取到值.

    1.1.2 内部编码

      列表类型的内部编码有两种:  编码名 编码描述

      ziplist(压缩列表)  当列表的元素个数大于list-max-ziplist-entries配置(默认为512个),同时列表中每个元素的长度小于list-max-ziplist-value配置(默认为64字节).

      linkedlist(链表)  当列表的长度或值得大小不满足ziplist的要求,redis会采用linkedlist为列表的内部实现编码.

    1.1.3 使用场景

      消息队列:redis的lpush-brpop命令组合即可实现阻塞队列,生产者客户端使用lpush命令向列表插入元素.消费者客户端使用brpop命令阻塞式的"抢"列表中的尾部元素.多个客户端保证消息的负载均衡与可用性.

    文章列表:每个用户都有属于自己的文章列表.此时可以考虑使用列表,因为列表不但是有序的,同时支持使用lrange按照索引范围获取多个元素.

    开发提示:列表的使用场景有很多如: lpush+lpop=Stack(栈)、lpush+rpop=queue(队列)、lpush+brpop=message queue、lpush+ltrim=Capped Collection(有限集合)

    1.2 集合  

      集合(set)类型也是用来保存多个的字符串元素,但和列表不同的是:它的元素是无序且不可重复的,不能通过索引获取元素.如下图,集合user:1:follows中包含着"his"、"it"、"sports"、"music"四个元素,一个集合最多可以存储(2的32次方-1)个元素.

     

    1.2.1 命令 

      1) 集合内操作

        (1) 添加元素  sadd key value [value...]  返回结果为添加成功的元素数量.

        (2) 删除元素  srem key value [value...]  返回结果为删除成功的元素数量.

        (3) 获取元素个数  scard key

        (4) 判断元素是否在集合中  sismember key value

        (5) 随机从集合中返回指定个数元素  srandmember key [count]  [count]是可选参数,如果不写默认为:1.

        (6) 从集合中随机弹出元素  spop key  spop操作可以从集合中随机弹出一个元素.

        (7) 获取集合的所有元素  smembers key  获取集合所有元素,且返回结果是无序的.

      2) 集合间操作

        (1) 求多个集合的交集  sinter key [key...]

        (2) 求多个集合的并集  sunion key [key...]

        (3) 求多个集合的差集  sdiff key [key...]

        (4) 将交集、并集、差集的结果保存.

          sinterstore storeKey key [key...]
          sunionstore storeKey key [key...]
          sdiffstore storeKey key [key...]

        集合间的运算在元素比较多的情况下会比较耗时,所以redis提供了上面三个命令(原命令+store)将集合间交集、并集、差集的结果保存到storeKey中,例如将user:1:follows和user:2:follows两个集合之间的交集结果保存到user:1_2:follows中.

    1.2.2 内部编码

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

      编码名            编码描述

      intset(整数集合)    当集合中的元素全是整数,且长度不超过set-max-intset-entries(默认为512个)时,redis会选用intset作为内部编码.

      hashtable(哈希表)   当集合无法满足intset的条件时,redis会使用hashtable作为内部编码.

    1.2.3 使用场景

      集合类型比较典型的使用场景是标签(tag).例如一个用户可能对音乐感兴趣,另一个用户对新闻感兴趣,这些想去点就是标签.有了这些数据就可以获得喜欢同一个标签的人,以及用户的共同喜好的标签,这些数据对于用户体验来说比较重要.

    1.3 有序集合

      有序集合相对于哈希、列表、集合来说会有一点陌生,但既然叫有序集合.那么它和集合必然是有着联系,它保留了集合不能重复元素的特性.但不同的是,有序集合是可排序的.但是他和列表使用索引下标进行排序依据不同的是,它给每个元素设置一个分数(score)作为排序的依据.

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

    1.3.1 命令 

      1)集合内

        (1) 添加成员  zadd key score member [score member ...]

          有关zadd命令有两点需要注意:  Redis 3.2为zadd命令添加了nx、xx、ch、incr四个选项:

            nx:member必须不存在,才可以设置成功,用于添加.

            xx:member必须存在,才可以设置成功,用于添加.

            ch:返回此次操作后,有序结合元素和分数发生变化的个数.

            incr: 对score进行添加操作,相当于后面介绍的zincrby.

          有序集合相比集合提供了排序字段,但是也产生了代价,zadd的时间复杂度是O(log(n)),sadd的时间复杂度为O(1).

        (2) 获取成员个数  zcard key

        (3) 获取某个成员的分数  zscore key member

        (4) 获取成员排名  zrank key member  zrevrank key member

        (5) 删除成员  zrem key member [member...]  

        (6) 增加成员分数  zincrby key score member

        (7) 获取制定范围的元素  zrange key start end [withscores]  zrevrange key start end [withscores]

          有序集合是按照分值排名的,zrange是由低到高返回,zrevrange反之,查询全部:zrange user:ranking 0 -1,加上withscores参数显示分数.

        (8) 返回指定分数范围的成员  zrangebyscore key min max [withscores] [limit offset count]  zrevrangebyscore key min max [withscores] [limit offset count]

        (9) 返回指定分数范围成员个数  zcount key min max

        (10) 删除指定排名内的升序元素  zremrangebyrank key start end

        (11) 删除指定分数范围的成员  zremrangebyscore key min max

      2) 集合间的操作

        (1) 交集  zinterstore storeKey keyNum key [key ...] [weights weight [weight...]] [aggregate sum|min|max]  参数说明:

          storeKey:交集计算结果保存到这个键下.

          keyNum:需要做交集的键的个数.

          key[key ...]:需要做交集的键.

          weights weight [weight...]:每个键的权重,在做交集计算时,每个键中的每个member的分值会和这个权重相乘,每个键的权重默认为1.

          aggregate sum|min|sum:计算成员交集后,分值可以按照sum(和)、min(最小值)、max(最大值)做汇总.默认值为sum.

        (2) 并集  zunionstore storeKey keyNum key [key...] [weights weight [weight...]] [aggregate sum|min|max]  该命令的所有参数和zinterstore是一致的,只不过做的是并集计算.

    1.3.2 内部编码 

      编码名称        编码描述

      ziplist(压缩列表)    当有序集合的元素小于zset-max-ziplist-entries配置(默认是128个),同时每个元素的值都小于zset-max-ziplist-value(默认是64字节)时,Redis会用ziplist来作为有序集合的内部编码实现,ziplist可以有效的减少内存的使用

      skiplist(跳跃表)      当ziplist的条件不满足时,有序集合将使用skiplist作为内部编码的实现,来解决此时ziplist造成的读写效率下降的问题.

     

    展开全文
  • 有序集合的交运算

    2021-01-11 15:44:41
    假设以两个元素依次递增有序排序排列线性表 A 和 B 分别表示两个集合(即同一表中元素值各不相同),现要求另辟空间构成一个线性表 C,其元素为 A 和 B 中元素交集,且表 C 中元素也依值递增有序排列。...
  • redis有序集合

    2019-07-02 14:09:41
    Redis Zincrby 命令对有序集合中指定成员分数加上增量 increment 可以通过传递一个负数值 increment ,让分数减去相应值,比如 ZINCRBY key -5 member ,就是让 member score 值减去 5 。 当 key....
  • 有序集合zset

    2019-08-08 15:35:26
    有序集合zset:和set很像,都是字符串的集合,都不允许重复的成员出现在一个set中。他们的区别在于有序集合中每一个成员都有一个分数(score)与之关联,redis正是通过分数来集合里的成员进行从小到大的排序。尽管...
  • {1 2 3 4 5}集合是正确有序的,但 {2 3 1 4 5}是错误顺序的,其有序率 : 对于2来说,其余四个数中有三个数的分布是对的(3,4,5分布在2的右边,真确的;但1的位置是错的,应该在2的左边),其有序率为3/4, 对于3来...
  • 我将会用第二部分来讨论集合的特殊操作: In [136]: x.sadd("challenge", 1,2,3,4,5,6,7,5,4,4,3,4,2) 7 In [138]: x.smembers("challenge") set(['1', '3', '2', '5', '4', '7', '6']) In [139]...
  • 带有XX选项ZADD命令只会对有序集合已有成员进行更新,而不会向有序集合添加任何新成员。 带有NX选项ZADD命令只会想有序集合添加新成员,而不会已有成员进行任何更新。 在默认情况下,ZADD命令会返回新...
  • Redis 有序集合命令

    2018-09-10 16:30:08
    ZADD key score1 member1 [score2 member2] 向有序集合添加一个或多个成员,或者更新已存在成员分数 ZCARD key 获取有序集合的成员数 ...有序集合指定成员分数加上增量 increment ZINTER...
  • Redis有序集合详解

    2020-03-20 17:32:19
    有序集合集合类似,只是说它是有序的,和无序集合的主要区别在于每一个元素除了值之外,它还会多一个分数。分数是一个浮点数,在 Java 中是使用双精度表示,根据分数,Redis 就可以支持分数从小到大或者从大到...
  • 有两点让我认为TreeSet能够帮我快速获得有序的学生集合: (1)TreeSet基于红黑树实现,而红黑树是一个平衡二叉树,也就说,它排序时间复杂度是nlognnlogn; (2)在插入初期lognlogn较小。
  • redis 有序集合zset

    2018-10-31 00:56:00
    有序集合和散列一样,都用于存储键值有序集合zset键被称为成员(member),每个成员都是各不相同;而有序集合的值则被称为分值(score),分值必须 是浮点数。有序集合是redis中唯一一个既可以根据成员访问...
  • 多个有序集合 score存发布时间戳 两个月内作品集合 用户作品集合 (发布立即压入集合) 关注用户作品集合 点赞作品集合 活跃用户关注作品集合 圈子集合 1. 同学校作品集合 2. 同班级作品集合 3. 其他圈子 ...
  • redis学习之有序集合

    2019-09-06 17:21:06
    redis有序集合集合不同是每个成员都会关联一个double类型分数,redis就是利用分数对集合成员进行从小到大排序。 目录 查询集合成员 查询集合成员分数 统计 加入集合 成员增量 删除集合成员 ...
  • 要保存的集合 * @param $zsetkey 求并集的集合 * @return int 集合的数目 */ public function zInter( $output , $zsetkey ){ return $this -> redis ->zInter( $output , $zsetkey ); } } ...
  • 有序集合和散列一样,都用于存储键值有序集合的键被称为成员(member),每个成员都是各不相同;而有序集合的值则被称为分值(score),分值必须为浮点数。有序集合是Redis里面唯一一个既可以根据成员访问元素...
  • 一、简介 Sorted set(zset)是set升级版本,它在set基础上增加了一个顺序属性,这一属性在添加修改元素时候可以指定,每次...二、有序集合的操作方法 1.zadd key score member:向名称为keyzset中添加元素me
  • 主要给大家介绍了关于如何利用Redis的有序集合实现排行榜功能相关资料,文中通过示例代码介绍非常详细,大家学习或者使用Redis具有一定参考学习价值,需要朋友们下面来一起学习学习吧
  • 我们平时会笼统的认为实现List接口的集合都是有序的,实现Set和Map的接口的集合是无序的,这个说法其实是有问题的,在JDK1.4引入的LinkedHashMap和LinkedHashSet,这两个是通过双向链表实现的,是有序的。...
  • 趣题:如何用集合来定义有序对

    千次阅读 2008-10-16 00:10:00
    因此当我们讨论到有序对的概念时,我们只能用集合的语言去描述它。如何用集合来叙述有序对,使得=当且仅当a=c且b=d呢?集合本身的无序性给我们带来了相当大的困难。比如,大多数人可能会想到:={a,{b}}。可惜这种定义...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,609
精华内容 3,443
关键字:

有序对的集合