精华内容
下载资源
问答
  • 集合排序

    2011-07-09 10:20:00
    26. 集合排序成绩: 10 / 折扣: 0.8现有若干个集合的数据,每个数据集合可以自选一个指标参加排序。这些指标包含如下四种:Min,取集合中元素的最小值 Max,取集合中元素的最大值 Mean,取集合中元素的平均值,平均值...
     

    26. 集合排序

    成绩: 10 / 折扣: 0.8

    现有若干个集合的数据,每个数据集合可以自选一个指标参加排序。这些指标包含如下四种:

    • Min,取集合中元素的最小值
    • Max,取集合中元素的最大值
    • Mean,取集合中元素的平均值,平均值的计算公式为:(V1+V2+…+Vn) / n
    • Median,取集合中元素的中值,中值的计算公式为:(Vmin+Vmax) / 2

    读入数据后,请根据各个集合选择的指标对这些集合进行降序排列,每个集合内的元素请升序排列。

    输入

    每行一个集合。[]内为该集合选取的用于集合间排序的指标。随后为集合内各个元素,元素个数不定,以空格分隔。

    输出

    每行输出一个集合。{} 内为计算出该集合的排序指标值,随后为该集合的各个元素的升序排列。

     

    #include<stdio.h>
    #include<string.h>
    #include<math.h>
    #define M 200
    void min_max(int a[],int k);
    void print();
    int i;
    static int b[M][M]={0},d[M]={0};
    int main()
    {  char a[M][M],e=' ';
       int j,k=0,t=0,m=0;
      
       for(i=0;;i++)
        { j=0;e=' ';
          do { if(scanf("%c",&a[i][j++])==EOF)
    			{	print();
    				return 0;
    			}
    	 }  while(a[i][j-1]!=']');
          a[i][j]='\0';
          while(e!='\n')
    	 { scanf("%d",&b[i][k++]);
    	   e=getchar();
    	  }
          min_max(b[i],k);
          k--;
          if(!strcmp(a[i],"[Max]"))  d[i]=b[i][k];
          if(!strcmp(a[i],"[Min]"))  d[i]=b[i][0];
          if(!strcmp(a[i],"[Median]"))  d[i]=(b[i][0]+b[i][k])/2;
          if(!strcmp(a[i],"[Mean]"))
    	{ for(j=k;j>=0;j--)
    	    { d[i]+=b[i][j];
    	    }
    	  d[i]=d[i]/(k+1);
    	}
          b[i][k+1]=-1;
          k=0;m=0;t=0;
        }
    }
    
    void min_max(int b[],int n)
    {   int i,j,m,t;
        for(i=0;i<n-1;i++)
         { m=i;
           for(j=i+1;j<n;j++)
    	 { if(b[j]<b[m])
    	       m=j;
    	 }
           if(m!=i)
    	 { t=b[m];
    	   b[m]=b[i];
    	   b[i]=t;
    	 }
         }
    }
     
    void print()
    {	int k,m,t,j;
    	i--;k=i;
       for(;k>=0;k--)
         { m=i;t=0;
           for(j=i+1;j>=0;j--)
    	 {  if(d[j]>d[m]) m=j;
    	 }
           printf("{%d}",d[m]);
           while(1)
    	{ if(t==0) printf("%d",b[m][t]);
    	  if(t>0&&b[m][t]!=-1)  printf(" %d",b[m][t]);
    	  if(t>0&&b[m][t]==-1)  {printf("\n");break;}
    	  t++;
    	}
    	   d[m]=-1;
         }
    }


     

    展开全文
  • 1.软件开发过程中集合排序是比较强大的功能,会使用集合Map、Set、List实现排序功能,知道匿名内部类Comparator很关键,搞清楚集合排序的性能开销,排序遇到的坑以及解决的方法,注意下面的例子都是JDK1.8的用法。...

    一、背景

    1.软件开发过程中集合排序是比较强大的功能,会使用集合Map、Set、List实现排序功能,知道匿名内部类Comparator很关键,搞清楚集合排序的性能开销,排序遇到的坑以及解决的方法,注意下面的例子都是JDK1.8的用法。

    二、Set集合排序

    1.UML类图

    三、注意点

    1.我们先来说下集合的各个特点:

    2.List的主要特点以及用法

    2.1.可以允许存储重复的对象.

    2.2.可以插入多个null元素.

    2.3.是一个有序容器,保持了每一个元素的插入顺序,插入的顺序即输出的顺序.

    2.5.常用的实现类有 ArrayList、LinkedList 和 Vector。ArrayList 最为流行,它提供了使用索引的随意访问,而 LinkedList 则对于经常需要从 List 中添加或删除元素的场合更为合适.

    3.Set集合的主要特点及用法

    3.1 不允许重复对象 
    3.2 只允许一个 null 元素 
    3.3 无序容器,你无法保证每个元素的存储顺序,TreeSet通过 Comparator 或者 Comparable 维护了一个排序顺序 
    3.4 Set 接口最流行的几个实现类是 HashSet、LinkedHashSet 以及 TreeSet。最流行的是基于 HashMap 实现的 HashSet;TreeSet 还实现了 SortedSet 接口,因此 TreeSet 是一个根据其 compare() 和 compareTo() 的定义进行排序的有序容器

    4.Map集合的主要特点及用法 
    4.1 Map不是collection的子接口或者实现类。Map是一个接口。而List和Set是collection的子接口 
    4.2 Map 的 每个 Entry 都持有两个对象,也就是一个键一个值,Map 可能会持有相同的值对象但键对象必须是唯一的,这是双列集合的特点 
    4.3 TreeMap 也通过 Comparator 或者 Comparable 维护了一个排序顺序 
    4.4 Map 里你可以拥有随意个 null 值但最多只能有一个 null 键 
    4.5 Map 接口最流行的几个实现类是 HashMap、LinkedHashMap、Hashtable 和 TreeMap。(其中HashMap、TreeMap最常用)

    5. 区别 
    5.1、Collection 和 Map 的区别 
    容器内每个为之所存储的元素个数不同。 
    Collection类型者,每个位置只有一个元素。 
    Map类型者,持有 key-value pair,像个小型数据库。

    5.2、各自旗下的子类关系 
    Collection 
    –List:将以特定次序存储元素。所以取出来的顺序可能和放入顺序不同。 
    –ArrayList / LinkedList / Vector 
    –Set : 不能含有重复的元素 
    –HashSet / TreeSet 
    Map 
    –HashMap 
    –HashTable 
    –TreeMap

    四、第一种做法(排序)

    1.实体类

    public class Person{
        private String id;
        private String name;
        private String address;
    
        public Person(String id, String name, String address) {
            this.id = id;
            this.name = name;
            this.address = address;
        }
    
        public String getId() {
            return id;
        }
    
        public void setId(String id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "id='" + id + '\'' +
                    ", name='" + name + '\'' +
                    ", address='" + address + '\'' +
                    '}';
        }
    }

    2.测试类

    public class TreeSetTest {
        public static void main(String[] args) {
    
            Set<Person> set = new TreeSet<Person>(new Comparator<Person>() {
                @Override
                public int compare(Person o1, Person o2) {
                    return new Double(o1.getId()).compareTo(new Double(o2.getId()));//升序排列
                }
            });
            //产生100以内的随机数
            int num = (int)(Math.random()*100+1);
            for(int i=num;i>0;i--){
                set.add(new Person(""+i,"张三","河南"));
            }
            for(Object o : set){
                System.out.println(o);
            }
        }
    }
    

    3.结果(升序)

    Person{id='1', name='张三', address='河南'}
    Person{id='2', name='张三', address='河南'}
    Person{id='3', name='张三', address='河南'}
    Person{id='4', name='张三', address='河南'}
    Person{id='5', name='张三', address='河南'}
    Person{id='6', name='张三', address='河南'}
    Person{id='7', name='张三', address='河南'}
    Person{id='8', name='张三', address='河南'}
    Person{id='9', name='张三', address='河南'}
    Person{id='10', name='张三', address='河南'}
    Person{id='11', name='张三', address='河南'}

    4.如果要倒序(改动一下面这个就行了)

    Set<Person> set = new TreeSet<Person>(new Comparator<Person>() {
                @Override
                public int compare(Person o1, Person o2) {
                    return new Double(o2.getId()).compareTo(new Double(o1.getId()));//降序排列
                }
            });

    五、第二种做法

    1.实体类

    public class Person implements Comparable<Person> {
        private String id;
        private String name;
        private String address;
    
        public Person(String id, String name, String address) {
            this.id = id;
            this.name = name;
            this.address = address;
        }
    
        public String getId() {
            return id;
        }
    
        public void setId(String id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "id='" + id + '\'' +
                    ", name='" + name + '\'' +
                    ", address='" + address + '\'' +
                    '}';
        }
    
        @Override
        public int compareTo(Person o) {
            if (o instanceof Person) {
                Person o1 = (Person) o;
                return new Double(o1.getId()).compareTo(new Double(this.getId()));
            }
            throw new ClassCastException("不能转换为Person类型的对象...");
        }
    }

    2.测试类

    public class TreeSetTest {
        public static void main(String[] args) {
    
            Set<Person> set = new TreeSet<Person>();
    
            //产生100以内的随机数
            int num = (int)(Math.random()*100+1);
            for(int i=num;i>0;i--){
                set.add(new Person(""+i,"张三","河南"));
            }
            for(Object o : set){
                System.out.println(o);
            }
        }
    }

     3.结果(倒列),正序需调换下实体类中的比较对象的位置

    Person{id='10', name='张三', address='河南'}
    Person{id='9', name='张三', address='河南'}
    Person{id='8', name='张三', address='河南'}
    Person{id='7', name='张三', address='河南'}
    Person{id='6', name='张三', address='河南'}
    Person{id='5', name='张三', address='河南'}
    Person{id='4', name='张三', address='河南'}
    Person{id='3', name='张三', address='河南'}
    Person{id='2', name='张三', address='河南'}
    Person{id='1', name='张三', address='河南'}

    六、结束

    上面是对set集合中的TreeSet排序进行的总结。

    Always keep the faith!!!

    展开全文
  • 1.软件开发过程中集合排序是比较强大的功能,会使用集合Map、Set、List实现排序功能,知道匿名内部类Comparator很关键,搞清楚集合排序的性能开销,排序遇到的坑以及解决的方法,注意下面的例子都是JDK1.8的用法。...

    一、背景

    1.软件开发过程中集合排序是比较强大的功能,会使用集合Map、Set、List实现排序功能,知道匿名内部类Comparator很关键,搞清楚集合排序的性能开销,排序遇到的坑以及解决的方法,注意下面的例子都是JDK1.8的用法。

    二、UML的类图

    三、第一种方法

    1.实体类

    public class Person {
        private String id;
        private String name;
        private String address;
    
        public Person(String id, String name, String address) {
            this.id = id;
            this.name = name;
            this.address = address;
        }
    
        public String getId() {
            return id;
        }
    
        public void setId(String id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "id='" + id + '\'' +
                    ", name='" + name + '\'' +
                    ", address='" + address + '\'' +
                    '}';
        }
    
      }
    }

    2.测试类

    public class TreeMapTest {
        public static void main(String[] args) {
    
            Map<String, Person> treeMap = new TreeMap<String, Person>(new Comparator<String>() {
                @Override
                public int compare(String o1, String o2) {
                   return new Double(o2).compareTo(new Double(o1));
                }
            });
            //产生100以内的随机数
            int num = (int)(Math.random()*100+1);
            for(int i=num;i>0;i--){
                treeMap.put(""+i,new Person(""+i,"张三","河南"));
            }
            Iterator it = treeMap.keySet().iterator();
            while (it.hasNext()) {
                //it.next()得到的是key,treeMap.get(key)得到obj
                System.out.println(treeMap.get(it.next()));
            }
        }
    }
    

    3.结果(降序)

    Person{id='11', name='张三', address='河南'}
    Person{id='10', name='张三', address='河南'}
    Person{id='9', name='张三', address='河南'}
    Person{id='8', name='张三', address='河南'}
    Person{id='7', name='张三', address='河南'}
    Person{id='6', name='张三', address='河南'}
    Person{id='5', name='张三', address='河南'}
    Person{id='4', name='张三', address='河南'}
    Person{id='3', name='张三', address='河南'}
    Person{id='2', name='张三', address='河南'}
    Person{id='1', name='张三', address='河南'}
    

    四、总结

    1.compareTo(String str) :是String 提供的一个方法,如果参数字符串等于此字符串, 则返回 0 值;如果按字典顺序此字符串小于字符串参数,则返回一个小于 0 的值;如果按字典顺序此字符串大于字符串参数,则返回一个大于 0 的值。
       int compare(T o1,T o2):随第一个参数小于、等于或大于第二个参数而分别返回负整数、零或正整数。

    2.compareTo就是比较两个值,如果前者大于后者,返回1,等于返回0,小于返回-1,我下面给出了例子,由于比较的变量我用的是int,int型可以直接比较,所有没有用到compareTo比较,如果声明的是Date、String、Integer或者其他的,也可以直接使用compareTo比较,比如以下函数代码用法:

    public int compareTo(TestModel1 o) {

    return this.str1.compareTo(o.str1);

    }

    五、结束

    Always keep the faith!!!

    展开全文
  • java集合排序

    2018-12-20 05:12:46
    List集合排序 2 将三个人的姓名年龄set进Person类中并添加到list集合里,运行一下,看控制台打印结果 List集合排序 3 我们可以看到控制台输出的结果是按照我们set进去的顺序是一样到 List集合排序 4 使用冒泡排序将...

    新建一个Person类,这里测试用到两个属性,name和age

    重写toString方法方便调试

    List集合排序
    2
    将三个人的姓名年龄set进Person类中并添加到list集合里,运行一下,看控制台打印结果

    List集合排序
    3
    我们可以看到控制台输出的结果是按照我们set进去的顺序是一样到

    List集合排序
    4
    使用冒泡排序将人的信息按照年龄大到小的顺序进行排序

    List集合排序
    5
    控制台输出结果显示顺序为:大到小的顺序

    List集合排序
    6
    使用Collections集合类进行排序,前面因为被冒泡排序进行过由大到小排序这里我们进行由小到大排序

    List集合排序
    7
    控制台输出结果顺序为由小到大显示

    List集合排序

    展开全文
  • Java排序之集合排序

    2016-10-10 15:29:56
    集合排序 要么让集合的对象具有比较性也就是让集合中的对象实现Comparable接口 自定义比较器实现Comparator 举例:按人的年龄排序代码如下 - UserBean对象/** * Created by yuandl on 2016-10-10. */ public ...
  • JAVA中对集合排序

    千次阅读 2021-03-21 23:49:12
    JAVA中对集合排序 1.集合排序的基本概念 集合排序,它可以使用集合的工具类java.util.Collections 其定义了很多静态方法,用于操作集合,其中sort方法是对list集合进行自然排序(从小到大)。 public class ...
  • * 集合排序; * * 首先先看一下关于集合的排序Demo; * * 先创建一个自己的测试类; * @author Administrator * */ public class SortTest { public static void main(String[] args).
  • scala集合排序The collection includes all those data structures that are used to store multiple elements or collections of elements like Array, List, Set, Vector, etc. 集合包括所有用于存储多个元素或...
  • Redis 集合排序

    千次阅读 2017-09-19 22:44:04
    排序主要针对的是集合操作,即List、Set、ZSet这三种集合。 排序操作主要依赖于如下几个...尽量使用limit限制获取的数据量集合排序返回或保存给定列表、集合、有序集合 key 中经过排序的元素,默认是升序语法:sort
  • List集合排序

    2019-05-20 19:08:51
    需求:对一个集合排序,集合中存放的是自定义对象。按照自定义对象的2个属性排序【小–>大】【大–>小】 1、List中是基本数据类型or包装数据类型 public static void main(String[] args) { List<...
  • Java集合排序

    2016-09-21 11:52:39
    写点示范代码演示集合排序 1,List集合排序,按照自然排序可以调用JDK的工具Collections.sort()方法; import java.util.ArrayList; import java.util.Collections; import java.util.List;public class SortString { ...
  • map集合排序

    千次阅读 2017-08-04 12:15:13
    百度了一下,膜拜了一下大佬的博客 map集合排序 但是感觉有些繁琐,因为比较菜,对Comparator比较器不熟悉,就自己想了一种易于理解办法。 场景是这样的,一个Map中,泛型为,现在要按照value从大到小对这个集合...
  • JAVA 集合排序

    2018-07-06 16:17:24
    //集合排序, List arrayList = new ArrayList(enterpriseEntityList1); Collections.sort(arrayList, new Comparator&lt;EnterpriseEntity&gt;() { @Override public int compare(EnterpriseEntity o1, E...
  • Java集合排序及java集合类详解

    千次阅读 2018-11-09 07:24:41
    Java集合排序及java集合类详解
  • 在有些场景可能会需要通过程序对集合中的元素进行排序,本文总结一下List集合排序可以通过哪些方式来实现 1.使用集合的工具类Collections对ArrayList集合进行排序 简单的整数型排序: 当集合的范型为Integer类型...
  • List集合排序、自定义比较器排序

    千次阅读 2019-08-20 17:25:12
    List集合排序 1、集合工具类(包装类)Collections.sort 使用Collections提供的sort方法,对集合进行排序 Collections.sort(list); 实现原理: 将list转成了数组对象后,调用了Array的sort方法,将数组排序,再用...
  • java中的各种集合排序

    千次阅读 2019-05-03 01:44:35
    1.软件开发过程中集合排序是比较强大的功能,会使用集合Map、Set、List实现排序功能,知道匿名内部类Comparator很关键,搞清楚集合排序的性能开销,排序遇到的坑以及解决的方法,注意下面的例子都是JDK1.8的用法。...
  • Android数字集合排序

    2019-08-18 11:58:08
    Android数字集合排序 遇到了记一下 List<Long> sortedKeys = new ArrayList<>(); sortedKeys.add((long) 2); sortedKeys.add((long) 1); sortedKeys.add((long) 4); sortedKeys.add((long) 3); ...
  • C++ STL集合排序

    2018-08-23 18:28:59
    C++ STL集合排序 map&amp;lt;key,value&amp;gt;和set&amp;lt;key&amp;gt;的内置键值比较函数排序 // 按照键值升序排列 map&amp;lt;string,int,less&amp;lt;string&amp;gt;&...
  • 【1】Collection与Collectionscollection接口是list、set和queue接口的父接口。其是一个 泛型接口,继承自Iterable&...【2】集合排序两个方法集合的排序,常常用Collections两个方法:① Collections.sort(songList)
  • Java集合排序操作
  • 数组排序和集合排序的使用

    千次阅读 2016-01-23 13:14:09
    **数组排序和集合排序的使用:**废话不多说,直接上代码和结果 Arrays.sort(str): String[] str = new String[] {“china”,”guangzhou”,”beijing”}; System.out.println(Arrays.toString(str)); Arrays....
  • 泛型集合排序,按泛型类型的特定子类的属性排序,只要求特定子类排序
  • List集合排序,以及截取字集合

    千次阅读 2014-11-11 21:47:05
    1. List 集合排序: 1.1. List集合里面的对象实现
  • scala集合排序

    千次阅读 2017-08-01 09:24:32
     你想要对一个集合元素进行排序。或者你想定义一个自定义类来实现Ordered trait,来让你可以使用sorted方法,或者使用比较操符,>=来对类的实例进行比较。 Solution  你可以使用sorted或者sortWith方法来对集合...
  • 顺序排列的集合排序为树形集合

    千次阅读 2017-12-07 12:55:58
    ID , 父ID,层级,当前层排序号 (例子如下) 层级和当前层排序号为提供原始集合排序使用 public class ResourceVo { /** * 资源编号 */ private String id; /** * 资源名称 */ private String ...
  • JAVA中的集合排序

    千次阅读 2018-02-21 16:32:34
    版权声明:未经允许,随意转载...JAVA集合排序 基本类型和字符串类型排序 基本类型和字符串类型排序直接调用 Collections.sort(list);根据元素的自然顺序对指定列表按升序进行排序 + 对存储在List中的整型数据...
  • C# IList集合扩展方法 -- 集合排序

    千次阅读 2016-03-31 16:07:07
    在平常开发中,经常要遇到集合排序的功能,可以用集合自带的Sort 或者OrderBy方法进行排序,但是要自定义比较器,每次使用都比较麻烦,所以就自己琢磨写了个集合的扩展方法,专门用来排序集合,起名叫做 “OrderBy...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 35,966
精华内容 14,386
关键字:

集合排序