您的位置: 首页  >  文章  >  JAVA中sort函数的使用方法的个人总结

JAVA中sort函数的使用方法的个人总结

分类: 文章 • 2024-03-20 15:44:40

首先：sort函数的基本格式（默认排序为升序排序）

[cpp] view plain copy
  1. Arrays.sort(数组名,起始下标,终止下标);   


我们举个简单的例子

[java] view plain copy
  1. import java.util.*;    
  2. import java.util.Arrays;    
  3. public class Main {    
  4.     public static void main(String[] args) {    
  5.             
  6.         Scanner in=new Scanner(System.in);    
  7.             
  8.         while(in.hasNext())    
  9.         {    
  10.             int num[]=new int[100];    
  11.                 
  12.             int n;///输出n个数    
  13.             n=in.nextInt();    
  14.                 
  15.             for(int i=0;i<n;i++)    
  16.             {    
  17.                 num[i]=in.nextInt();    
  18.                     
  19.             }    
  20.                 
  21.             Arrays.sort(num,0,n);///排序部分    
  22.                 
  23.             for(int i=0;i<n;i++)    
  24.             {    
  25.                 System.out.println(num[i]);    
  26.                     
  27.             }    
  28.         }    
  29.     
  30.     }    
  31. }    

这个代码输入n个数，并把他们从小到大排序，运行结果如下。

JAVA中sort函数的使用方法的个人总结


大家注意一下，这里的起始下标和终止下标一定要是整形数。不能是浮点型。不然会报


用sort函数对浮点数呢？

[java] view plain copy
  1. import java.util.*;    
  2. import java.util.Arrays;    
  3. public class Main {    
  4.     public static void main(String[] args) {    
  5.             
  6.         Scanner in=new Scanner(System.in);    
  7.             
  8.         while(in.hasNext())    
  9.         {    
  10.             double  num[]=new double[100];    
  11.                 
  12.             int n;///输出n个数    
  13.             n=in.nextInt();    
  14.                 
  15.             for(int i=0;i<n;i++)    
  16.             {    
  17.                 num[i]=in.nextDouble();    
  18.                     
  19.             }    
  20.                 
  21.             Arrays.sort(num,0,n);///排序部分    
  22.                 
  23.             for(int i=0;i<n;i++)    
  24.             {    
  25.                 System.out.println(num[i]);    
  26.                     
  27.             }    
  28.         }    
  29.     
  30.     }    
  31. }    

运行结果如下


JAVA中sort函数的使用方法的个人总结


如果一个数组初始化时已经赋值。则SORT函数可以另外一种格式

[java] view plain copy
  1. Arrays.sort(数组名);   

举个例子

[java] view plain copy
  1. import java.util.*;    
  2. import java.util.Arrays;    
  3. public class Main {    
  4.     public static void main(String[] args) {    
  5.             
  6.         Scanner in=new Scanner(System.in);    
  7.             
  8.         
  9.             int num[]= {5,4,3,2,1};    
  10.                 
  11.             Arrays.sort(num);    
  12.                 
  13.             for(int i=0;i<5;i++)    
  14.             {    
  15.                 System.out.println(num[i]);    
  16.                     
  17.             }    
  18.         
  19.     
  20.     }    
  21. }    



然而，只是单纯的降序升序排序是满足不了使用需求得。

所以，我们要研究下sort函数中cmp函数的使用方法


我们来看看cmp函数的格式

[java] view plain copy
  1. int compare(Object o1, Object o2);    

我们可以看到，传入函数的是java中的类（java中没有结构体）

这时，sort函数的格式变为

[java] view plain copy
  1. Arrays.sort(数组名, 起始下标, 终止下标, new cmp());    

怎么自定义排序呢？

基本方法

int compare(Object o1, Object o2) 返回一个基本类型的整型
如果要按照升序排序，
则o1 小于o2，返回-1（负数），相等返回0，01大于02返回1（正数）
如果要按照降序排序
 则o1 小于o2，返回1（正数），相等返回0，01大于02返回-1（负数）


以上就是在cmp函数中的自定义排序方法。


我们来举个例子。-----输入n个数，然后降序排序。

