精华内容
下载资源
问答
  • 众所周知,set/map是自动按从小到大排序的,而且排好序和不可再修改,否则会破坏组织结构 使用要在排序前,指定它的排序规则 ①用greater方式 个人认为这个比较简单 void test() { set<int,greater<int>>S2...

    众所周知,set/map是自动按从小到大排序的,而且排好序和不可再修改,否则会破坏组织结构

    使用要在排序前,指定它的排序规则
    ①用greater方式
    个人认为这个比较简单

    void test()
    {
        set<int,greater<int>>S2;
        S2.insert(10);
        S2.insert(100);
        S2.insert(200);
        for (set<int>::iterator it = S2.begin(); it != S2.end(); it++)
        {
            cout << *it << " ";
        }
    }
    

    在这里插入图片描述
    ②用仿函数的方式
    NULL

    插入自定义类型

    以set为例
    应该就是这样的,但是不知道为什么一直报错
    严重性 代码 说明 项目 文件 行 禁止显示状态
    错误 C3848 具有类型“const mycompare2”的表达式会丢失一些 const-volatile 限定符以调用“bool mycompare2::operator ()(const person &,const person &)” 20315 C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.24.28314\include\xutility 1481

    解决方法 : 在仿函数那块加上const修饰

    #include <iostream>
    #include<cstdlib>
    #include<string>
    #include<set>
    using namespace std;
    
    class person
    
    {
    
    public:
    
    	person(string name, int age)
    
    	{
    
    		this->m_name = name;
    
    		this->m_age = age;
    
    	}
    
    	string m_name;
    
    	int m_age;
    
    };
    
    class mycompare2
    
    {
    
    public:
    
    	bool operator()(const person& p1, const person& p2)const // 这个位置要加const修饰
    
    	{
    
    		if (p1.m_age > p2.m_age) //降序
    
    		{
    
    			return true;
    
    		}
    
    		return false;
    
    	}
    
    };
    
    void test4()
    
    {
    
    	set<person, mycompare2> p;
    
    	person p1("sss", 35);
    
    	person p2("aaa", 10);
    
    	person p3("bbb", 20);
    
    	person p4("ccc", 46);
    
    	person p5("ddd", 82);
    
    	p.insert(p1);
    
    	p.insert(p2);
    
    	p.insert(p3);
    
    	p.insert(p4);
    
    	p.insert(p5);
    
    	//插入自定义数据类型 需要指定排序规则
    
    	//显示
    
    	for (set<person, mycompare2>::iterator it = p.begin(); it != p.end(); it++)
    
    	{
    
    		cout << "姓名: " << (*it).m_name << "年龄: " << it->m_age << endl;
    
    	}
    
    }
    
    展开全文
  • Set排序方法

    万次阅读 2019-04-22 21:04:28
    在讲解Set集合排序的几种方法之前,我们应该先清楚Set集合的几种类型以及特点,才能有效使用起来。 Set集合的特点 ​ Set不允许包含相同的元素,如果试图把两个相同元素加入同一个集合中,add方法返回false。 ​ ...

    在讲解Set集合排序的几种方法之前,我们应该先清楚Set集合的几种类型以及特点,才能有效使用起来。

    Set集合的特点

    ​ Set不允许包含相同的元素,如果试图把两个相同元素加入同一个集合中,add方法返回false。
    ​ Set判断两个对象相同不是使用==运算符,而是根据equals方法。也就是说,只要两个对象用equals方法比较返回true,Set就不会同时接受这两个对象

    Set集合的分类

    Set集合主要分为3种:

    ​ |——SortedSet接口——TreeSet实现类

    Set接口——|——HashSet实现类

    ​ |——LinkedHashSet实现类

    • HashSet(无序,可null)

    HashSet的特点是不能保证元素的排列顺序,顺序有可能发生变化,集合元素可以是null,但只能放入一个null。因为在HashSet中存入一个元素的时候,会调用该对象的hashCode()方法来得到该对象的hashCode值,然后根据 hashCode值来决定该对象在HashSet中存储位置,所以储存位置是随机的。HashSet就好像是HashMap的key。

    • TreeSet(有元素顺序的)

    TreeSet是SortedSet接口的唯一实现类,TreeSet可以确保集合元素处于排序状态。TreeSet支持两种排序方式,自然排序 和定制排序,其中自然排序为默认的排序方式。一般的Set排序都会使用到TreeSet。

    • LinkedHashSet(记录插入顺序)

    LinkedHashSet集合同样是根据元素的hashCode值来决定元素的存储位置,但是它同时使用链表维护元素的次序。这样使得元素看起 来像是以插入顺 序保存的,也就是说,当遍历该集合时候,LinkedHashSet将会以元素的添加顺序访问集合的元素。一般的,如果让你设计一个缓存算法,LinkedHashSet就是基本的基础,利用LRU,筛选出应该淘汰的元素。

    由于TreeSet是有元素顺序的,因此我们在排序的过程中都会使用TreeSet。

    方法一:传统方法

    public class TraditionalSetSortTest {
        public static void main(String[] args) {
            Set<BigDecimal> set = new HashSet<>();
            set.add(new BigDecimal(1.2).setScale(2, BigDecimal.ROUND_HALF_UP));
            set.add(new BigDecimal(2.3).setScale(2, BigDecimal.ROUND_HALF_UP));
            set.add(new BigDecimal(3.4).setScale(2, BigDecimal.ROUND_HALF_UP));
            set.add(new BigDecimal(2.4).setScale(2, BigDecimal.ROUND_HALF_UP));
            set.add(new BigDecimal(0.4).setScale(2, BigDecimal.ROUND_HALF_UP));
            set.add(new BigDecimal(9.4).setScale(2, BigDecimal.ROUND_HALF_UP));
    
            TreeSet<BigDecimal> sortSet = new TreeSet<>(new Comparator<BigDecimal>() {
                @Override
                public int compare(BigDecimal o1, BigDecimal o2) {
                    return o1.compareTo(o2);
                }
            });
            sortSet.addAll(set);
            System.out.println(sortSet);
        }
    }
    --------------------------------------------------------------------------------------------
    结果:[0.40, 1.20, 2.30, 2.40, 3.40, 9.40]
    

    方法二:lambda表达式

    public class LambdaSetSortTest {
        public static void main(String[] args) {
            Set<BigDecimal> set = new HashSet<>();
            set.add(new BigDecimal(1.2).setScale(2, BigDecimal.ROUND_HALF_UP));
            set.add(new BigDecimal(2.3).setScale(2, BigDecimal.ROUND_HALF_UP));
            set.add(new BigDecimal(3.4).setScale(2, BigDecimal.ROUND_HALF_UP));
            set.add(new BigDecimal(2.4).setScale(2, BigDecimal.ROUND_HALF_UP));
            set.add(new BigDecimal(0.4).setScale(2, BigDecimal.ROUND_HALF_UP));
            set.add(new BigDecimal(9.4).setScale(2, BigDecimal.ROUND_HALF_UP));
            TreeSet<BigDecimal> sortedSet = new TreeSet<>(((o1, o2) -> o1.compareTo(o2)));
            sortedSet.addAll(set);
            System.out.println(sortedSet);
        }
    }
    --------------------------------------------------------------------------------------------
    结果:[0.40, 1.20, 2.30, 2.40, 3.40, 9.40]
    

    方法三:使用Comparator,在jdk1.8以后,Comparator有Comparator.naturalOrder()自然排序这个方法,也有Comparator.reverseOrder()相反排序的方法。

    public class ComparatorSetSortTest {
        public static void main(String[] args) {
            Set<BigDecimal> set = new HashSet<>();
            set.add(new BigDecimal(1.2).setScale(2, BigDecimal.ROUND_HALF_UP));
            set.add(new BigDecimal(2.3).setScale(2, BigDecimal.ROUND_HALF_UP));
            set.add(new BigDecimal(3.4).setScale(2, BigDecimal.ROUND_HALF_UP));
            set.add(new BigDecimal(2.4).setScale(2, BigDecimal.ROUND_HALF_UP));
            set.add(new BigDecimal(0.4).setScale(2, BigDecimal.ROUND_HALF_UP));
            set.add(new BigDecimal(9.4).setScale(2, BigDecimal.ROUND_HALF_UP));
            TreeSet<BigDecimal> sortedSet = new TreeSet<>(Comparator.naturalOrder());
            sortedSet.addAll(set);
            System.out.println(sortedSet);
        }
    }
    --------------------------------------------------------------------------------------------
    结果:[0.40, 1.20, 2.30, 2.40, 3.40, 9.40]
    

    方法四:使用Stream

    这里使用Stream的时候可以转还成Set或者List,转换成Set的时候还需要再创建TreeSet,如果没有必须要求是Set,其实可以是直接转换成List,直接就是有序的,更加方便。

    List list = set.stream().sorted(Comparator.naturalOrder()).collect(Collectors.toList());
    
    public class StreamSetSortTest {
        public static void main(String[] args) {
            Set<BigDecimal> set = new HashSet<>();
            set.add(new BigDecimal(1.2).setScale(2, BigDecimal.ROUND_HALF_UP));
            set.add(new BigDecimal(2.3).setScale(2, BigDecimal.ROUND_HALF_UP));
            set.add(new BigDecimal(3.4).setScale(2, BigDecimal.ROUND_HALF_UP));
            set.add(new BigDecimal(2.4).setScale(2, BigDecimal.ROUND_HALF_UP));
            set.add(new BigDecimal(0.4).setScale(2, BigDecimal.ROUND_HALF_UP));
            set.add(new BigDecimal(9.4).setScale(2, BigDecimal.ROUND_HALF_UP));
            Set newSet = set.stream().sorted(Comparator.naturalOrder()).collect(Collectors.toSet());
            TreeSet<Object> treeSet = new TreeSet<>();
            treeSet.addAll(newSet);
            System.out.println(treeSet);
        }
    }
    --------------------------------------------------------------------------------------------
    结果:[0.40, 1.20, 2.30, 2.40, 3.40, 9.40]
    

    补充:

    已知数值a,如果要求向上取值(即寻找顺序的Set集合中一个大于等于a的第一个元素,日常业务还是用到很多的,不到半斤算半斤(含),超过半斤算一斤类似),可以借用set的floor方法,数值超出元素的最大值后会返回null。
    如果是BigDecimal类型,TreeSet集合元素与ceiling参数的小数点位数请务必保持一致。举例如下:

    public class SetFloorMethod {
        public static void main(String[] args) {
            Set<BigDecimal> set = new HashSet<>();
            set.add(new BigDecimal(1.2).setScale(2, BigDecimal.ROUND_HALF_UP));
            set.add(new BigDecimal(2.3).setScale(2, BigDecimal.ROUND_HALF_UP));
            set.add(new BigDecimal(3.4).setScale(2, BigDecimal.ROUND_HALF_UP));
            set.add(new BigDecimal(2.4).setScale(2, BigDecimal.ROUND_HALF_UP));
            set.add(new BigDecimal(0.4).setScale(2, BigDecimal.ROUND_HALF_UP));
            set.add(new BigDecimal(9.4).setScale(2, BigDecimal.ROUND_HALF_UP));
            TreeSet<BigDecimal> sortedSet = new TreeSet<>(Comparator.naturalOrder());
            sortedSet.addAll(set);
            System.out.println(sortedSet);
            BigDecimal value1 = sortedSet.ceiling(new BigDecimal(0.5).setScale(2, BigDecimal.ROUND_HALF_UP));
            System.out.println("根据0.5可以取到元素:" + value1);
            BigDecimal value2 = sortedSet.ceiling(new BigDecimal(2.35).setScale(2, BigDecimal.ROUND_HALF_UP));
            System.out.println("根据2.35可以取到元素:" + value2);
            BigDecimal value3 = sortedSet.ceiling(new BigDecimal(11).setScale(2, BigDecimal.ROUND_HALF_UP));
            System.out.println("根据11可以取到元素:" + value3);
        }
    }
    --------------------------------------------------------------------------------------------
    结果如下:
    [0.40, 1.20, 2.30, 2.40, 3.40, 9.40]
    根据0.5可以取到元素:1.20
    根据2.35可以取到元素:2.40
    根据11可以取到元素:null
    
    展开全文
  • set容器对类进行排序

    2011-11-02 18:15:29
    使用C++容器类中的set容器对类进行排序!!!
  • Set集合排序

    万次阅读 2017-10-03 11:08:08
    TreeSet使用元素的自然顺序对元素进行排序,或者根据创建set时提供的Comparator进行排序,具体取决于使用的构造方法。通俗一点来说,就是可以按照排序后的列表显示,也可以按照指定的规则排序Set<String> set = ...

    TreeSet使用元素的自然顺序对元素进行排序,或者根据创建set时提供的Comparator进行排序,具体取决于使用的构造方法。通俗一点来说,就是可以按照排序后的列表显示,也可以按照指定的规则排序。

    Set<String> set = new TreeSet<String>();       
            set.add("f");  
            set.add("a");  
            set.add("b");  
            set.add("c");  
            set.add("d");  
            set.add("e");          
            System.out.println(set);

    输出:[a, b, c, d, e, f] ,按照排序后输出

    若想它倒序输出,可以指定一个规则让他倒序输出

    public class TreeSetTest3 {  
         public static void main(String[] args) {  
            Set<String> set = new TreeSet<String>(new MyComparator());  
            set.add("a");  
            set.add("b");  
            set.add("c");  
            set.add("d");  
            set.add("e");  
            set.add("A");        
            for(Iterator<String> iterator = set.iterator();iterator.hasNext();){  
                System.out.print(iterator.next()+" ");  
            }  
        }  
    }    
    class MyComparator implements Comparator<String>{  
        @Override  
        public int compare(String o1, String o2) {           
            return o2.compareTo(o1);//降序排列  
        }  
    }  

    输出:e d c b a A

    如果Set集合中放入的是我们自己定义的一个类类型呢?

    注意:一定要定义一个排序规则类实现Comparator接口,与上面的方法类似

    public class TreeSetTest2 {  
        public static void main(String[] args) {  
            Set<Person> set = new TreeSet<Person>(new PersonComparator());  
            Person p1 =  new Person(10);  
            Person p2 =  new Person(20);  
            Person p3 =  new Person(30);  
            Person p4 =  new Person(40);  
            set.add(p1);  
            set.add(p2);  
            set.add(p3);  
            set.add(p4);         
            for(Iterator<Person> iterator = set.iterator();iterator.hasNext();){  
                System.out.print(iterator.next().score+" ");  
            }  
        }  
    }  
    class Person{  
        int score;  
        public Person(int score){  
            this.score = score;  
        }     
        public String toString(){  
            return String.valueOf(this.score);  
        }  
    }  
    class PersonComparator implements Comparator<Person>{  
        @Override  
        public int compare(Person o1, Person o2) {      
            return o1.score - o2.score;  
        }      
    }  

    输出:10 20 30 40

    如果按照一个人的分数的倒序排列,只需要更改compare方法中的o2.score-o1.score

    参考博客:http://blog.csdn.net/u014649337/article/details/43734863

    展开全文
  • 1.简单的集合排序 1 package com.demo.advice; 2 3 import java.util.Collections; 4 import java.util.LinkedList; 5 6 import com.alibaba.druid.sql.visitor.functions.Reverse; 7 8 ...

    1.简单的集合排序

     1 package com.demo.advice;
     2 
     3 import java.util.Collections;
     4 import java.util.LinkedList;
     5 
     6 import com.alibaba.druid.sql.visitor.functions.Reverse;
     7 
     8 public class Test {
     9     public static void main(String[] args) {
    10         
    11         LinkedList<Integer> list = new LinkedList<Integer>();
    12         list.add(1);
    13         list.add(8);
    14         list.add(7);
    15         list.add(4);
    16         list.add(5);
    17         //排序前
    18         System.out.println(list);
    19         //倒序
    20         Collections.reverse(list);
    21         System.out.println(list);
    22         //从大到小排序
    23         Collections.sort(list);
    24         System.out.println(list);
    25         
    26     }
    27     
    28 }
    View Code

    排序结果图

    2.复杂一点的集合排序

     1 package com.demo.advice;
     2 
     3 
     4 import java.util.Collections;
     5 import java.util.LinkedList;
     6 
     7 
     8 
     9 public class Test {
    10     public static void main(String[] args) {
    11         LinkedList<Users> list = new LinkedList<Users>();
    12         list.add(new Users(1,"aa",20));
    13         list.add(new Users(4,"bb",30));
    14         list.add(new Users(3,"cc",25));
    15         list.add(new Users(3,"dd",42));
    16         list.add(new Users(8,"ee",35));
    17         Collections.sort(list);
    18         for (Users users : list) {
    19             System.out.println(users);
    20         }
    21     }
    22     
    23 }

    下面是实体类实现comparable接口

    package com.demo.advice;
    
    public class Users implements Comparable<Users> {
    
        private int id;
        private String name;
        private int age;
        public Users() {
            super();
            // TODO Auto-generated constructor stub
        }
        public Users(Integer id, String name, Integer age) {
            super();
            this.id = id;
            this.name = name;
            this.age = age;
        }
        @Override
        public String toString() {
            return "Users [id=" + id + ", name=" + name + ", age=" + age + "]";
        }
        
        
        public int getId() {
            return id;
        }
        public void setId(int id) {
            this.id = id;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        @Override
        public int compareTo(Users o) {
            int i = this.getId() - o.getId();
            if (i==0) {
                return this.getAge() - o.getAge();
            }
            return i;
            // TODO Auto-generated method stub
            
        }
    }

     

    比较的结果截图

    如果要按姓名排序

     

    转载于:https://www.cnblogs.com/xaoco/p/9133377.html

    展开全文
  • C++ set自定义排序

    万次阅读 多人点赞 2018-04-02 15:07:53
    针对自定义数据结构或者说自定义set排序规则有如下几种方法: 方法一 重载&lt; 在自定义结构体中重载&lt; 则可以实现默认排序,示例代码如下: #include&lt;iostream&gt; #i...
  • c++容器 set 自定义排序

    万次阅读 多人点赞 2018-04-03 16:31:49
    set c++ reference是c++中的一种容器,set可以用二叉树搜索树实现,set有两个特点:1. set中的元素不允许重复;...默认定义了compare函数利用set内部默认的compare函数,可以将整数从小到大排序,将字符...
  • 代码如下: import operator list_a = [1,2,3,4,5,6,1,1,1,2,2,3,4,4,5,5,5,5,6,6,6,6,6,6] ...set_a = list(set(list_a)) # 去重得到一个集合 print("set_a: " + str(set_a) + '\n') c...
  • Set集合的排序

    千次阅读 2018-04-22 13:51:58
    TreeSet使用元素的自然顺序对元素进行排序,或者根据创建set时提供的Comparator进行排序,具体取决于使用的构造方法。通俗一点来说,就是可以按照排序后的列表显示,也可以按照指定的规则排序Set&lt;String&...
  • 1.软件开发过程中集合排序是比较强大的功能,会使用集合Map、Set、List实现排序功能,知道匿名内部类Comparator很关键,搞清楚集合排序的性能开销,排序遇到的坑以及解决的方法,注意下面的例子都是JDK1.8的用法。...
  • STL set里面会自动排序

    千次阅读 2019-04-11 18:44:16
    set里面会自动排序(从小到大),以后可以利用好这个特性 set里面用的是平衡二叉搜索树(也就是红黑树)维护 看代码 #include <iostream> #include <set> using namespace std; int main() { set&...
  • set集合的排序

    千次阅读 2015-07-22 10:59:24
    在hibernate的OneToMany的实体关联的时候,one端的set是无序的,可是需要按照顺序来搞的话就比较麻烦了。 下面给出一个例子。 Set diaryPictureSet = growthDiary.getDiaryPictures(); List diaryPictureList = ...
  • set集合实现排序

    2014-03-05 23:56:47
    键盘输入以上数据(包括姓名,三门课成绩), 输入的格式:如:zhagnsan,30,40,60计算出总成绩, 并把学生的信息和计算出的总分数高低顺序存放在磁盘文件"stud.txt"中。(如果总分相同,按照姓名排序)
  • set集合排序

    千次阅读 2014-04-11 19:42:36
    * 给字符串时间的set排序 * @return 有序的set集合 */ public static Set getSort(){ Set<String> st = new TreeSet(new Comparator() { public int compare(Object o1, Object o2) { String ...
  • 自然排序:也就是自然发生的,在创建集合对象时不需要给参数。注:往TreeSet集合对象中添加元素是,元素必须是可比的(Integer 、Double、Float….),假如是自定义类型Student,就必须让Student实现Comparable接口*...
  • Java数组去重排序从大到小

    千次阅读 2018-07-31 11:22:04
    Java小白的独立写出的第一个Java程序,虽然是很简单的程序,氮素我也花了很长的时间,写出来还是很开心的 ... * 数组去重排序 */ public class arrayaa { public static void main(String[] args) { int demo...
  • // 从小到大顺序排序 minSort (arr) { var min for (var i = 0; i &lt; arr.length; i++) { for (var j = i; j &lt; arr.length; j++) { if (arr[i].coupon.faceMoney &gt; arr[j...
  • 题目:随机生成100个小于1000的数,从大到小排序,并输出次最大值。 拿题目的时候,想的好简单,冒泡排序从大到小,取数组中第二个数,就是次最大值。回来又细想了下,如果随机生成的数中有重复值,这么做就...
  • java set集合排序

    万次阅读 2017-11-14 13:16:47
    Set set = new HashSet(); set.add("aaaa"); set.add("bbbb"); List list = new ArrayList(set) Collections.sort(list);

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 673,118
精华内容 269,247
关键字:

set的从大到小排序