当前位置：首页 > article >正文

蓝桥杯——————数位排序（java）

article 2025/3/26 3:19:56

怎么说呢，实在是想不明白我这冒泡排序好像也没有问题呀，但是为甚么最后排序玩之后，会出现11在2 前面呢？

有点逆天，

package Lanqiao;

import java.util.Scanner;

/**
 * @author zb
 * date2025/3/21 10:24
 */
public class L2122 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n  = in.nextInt();
        int m = in.nextInt();
//        防止越界
        int a[] = new int[n+12];
        for (int i = 1; i <=n ; i++) {
            a[i] = i;
        }
//        冒泡排序
        for (int i = 1; i <n; i++) {
            for (int j = i+1; j <=n ; j++) {
                if(check(a[i],a[j])){
                    int temp = a[i];
                    a[i] =a[j] ;
                    a[j] =temp;

                }
            }
        }
        for (int i = 1; i <=n ; i++) {
            System.out.print(a[i]+" ");
        }
        System.out.println(a[m]);



        in.close();
    }
    static boolean  check(int x, int y){
        int sum1 = 0 ;
        int sum2 = 0 ;
//        计算两个数的各个位数的和
        while (x>0){
            sum1 += x%10;
            x = x /  10 ;
        }  while (y>0){
            sum2 += y%10;
            y = y /  10 ;
        }
//        如果前面那个哥哥位数的和比后面那个大，交换这两个元素
        if(sum1>sum2){
            return true;
        }else {
            return false;
        }

    }
}

看了半天解析；

总结一下就是使用Arrays。sort（）

这是核心代码部分o1和o2是数组中的两个任意的元素，然后题目要求

首先按照数位和从小到大排列，

如果数位和大小相等那么就比较两个数本身的大小，小的放前面

当 sumB - sumA > 0（即 sumA < sumB）时，o1 会被排在 o2 前面，无论它们是否相邻。

当 o1 - o2 < 0（即 o1 < o2）时，数位和相同的 o1 会排在前面。

按照数位和从小到da排序，数位和相同，就会比较o1o2的大小按照数字o1,o2从小到大排序（数字本身是不会相同的，除非o1,o2是同一个数字，当然这是不可能，因为比较器就是比较的是任意两个不同的数字o1,o2）

      Arrays.sort(a,(o1,o2)->{
            int sumA = digitsum(o1);
            int sumB = digitsum(o2);
            return (sumA!=sumB)?sumB-sumA:o1-o2;
        }

        );

这里也可以写成下面这种，这种可能更清晰一点

Arrays.sort(a, (o1, o2) -> {
    int sumA = digitsum(o1); // 计算o1的数位和
    int sumB = digitsum(o2); // 计算o2的数位和
    
    if (sumA != sumB) {
        return sumA - sumB; // 关键点：返回差值！
    }
    return o1 - o2; // 数位和相同时比较数值
});

我的理解就是这其实相当于高考的时候理科报志愿，如果两个人分数相同，先看数学谁考的高如果数学分数相同，再看物理多少分这种

看一下运行结果

如果改变sumA和sumB 的位置，比如改成下面这种

     Arrays.sort(a,(o1,o2)->{
            int sumA = digitsum(o1);
            int sumB = digitsum(o2);
            return (sumA!=sumB)?sumB-sumA:o1-o2;
        }

        );

就会按照数位和从大到小排序，数位和相同，按照数字从小到大排序

总结一下，就是

如果o1 o2的初始顺序和返回条件的顺序是相同的，那么就是升序排序，否则就是降序排序


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

/**
 * @author zb
 * date2025/3/21 10:24
 */
public class Main {

    public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    int n =in.nextInt();
    int m = in.nextInt();
        Integer a[] =new Integer[n];
//        初始化数组
         for (int i = 0; i <n ; i++) {
             a[i] = i+1;

        }
        Arrays.sort(a,(o1,o2)->{
            int sumA = digitsum(o1);
            int sumB = digitsum(o2);
            return (sumA!=sumB)?sumA-sumB:o1-o2;
        }

        );
//        for (int i = 0; i <n ; i++) {
//            System.out.print(a[i]+" ");
//        }
        System.out.println(a[m-1]);



    in.close();

    }
//    求数位和
    static int digitsum(int n){
        int sum = 0  ;
        while (n>0){
            sum = sum + n%10 ;
            n = n/10 ;
        }
        return sum;
    }
}
//class Mycomparator implements Comparator<Integer>{
//
//    @Override
//    public int compare(Integer o1, Integer o2) {
//        if(o1<o2){
//            return 1;
//        } else if (o1>o2){
//            return -1;
//        }
//        return 0;
//    }
//}