[java] view plain copy
  1. import java.util.Arrays;    
  2. import java.util.Comparator;    
  3. import java.util.Scanner;    
  4. import java.util.*;      
  5.     
  6. class shu ///创建类    
  7. {    
  8.     int x;    
  9. }    
  10.     
  11. class cmp implements Comparator<shu> {    
  12.     /*  
  13.      * 因为上面指定了类型<he>，所以此处可以直接(he A,he B) 否则要写成(Object A,Object  
  14.      * B)，再强制转换成he类型：((he)A).x  
  15.      */    
  16.     public int compare(shu A, shu B) ///降序排序    
  17.     {    
  18.             if(A.x<B.x)    
  19.             {    
  20.                 return 1;    
  21.             }    
  22.             else if(A.x==B.x)    
  23.             {    
  24.                 return 0;    
  25.             }    
  26.             else    
  27.             {    
  28.                 return -1;    
  29.             }    
  30.     
  31.     }    
  32. }    
  33.     
  34. public class Main {    
  35.     public static void main(String[] args) {    
  36.             
  37.         Scanner in = new Scanner(System.in);    
  38.     
  39.         while (in.hasNext()) {    
  40.                 
  41.             shu num[] = new shu[100];///创建类数组    
  42.     
  43.             int n;    
  44.             n = in.nextInt();    
  45.     
  46.             for (int i = 0; i < n; i++) {    
  47.                     
  48.                 num[i]=new shu();///这个地方容易漏    
  49.                     
  50.                 num[i].x = in.nextInt();    
  51.             }    
  52.                 
  53.             Arrays.sort(num, 0, n, new cmp());    
  54.                 
  55.             for (int i = 0; i < n; i++) {    
  56.                 System.out.println(num[i].x);    
  57.             }    
  58.     
  59.         }    
  60.     }    
  61. }    


运行结果

JAVA中sort函数的使用方法的个人总结



为了更好地理解，我们来举一些关于java结构体排序的题目


例一:HRBUST 1095 最麻烦了   点击打开链接


[java] view plain copy
  1. import java.util.Arrays;    
  2. import java.util.Comparator;    
  3. import java.util.Scanner;    
  4. import java.util.*;      
  5.     
  6. class shu ///创建类    
  7. {    
  8.     int acm;    
  9.     int mon;    
  10.     int rp;    
  11. }    
  12.     
  13. class cmp implements Comparator<shu> {    
  14.     public int compare(shu A, shu B) ///降序排序    
  15.     {    
  16.             if(A.acm==B.acm)    
  17.             {    
  18.                 if(A.mon==B.mon)    
  19.                 {    
  20.                     if(A.rp<B.rp)    
  21.                     {    
  22.                         return 1;    
  23.                     }    
  24.                     else if(A.rp==B.rp)    
  25.                     {    
  26.                         return 0;    
  27.                     }    
  28.                     else    
  29.                     {    
  30.                         return -1;    
  31.                     }    
  32.                 }    
  33.                 else    
  34.                 {    
  35.                     if(A.mon<B.mon)    
  36.                     {    
  37.                         return 1;    
  38.                     }    
  39.                     else if(A.mon==B.mon)    
  40.                     {    
  41.                         return 0;    
  42.                     }    
  43.                     else    
  44.                     {    
  45.                         return -1;    
  46.                     }    
  47.                 }    
  48.             }    
  49.             else    
  50.             {    
  51.                 if(A.acm<B.acm)    
  52.                 {    
  53.                     return 1;    
  54.                 }    
  55.                 else if(A.acm==B.acm)    
  56.                 {    
  57.                     return 0;    
  58.                 }    
  59.                 else    
  60.                 {    
  61.                     return -1;    
  62.                 }    
  63.             }    
  64.     
  65.     }    
  66. }    
  67.     
  68. public class Main {    
  69.     public static void main(String[] args) {    
  70.             
  71.         Scanner in = new Scanner(System.in);    
  72.     
  73.         while (in.hasNext()) {    
  74.                 
  75.             shu num[] = new shu[1005];///创建类数组    
  76.     
  77.             int n;    
  78.             n = in.nextInt();    
  79.     
  80.             for (int i = 0; i < n; i++) {    
  81.                     
  82.                 num[i]=new shu();///这个地方容易漏    
  83.                     
  84.                 num[i].acm = in.nextInt();    
  85.                 num[i].mon = in.nextInt();    
  86.                 num[i].rp  = in.nextInt();    
  87.             }    
  88.                 
  89.             Arrays.sort(num, 0, n, new cmp());    
  90.                 
  91.             for (int i = 0; i < n; i++) {    
  92.                 System.out.println(num[i].acm+" "+num[i].mon+" "+num[i].rp);    
  93.             }    
  94.     
  95.         }    
  96.     }    
  97. }    
  98. //int compare(Object o1, Object o2) 返回一个基本类型的整型    
  99. //如果要按照升序排序，    
  100. //则o1 小于o2，返回-1（负数），相等返回0，01大于02返回1（正数）    
  101. //如果要按照降序排序    
  102. // 则o1 小于o2，返回1（正数），相等返回0，01大于02返回-1（负数）    
  103. //    
这题还有另外一种写法。（借用的）

