成绩排序

一、容易想到的方法，封装对象。

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        int total = in.nextInt();
        int order = in.nextInt();
        List<Stu> list = new ArrayList<>();
        for (int i = 0; i < total; i++) {
            String name = in.next();
            int score = in.nextInt();
            Stu stu = new Stu(name, score);
            list.add(stu);
        }

        if (order == 0) {
            // 0 降序
            Collections.sort(list, Comparator.reverseOrder());
        } else if (order == 1) {
            // 1 升序
            Collections.sort(list);
        }

        list.forEach(stu -> System.out.println(stu.getName() + " " + stu.getScore()));

    }

    private static class Stu implements Comparable<Stu> {
        private String name;
        private int score;

        Stu(String name, int score) {
            this.name = name;
            this.score = score;
        }

        int getScore() {
            return this.score;
        }

        String getName() {
            return this.name;
        }

        public int compareTo(Stu o) {
            if (o == null) {
                return 1;
            }
            return this.getScore() - o.getScore();
        }
    }
}

二、其实List嵌套List也可以被排序

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        int total = in.nextInt();
        int order = in.nextInt();
        List<List> list = new ArrayList<>();

        for (int i = 0; i < total; i++) {
            String name = in.next();
            int score = in.nextInt();
            List l = new ArrayList<>();
            l.add(name);
            l.add(score);
            list.add(l);
        }

        if (order == 0) {
            // 0 降序
            Collections.sort(list, (o1, o2) -> (int) o2.get(1) - (int) o1.get(1));
        } else if (order == 1) {
            // 1 升序
            Collections.sort(list, (o1, o2) -> (int) o1.get(1) - (int) o2.get(1));
        }

        list.forEach(l -> System.out.println(l.get(0) + " " + l.get(1)));
    }
}

1 最初，使用HashMap存(名字,成绩)，按成绩排序
2 但成绩相同时，名字无法按录入顺序排序
3 想到用List存储、排序，但List存不了(名字,成绩)两个值
4 百度一下，可自建一个类KV，包装下(名字,成绩)存入List   
【有点面向对象的味道了】

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int op = in.nextInt();
        List<KV> list = new ArrayList<>();
        while (n-- > 0) {
            list.add(new KV(in.next(),in.nextInt())); // 存入list
        }
        list.sort((o1,o2)->{ return op == 1 ? o1.getValue().compareTo(o2.getValue()) : o2.getValue().compareTo(o1.getValue());});  // 排序
        list.forEach(e-> {System.out.println(e.getKey() + " " + e.getValue());}); // 打印
    }

}
// 包装(名字,成绩)
class KV {
    private String key;
    private Integer value;
    public KV(String key, Integer value) {
        this.key = key;
        this.value = value;
    }
    public String getKey() {
        return this.key;
    }
    public Integer getValue() {
        return this.value;
    }
}

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        // 读取学生人数
        int n = in.nextInt();

        // 读取排序方式
        int sortType = in.nextInt();

        // 创建学生数组
        String[] names = new String[n];
        int[] scores = new int[n];

        // 读取学生信息
        for (int i = 0; i < n; i++) {
            names[i] = in.next();
            scores[i] = in.nextInt();
        }

        // 两层循环实现冒泡排序
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - 1 - i; j++) {
                if ((sortType == 0 && scores[j] < scores[j + 1]) || (sortType == 1 && scores[j] > scores[j + 1])) {
                    // 交换成绩
                    int tempScore = scores[j];
                    scores[j] = scores[j + 1];
                    scores[j + 1] = tempScore;
                    // 交换名字
                    String tempName = names[j];
                    names[j] = names[j + 1];
                    names[j + 1] = tempName;
                }
            }
        }
        // 输出排序后的学生信息
        for (int i = 0; i < n; i++) {
            System.out.println(names[i] + " " + scores[i]);
        }

        in.close();
    }
}

// 算法复杂度O（nlogn）空间复杂度o（n）;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        int flag = Integer.parseInt(br.readLine());

        Map<Integer, List<String>> map = new HashMap<>();

        String str;
        while ((str = br.readLine()) != null && !str.isEmpty()) {
            String[] strs = str.split(" ");
            int key = Integer.parseInt(strs[1]);
            List<String> names = map.getOrDefault(key, new ArrayList<>());
            names.add(strs[0]);
            map.put(key, names);
        }

        int[] nums = new int[map.size()];
        int index = 0;

        for (int key : map.keySet()) {
            nums[index++] = key;
        }

        Arrays.sort(nums);

        if (flag == 1) {  // 升序输出
            for (int i : nums) {
                for (String name : map.get(i)) {
                    System.out.println(name + " " + i);
                }
            }
        } else {
            for (int i = nums.length - 1; i >= 0; i--) {
                int key = nums[i];
                for (String name : map.get(key)) {
                    System.out.println(name + " " + key);
                }
            }
        }
    }
}

思路：利用桶排序

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int sum = in.nextInt();
        int sort = in.nextInt();
        //数组的角标即为成绩，利用桶排序
        Student[] stu = new Student[101];
        for (int i = 0; i < sum; i++) {
            String name = in.next();
            int score = in.nextInt();
            //每个类记录相同分数的所有名字
            if (stu[score] == null) {
                stu[score] = new Student(name);
            } else {
                stu[score].addName(name);
            }
        }
        //从小到大，正序输出student数组
        if (sort == 1) {
            for (int i = 0; i <= 100; i++) {
                if (stu[i] != null) {
                    //遍历每个类内部所有的名字
                    for (int j = 0; j < stu[i].point; j++) {
                        System.out.println(stu[i].name[j] + " " + i);
                    }
                }
            }
        //从大到小，倒序输出
        } else {
            for (int i = 100; i >= 0; i--) {
                if (stu[i] != null) {
                    for (int j = 0; j < stu[i].point; j++) {
                        System.out.println(stu[i].name[j] + " " + i);
                    }
                }
            }
        }

    }
}
//对每个分数建立名字列表，以保证相同成绩时，保持输入的顺序
class Student {
    String[] name = new String[200];
    //每个类内部维护记录名字的数组
    int point = 0;
    public Student(String name) {
        this.name[point++] = name;
    }
    public void addName(String name) {
        this.name[point++] = name;
    }
}

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

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = Integer.parseInt(in.nextLine());
        Student.sortMethod = Integer.parseInt(in.nextLine());
        Student[] students = new Student[n];
        for (int i = 0; i < n; i++) {
            String[] s = in.nextLine().split(" ");
            students[i] = new Student(i, s[0], Integer.parseInt(s[1]));
        }
        Arrays.sort(students);
        for (Student student : students) {
            System.out.println(student.name + " " + student.score);
        }
    }
}

class Student implements Comparable<Student> {
    int i;
    String name;
    int score;
    public static int sortMethod;

    public Student(int i, String name, int score) {
        this.i = i;
        this.name = name;
        this.score = score;
    }

    @Override
    public int compareTo(Student o) {
        int s = Integer.compare(this.score, o.score);
        if (sortMethod == 0) {
            s = -s;
        }
        if (s != 0) {
            return s;
        }
        return Integer.compare(this.i, o.i);
    }
}