【蓝桥杯Java】数位排序（Arrays.sort(T[] a, Comparator c)与lambda表达式）

目录

问题描述

输入格式

输出格式

样例输入

样例输出

样例说明

思路解析

Arrays.sort详解

Arrays.sort(int[] a)

Arrays.sort(int[] a, int fromIndex, int toIndex)

public static void sort(T[] a, Comparator c)

解题代码

---

问题描述

小蓝对一个数的数位之和很感兴趣, 今天他要按照数位之和给数排序。当两个数各个数位之和不同时, 将数位和较小的排在前面, 当数位之和相等时, 将数值小的排在前面。

例如, 2022 排在 409 前面, 因为 2022 的数位之和是 6, 小于 409 的数位之和 13 。

又如, 6 排在 2022 前面, 因为它们的数位之和相同, 而 6 小于 2022 。

给定正整数 n,m, 请问对 1 到 n 采用这种方法排序时, 排在第 m 个的元素是多少?

输入格式

输入第一行包含一个正整数 n 。

第二行包含一个正整数 m 。

输出格式

输出一行包含一个整数, 表示答案。

样例输入

13
5

样例输出

3

样例说明

1 到 13 的排序为: 1,10,2,11,3,12,4,13,5,6,7,8,9。

第 5 个数为 3 。

思路解析

Arrays.sort详解

Arrays.sort(int[] a)

这个是最基础的，我们都知道可以将数组按从小到大的顺序进行排序。

int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
Arrays.sort(a);

结果：0 1 2 3 4 5 6 7 8 9 

Arrays.sort(int[] a, int fromIndex, int toIndex)

这个是对数组部分进行排序，对数组 a 的下标从 fromIndex 到 toIndex-1 的元素排序，括号左闭右开。

int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
Arrays.sort(a, 0, 3);

结果：7 8 9 2 3 4 1 0 6 5   --对索引为0到2的元素进行排序

public static void sort(T[] a, Comparator<? super T> c)

通常我们会有一些别的排序要求，比如从大到小排序这种。

这个时候，我们就需要重写 Comparator 比较器。

import java.util.Arrays;
import java.util.Comparator;

public class Main {
    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 i = 0; i < a.length; i ++) {
            System.out.print(a[i] + " ");
        }
    }
}
//Comparator是一个接口，所以这里我们自己定义的类MyComparator要implents该接口
//而不是extends Comparator
class MyComparator implements Comparator<Integer>{
    @Override
    public int compare(Integer o1, Integer o2) {
        //如果n1小于n2，我们就返回正值，如果n1大于n2我们就返回负值，
        //这样颠倒一下，就可以实现反向排序了
        if(o1 < o2) {
            return 1;
        }else if(o1 > o2) {
            return -1;
        }else {
            return 0;
        }
    }
}

结果：9 8 7 6 5 4 3 2 1 0 

当然，以上代码可以使用简单的一行 lambda 表达式进行表示。 

Arrays.sort(a, (o1, o2) -> (o2 - o1));

正常的话，Comparator 比较器对给定的两个操作对象 o1, o2，根据比较结果返回正数（o1 > o2）、负数(<)、零(=)。

这样实现的结果是对数组进行从小到大的排序。

重写完是根据比较结果返回  1（o1 < o2）、-1（o1 > o2）与默认相反，从而实现从大到小的排序。

解题代码

import java.util.Scanner;
import java.util.Arrays;
// 1:无需package
// 2: 类名必须Main, 不可修改

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        int n = scan.nextInt();
        int m = scan.nextInt();
        Integer[] array = new Integer[n];
        for (int i = 0; i < n; i++) {
            array[i] = i + 1;
        }
        Arrays.sort(array, (o1, o2) -> digitSum(o1) != digitSum(o2) ? digitSum(o1) - digitSum(o2) : o1 - o2);
        System.out.println(array[m - 1]);
        scan.close();
    }

    private static int digitSum(Integer num) {
        int ans = 0;
        while (num > 0) {
            ans += num % 10;
            num /= 10;
        }
        return ans;
    }
}

对于以下代码

 Arrays.sort(array, (o1, o2) -> digitSum(o1) != digitSum(o2) ? digitSum(o1) - digitSum(o2) : o1 - o2);

意思就是说，我们重写了比较器，如果 o1 不等于 o2，我们就按照其数位之和排序，如果相同，我们就按照数字从小到大的方式排序。