[java] view plain copy
  1. import java.util.*;  
  2.   
  3. class mans  
  4. {  
  5.     long acm,money,rp;  
  6. }  
  7. class cmp implements Comparator<mans>  
  8. {  
  9.     public int compare(mans a,mans b)  
  10.     {  
  11.         if(a.acm==b.acm)  
  12.         {  
  13.             if(a.money==b.money)  
  14.             {  
  15.                 return (int)(a.rp-b.rp);  
  16.             }  
  17.             return (int)(a.money-b.money);    
  18.         }  
  19.         return (int)(a.acm-b.acm);  
  20.     }  
  21. }  
  22. public class Main  
  23. {  
  24.   
  25.     public static void main(String[] args)  
  26.     {  
  27.         // TODO Auto-generated method stub  
  28.         Scanner scanf=new Scanner(System.in);  
  29.         mans a[]=new mans[1009];  
  30.         while(scanf.hasNext())  
  31.         {  
  32.             int n=scanf.nextInt();  
  33.             for(int i=0;i<n;i++)  
  34.             {  
  35.                 a[i] = new mans();  
  36.                 a[i].acm=scanf.nextLong();  
  37.                 a[i].money=scanf.nextLong();  
  38.                 a[i].rp=scanf.nextLong();  
  39.             }  
  40.             Arrays.sort(a,0,n,new cmp());  
  41.             for(int i=n-1;i>=0;i--)  
  42.             {  
  43.                 System.out.println(a[i].acm+" "+a[i].money+" "+a[i].rp);  
  44.             }  
  45.         }  
  46.     }  
  47. }  



但是更多的题目中，我们会遇到字典序排序的情况

这里，我们再举一个例子

例2：HRBUST 1023 JiaoZhu and C   点击打开链接

这个代码提交会超时！！！！！！！！！！！！！


[java] view plain copy
  1. import java.util.Arrays;    
  2. import java.util.Comparator;    
  3. import java.util.Scanner;    
  4. import java.util.*;      
  5.     
  6. class shu ///创建类    
  7. {    
  8.     String name;///比较时用String    
  9.     int mon;    
  10.     int hunt;    
  11. }    
  12.     
  13. class cmp implements Comparator<shu> {    
  14.     public int compare(shu A, shu B)     
  15.     {    
  16.             if(A.hunt==B.hunt)    
  17.             {    
  18.                 if(A.mon==B.mon)    
  19.                 {    
  20.                     int flag=(A.name).compareTo(B.name);///按字典序排序    
  21.                     if(flag==0)    
  22.                     {    
  23.                         return 0;    
  24.                     }    
  25.                     else if(flag<0)    
  26.                     {    
  27.                         return -1;    
  28.                     }    
  29.                     else    
  30.                     {    
  31.                         return 1;    
  32.                     }    
  33.                 }    
  34.                 else    
  35.                 {    
  36.                     if(A.mon==B.mon)    
  37.                     {    
  38.                         return 0;    
  39.     
  40.                     }    
  41.                     else if(A.mon<B.mon)    
  42.                     {    
  43.                         return -1;    
  44.                     }    
  45.                     else    
  46.                     {    
  47.                         return 1;    
  48.                     }    
  49.                             
  50.                 }    
  51.             }    
  52.             else    
  53.             {    
  54.     
  55.                 if(A.hunt==B.hunt)    
  56.                 {    
  57.                     return 0;    
  58.     
  59.                 }    
  60.                 else if(A.hunt<B.hunt)    
  61.                 {    
  62.                     return 1;    
  63.                 }    
  64.                 else    
  65.                 {    
  66.                     return -1;    
  67.                 }    
  68.             }    
  69.     
  70.                 
  71.     }    
  72.     
  73.     
  74. }    
  75.     
  76. public class Main {    
  77.     public static void main(String[] args) {    
  78.             
  79.         Scanner in = new Scanner(System.in);    
  80.     
  81.         while (in.hasNext()) {    
  82.                 
  83.             shu num[] = new shu[100005];///创建类数组    
  84.     
  85.             int n;    
  86.             n = in.nextInt();    
  87.     
  88.             for (int i = 0; i < n; i++) {    
  89.                     
  90.                 num[i]=new shu();///这个地方容易漏    
  91.                     
  92.                 num[i].name=in.next();    
  93.                 num[i].hunt=in.nextInt();    
  94.                 num[i].mon=in.nextInt();    
  95.             }    
  96.                 
  97.             Arrays.sort(num, 0, n, new cmp());    
  98.                 
  99.             for (int i = 0; i < n; i++) {    
  100.                 System.out.println(num[i].name);    
  101.             }    
  102.     
  103.         }    
  104.     }    
  105. }    

相关推荐