sort排序

Java中常用的数组或集合排序的方法有两个，一个是java.util.Arrays中的静态方法Arrays.sort（），还有一个是java.util.Collections中的静态方法的Collections.sort()方法

实现原理：sort并不是简单的快速排序，它对普通的快速排序进行了优化，此外，它还结合了插入排序和推排序。系统会根据你的数据形式和数据量自动选择合适的排序方法，这并不是说它每次排序只选择一种方法，它是在一次完整排序中不同的情况选用不同方法，比如给一个数据量较大的数组排序，开始采用快速排序，分段递归，分段之后每一段的数据量达到一个较小值后它就不继续往下递归，而是选择插入排序，如果递归的太深，他会选择推排序。

一.Arrays.sort()

Arrays中的sort()方法主要是针对各种数据类型（基本数据类型和引用对象类型）的数组元素排序。

1.1 基本数据类型排序

• Arrays.sort(数组名) 数组排序，默认为升序
• Arrays.sort(数组名，int fromIndex,int toIndex) 对数组指定的范围进行排序（从索引 fromIndex（包括）一直到索引toIndex（不包括））
• Arrays.sort(数组名，Collections.reverseOrder()) 降序
  注:Arrays.sort(a,Collections.reverseOrder())不支持基本类型(int，double，char等)，int型需要改成Integer，float要改成Float。

import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
	Integer[] ans=new Integer[]{3,1,6,2,9};
	Integer[] ans1=new Integer[]{3,1,6,2,9};
	Arrays.sort(ans);
	Arrays.sort(ans1,2,5,Collections.reverseOrder());
	for(int i:ans){
		System.out.print(i+" ");
	}
	System.out.println();
	for(int i:ans1){
		System.out.print(i+" ");
	}
    }
  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

1.2 引用对象类型排序

引用对象类型数组的排序sort()方法要用到接口Comparator，对其排序内部的比较函数compare()进行重写，以便于我们按照我们的排序要求对引用对象数组极性排序，默认是升序排序，但可以自己自定义成降序排序

• Arrays.sort(T[] a,Comparator<? super T> c)

public class Test {
    public static void main(String[] args) {
        /*
         * 注意，要想改变默认的排列顺序，不能使用基本类型（int,double,char）而要使用它们对应的类
         */
        Integer[] a = { 9, 8, 7, 2, 3, 4, 1, 0, 6, 5 };
        // 定义一个自定义类MyComparator的对象
        Comparator cmp = new MyComparator();
        Arrays.sort(a, cmp);
        for (int arr : a) {
            System.out.print(arr + " ");
        }
    }
}
// 实现Comparator接口
class MyComparator implements Comparator<Integer> {
    @Override
    public int compare(Integer o1, Integer o2) {
        /*
         * 如果o1小于o2，我们就返回正值，如果o1大于o2我们就返回负值， 这样颠倒一下，就可以实现降序排序了,反之即可自定义升序排序了
         */
        return o2 - o1;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

二.Collections.sort()

Collections类中的sort方法可以实现对List接口的集合进行排序。这个方法假定列表元素实现了Comparable接口。

• Collections.sort(List list):将集合中的元素按照默认规则排序

//定义一个字符串的list集合,并排序
        List<String> list = new ArrayList<>();
        list.add("123");
        list.add("213");
        list.add("abc");
        list.add("aac");
        list.add("112");
        list.add("224");
        list.add("223");
        list.add("Aac");
        System.out.println(list);
        //[123, 213, abc, aac, 112, 224, 223, Aac]

        Collections.sort(list);
        System.out.println(list);
        //[112, 123, 213, 223, 224, Aac, aac, abc]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

• Collections.sort(List list,Comparator<? super T>):将集合中元素按照指定规则排序
  方式一：

class Students{
	String name;
	int age;
	public Students(String name,int age){
		this.name=name;
		this.age=age;
	}
}
public class Test9 {
    public static void main(String[] args) {
       ArrayList<Students> list=new ArrayList<Students>();
       list.add(new Students("张三", 18));
       list.add(new Students("李四", 16));
       list.add(new Students("王二", 21));
       list.add(new Students("麻子", 25));
       Collections.sort(list,new Comparator<Students>() {
    @Override
    public int compare(Students o1, Students o2) {
     //return o1.age - o2.age;升序
       return o2.age - o1.age;//降序
    }
    });
       for(Students s:list){
    	   System.out.println(s.name+" "+s.age);
       }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

方式二：

class Students implements Comparable<Students>{
	String name;
	int age;
	public Students(String name,int age){
		this.name=name;
		this.age=age;
	}
	public int compareTo(Students s) {
		// TODO Auto-generated method stub
		return s.age-this.age;//降序
	}
	
}
public class Test9 {
    public static void main(String[] args) {
       ArrayList<Students> list=new ArrayList<Students>();
       list.add(new Students("张三", 18));
       list.add(new Students("李四", 16));
       list.add(new Students("王二", 21));
       list.add(new Students("麻子", 25));
       Collections.sort(list);
       for(Students s:list){
    	   System.out.println(s.name+" "+s.age);
       }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

推荐算法练习题：
分数线划定
帮贡排序
蓝桥杯2021年真题：
双向排序
不过这题用sort，相当于用暴力枚举只能得60分，会显示超时

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
import java.util.Arrays;
import java.util.Collections;
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
       
       int n=scanner.nextInt();
       int m=scanner.nextInt();
       Integer[] ans=new Integer[n];
       for(int i=0;i<n;i++){
           ans[i]=i+1;
       } 
       for(int j=0;j<m;j++){
           int p=scanner.nextInt();
           int q=scanner.nextInt();
           if(p==0){
               Arrays.sort(ans,0,q,Collections.reverseOrder());
           }else{
               Arrays.sort(ans,q-1,ans.length);
           }
       }
   for(int a :ans){
                 System.out.print(a+" ");
             }
        scanner.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

此题正解请参考以下博客：
https://blog.csdn.net/qq_53269123/article/details/122832906