精华内容
下载资源
问答
  • Java 多关键字排序

    2021-03-09 15:07:07
    一开始默认可以在类内部重写排序规则: 首先继承排序接口:Comparable<Person> int compare(Person p1, Person p2) 返回一个基本类型的整型, 返回负数表示:p1 小于 p2, 返回0 表示: p1 和 p2相等, ...

    继承 Comparable接口

    一开始默认可以在类内部重写排序规则:

    首先继承排序接口:Comparable<Person>

    int compare(Person p1, Person p2) 返回一个基本类型的整型,
    
    返回负数表示:p1 小于 p2,
    
    返回0 表示: p1 和 p2相等,
    
    返回正数表示:p1 大于 p2
    
    所以重写排序规则的时候很灵活。如果类型是数字的话,可以直接用前一个减后一个, 
    其他类型用 compareTo 函数。
    
    如果从大到小排就 return 的时候把 p1 and p2 调换一下。
    package com.ytc.alpha;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.List;
    
    public class Person implements Comparable<Person>{
        private String name;
        private Integer age;
    
        public Person(String name, Integer age) {
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        @Override
        public int compareTo(Person o) {
            return this.age - o.age;
        }
    
        public static void main(String[] args) {
            List<Person> plist = new ArrayList<Person>();
            Person p1 = new Person("0001", 14);
            Person p4 = new Person("0004",23);
            Person p5 = new Person("0005",25);
            Person p3 = new Person("0003",25);
            Person p6 = new Person("0006",25);
            Person p7 = new Person("0007",25);
            Person p2 = new Person("0002",20);
    
            plist.add(p1);
            plist.add(p2);
            plist.add(p3);
            plist.add(p4);
            plist.add(p5);
            plist.add(p6);
            plist.add(p7);
            for(Person person : plist){
                System.out.println("排序前的结果:"+person.getName() + " " + person.getAge());
            }
            Collections.sort((plist));
    
            System.out.println();
            for(Person person : plist){
                System.out.println("排序前的结果:"+person.getName() + " " + person.getAge());
            }
        }
    }

     

    比较器的使用

    默认是用 age 排序,但是有的时候需要用 name 来排序怎么办? 这个时候比较器 :Comparator 就排上用场了。

    Comparator 的使用有两种方式:

    • Collections.sort(list,Comparator<T>);

    • list.sort(Comparator<T>);

    其实主要是看 `Comparator` 接口的实现,重写里面的 `compare` 方法。代码如下:

    // 方法一
    Collections.sort(plist, new Comparator<Person>(){
      @Override
      public int compare(Person p1, Person p2) {
        //按照Person的年龄进行升序排列,如果年龄一样按照姓名从大到小排序
        if (p1.getAge() == p2.getAge())
          return p2.getName().compareTo(p1.getName());
        return p1.getAge().compareTo(p2.getAge());
      }
    });
    
    // 方法二
    plist.sort(new Comparator<Person>() {
      // 倒序排列
      @Override
      public int compare(Person o1, Person o2) {
        return o2.age.compareTo(o1.age);
      }
    });
    // 方法三:
    // 定义一个比较器的类,然后直接用就可以了, 可以不用在主程序中写比较的内容
    // 这个类要继承比较器的接口,然后重写比较的规则
    class idComparator implements Comparator<Person> {
        @Override
        public int compare(Person o1, Person o2) {
            return o2.getAge() - o1.getAge();
        }
    }

     

     

     

    展开全文
  • 以列表有两列为例,我们需要按照两列排序,可以利用sorted和lambda组合 l = [['a', 2], ['c', 1], ['d', 4], ['b', 2]] sorted(l, key = lambda x: (x[1], x[0]), reverse = True) 然后结果是 [['d', 4], ['b', 2]...

    最近刷刷题遇到的,发现还没有一模一样的答案,自己做个解答

    以列表有两列为例,我们需要按照两列排序,可以利用sorted和lambda组合

    l = [['a', 2], ['c', 1], ['d', 4], ['b', 2]]
    
    sorted(l, key = lambda x: (x[1], x[0]), reverse = True)
    

    然后结果是

    [['d', 4], ['b', 2], ['a', 2], ['c', 1]]
    

    那如果我们想让第二个关键词按照降序应该怎么搞呢?

    • 如果第二个关键词是数字,就直接可以加负号,负号升序他自己就是降序
    sorted(l, key = lambda x: (x[1], -x[0]), reverse = True)
    
    • 如果关键词不是数字,就加上ord()求其ASCII码排序就行
    l = [['a', 2], ['c', 1], ['d', 4], ['b', 2]]
    
    sorted(l, key = lambda x: (x[1], -ord(x[0])), reverse = True)
    

    这样的结果就是

    [['d', 4], ['a', 2], ['b', 2], ['c', 1]]
    

    搞定
    顺便求最近笔试面试顺利,春招offer多多✌️

    展开全文
  • 现在要求按照一下方式排序(默认排序规则都是从小到大);1.按照编号从小到大排序2.对于编号相等的长方形,按照长方形的长排序;3.如果编号和长都相同,按照长方形的宽排序;4.如果编号、长、宽都相同,就只保留一个

    一种排序

    时间限制:3000 ms | 内存限制:65535 KB
    难度:3

    描述

    现在有很多长方形,每一个长方形都有一个编号,这个编号可以重复;还知道这个长方形的宽和长,编号、长、宽都是整数;现在要求按照一下方式排序(默认排序规则都是从小到大);

    1.按照编号从小到大排序

    2.对于编号相等的长方形,按照长方形的长排序;

    3.如果编号和长都相同,按照长方形的宽排序;

    4.如果编号、长、宽都相同,就只保留一个长方形用于排序,删除多余的长方形;最后排好序按照指定格式显示所有的长方形;

    输入

    第一行有一个整数 0

    输出

    顺序输出每组数据的所有符合条件的长方形的 编号 长 宽

    样例输入

    1
    8
    1 1 1
    1 1 1
    1 1 2
    1 2 1
    1 2 2
    2 1 1
    2 1 2
    2 2 1

    样例输出

    1 1 1
    1 2 1
    1 2 2
    2 1 1
    2 2 1

    来源

    经典题目

    上传者

      iphxer

    题解

      sort函数自定义cmp,实现多关键字排序

    代码

     1 #include<iostream>
     2 #include<cstdio>
     3 #include<cstdlib>
     4 #include<cstring>
     5 #include<algorithm>
     6 using namespace std;
     7 
     8 const int M=1000;
     9 struct node{
    10     int h,w,i;
    11 }rectan[M];
    12 
    13 bool cmp(struct node x,struct node y)
    14 {
    15     if(x.i!=y.i)
    16         return x.i<y.i;
    17     else
    18     {
    19         if(x.h!=y.h)
    20             return x.h<y.h;
    21         else
    22             return x.w<x.w;
    23     }
    24 }
    25 
    26 int main()
    27 {
    28     int n,m;
    29     scanf("%d",&n);
    30     while(n--)
    31     {
    32         scanf("%d",&m);
    33         for(int j=0;j<m;j++)
    34         {
    35             int a,b,c;
    36             scanf("%d %d %d",&a,&b,&c);
    37             rectan[j].i=a;
    38             if(b>c)
    39                 rectan[j].h=b,rectan[j].w=c;
    40             else
    41                 rectan[j].h=c,rectan[j].w=b;
    42 
    43         }
    44         sort(rectan,rectan+m,cmp);46         printf("%d %d %d\n",rectan[0].i,rectan[0].h,rectan[0].w);
    47         for(int j=1;j<m;j++)
    48         {
    49             if(!(rectan[j].i==rectan[j-1].i&&rectan[j].h==rectan[j-1].h&&rectan[j].w==rectan[j-1].w))
    50                 printf("%d %d %d\n",rectan[j].i,rectan[j].h,rectan[j].w);
    51         }
    52 
    53     }
    54     return 0;
    55 }
    展开全文
  • 第一次用STL的sort进行多关键字进行排序。 另外,排序后再如何处理,有一定难度。   #include #include using namespace std; const int MAX = 5000; /* Stick类 */ class Stick { public: int length; /...

    第一次用STL的sort进行多关键字进行排序。

    另外,排序后再如何处理,有一定难度。

     

    展开全文
  • 成绩排序(关键字排序

    千次阅读 2017-01-04 22:05:53
    ...查找和排序 ...题目:输入任意(用户,成绩)序列,可以获得成绩从高到低或从低到高的排列,... 都按先录入排列在前的规则处理。  例示:  jack 70  peter 96  Tom 70  smith 67  从高到低
  • SQL Server中的Collate排序规则关键字的使用
  • 现有列表ll=[(1,2),(4,5),(8,9),(1,1),(4,3),(8,20)],要实现排序,排序规则为:按元组第一个元素降序,如果元祖第一个元素相同按元祖第二个元祖升序。 import functools def tcmp(x,y): #只能返回[-1,0,1]分别...
  • 首先对查询的时间段进行过滤 RangeQuery querybetween = new RangeQuery(begintime, endtime,...加入排序规则 Hits hits = searcher.search(query, sort);// 开始进行搜索   就这样实现了完整的搜索  
  • IOS数组按中文关键字以字母序排序

    千次阅读 2013-08-22 14:17:32
    IOS项目中会用到对通讯录的联系人或是会员按姓名为关键字排序,因为NSArray并不直接支持对汉字的排序,这就要通过将汉字转换成拼音完成按A~Z的排序,这看起来是个头疼的问题,因为牵扯到汉字转为拼音,kmyhy给出一个...
  • Java volatile关键字用于将Java变量标记为“存储在主内存中”。更确切地说,这意味着:volatile变量每次都将从计算机的主存储器读取,而不是CPU缓存中;volatile变量每次都将写入主存储器,而不仅仅是CPU缓存。 实际...
  • iOS数组按中文关键字以字母序排序iOS项目中会用到对通讯录的联系人或是会员按姓名为关键字排序,因为NSArray并不直接支持对汉字的排序,这就要通过将汉字转换成拼音完成按A~Z的排序,这看起来是个头疼的问题,因为...
  • Java中 volatile关键字怎么禁止重排序

    千次阅读 2017-12-11 11:19:33
    使用volatile关键字修饰共享变量可以禁止重排序。若用volatile修饰共享变量,在编译时,会在指令序列中插入内存屏障来禁止特定类型的处理器重排序  volatile禁止指令重排序的一些规则:  1.当第二个操作是...
  • 模拟 排序 多关键字排序 【分析】 这题只是一个关键字有点的排序而已。 最多会有256/6个关键字。我们直接把所有的关键字提取出来,位置越后,级别越高。 upper=1 middle=0(初始也为0) lower=-1 然后排个序,这...
  • Python中字典根据规则排序

    千次阅读 多人点赞 2018-05-23 11:44:49
    Python中字典根据规则排序   在SQL中或者用pandas可以轻松地对一列数据按照规则进行排序,那么有没有办法直接用python的sorted实现呢?答案是肯定的。 key value b 10 c 10 a 10 d...
  • sql server中collate排序关键字的使用

    千次阅读 2016-10-26 23:10:10
    collate是一个子句,可应用于数据库定义或列定义以定义排序规则,或应用于字符串表达式以应用排序规则投影。 语法 COLLATE ::= { Windows_collation_name } | { SQL_collation_name } 参数 collation_name 是...
  • Solr打分排序规则自定义

    万次阅读 2017-05-18 17:01:46
    Solr打分排序规则自定义 在搭建好solrCloud搜索集群后,通过编写基本的查询显示语句已经能够通过输入关键字查询到相应结果进行显示,但是在显示结果排序上以及不相关信息过滤问题上,如何制定合理的打分规则得到理想...
  • Python3 自定义 sort() 的排序规则

    千次阅读 2020-07-13 21:08:55
    在 Python2 种,sort 和 sorted 可以通过关键字参数 cmp 指定排序规则,但在 Python3 中这个参数给去掉了: Python2: list.sort(cmp=None, key=None, reverse=False) Python3: list.sort(key=None, reverse=...
  • 关键字

    2019-09-23 21:44:35
    synchronized是Java关键字,当它用来修饰一个方法或一个代码块的时候,能够保证在同一时刻最多只有一个线程执行该段代码。 Lock是一个接口,而synchronized是Java中的关键字,synchronized是内置的语言实现;...
  • // 这里是a、b需要处理的业务,需要根据你的规则进行修改。 String aStr = a.getString( key ); valA = aStr.replaceAll( "-" , "" ); String bStr = b.getString( key ); valB = bStr.replaceAll( "-" , "" ...
  • 关键字搜索

    千次阅读 2016-06-12 14:46:57
    写这篇文章在半个月前就打算写,...2、能够在搜索栏输入关键字进行按关键它检索,并且按规定的顺序对关键字进行排序; 3、对搜索出来的数据包含关键的内容关键字进行高突出显示。 4、输入的关键字时时自动更新检索的内

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 113,475
精华内容 45,390
关键字:

多关键字排序规则