成绩排序

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);
    }
}

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {

    static class Item {
        public String name;
        public Integer score;
        public Integer index;
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt(), s = in.nextInt();
        List<Item> list = new ArrayList();
        int c = 0;
        while (n -- > 0) {
            Item item = new Item();
            item.index = ++ c;
            item.name = in.next();
            item.score = in.nextInt();
            list.add(item);
        }
        Collections.sort(list, (r1, r2) -> {
            if (r1.score == r2.score) return r1.index.compareTo(r2.index);
            return s == 1 ? r1.score.compareTo(r2.score) : r2.score.compareTo(r1.score);
        });
        list.forEach(item -> System.out.println(item.name + " " + item.score));
    }
}

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int count = in.nextInt();
        int asc = in.nextInt();
        in.nextLine();
        String[] names = new String[count];
        int[] scores = new int[count];
        int[] ordered = new int[count];
        for(int i=0;i<count;i++){
            String[] arr = in.nextLine().split("\\s+");
            names[i] = arr[0];
            scores[i] = Integer.parseInt(arr[1]);
            ordered[i] = i;
        }

        for(int i=0;i<count;i++){
            for(int j=i+1;j<count;j++){
                if((scores[i] == scores[j] && ordered[i] > ordered[j])
                    || (asc == 0 && scores[i] < scores[j])
                    || (asc == 1 && scores[i] > scores[j])
                ){
                    scores[i]  = scores[i]+scores[j]-(scores[j]=scores[i]);
                    ordered[i]  = ordered[i]+ordered[j]-(ordered[j]=ordered[i]);
                }
            }
        }

        for(int i=0;i<count;i++){
            System.out.println(names[ordered[i]]+" "+scores[i]);
        }
    }
}

import java.util.*; 
import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in); 
        int n = scanner.nextInt(); // 读取人数  
        int order = scanner.nextInt(); // 读取排序方式，0代表从高到低，1代表从低到高   
        // 使用HashMap存储学生信息，确保相同成绩时，先录入的排在前面  
        List<Map<String, Object>> students = new ArrayList<>(); 
        for (int i = 0; i < n; i++) {  
            Map<String, Object> map = new HashMap<>();
            String name = scanner.next(); 
            int score = scanner.nextInt();
            map.put("score",score);
            map.put("name",name);
            students.add(map); 
    }   
    // 使用TreeMap根据成绩排序  
    Map<Integer, List<String>> sortedStudents = new TreeMap<Integer, List<String>>(order == 0 ? Comparator.reverseOrder() : Comparator.naturalOrder());
        for (Map<String, Object> student : students) {  
            sortedStudents.computeIfAbsent(Integer.parseInt(student.get("score").toString()),
                k -> new ArrayList<>()).add(student.get("name").toString()); 
        }   
        // 输出结果  
        for (Map.Entry<Integer, List<String>> entry : sortedStudents.entrySet()) {  
            int score = entry.getKey();
            List<String> names = entry.getValue(); 
            for (int i = 0; i < names.size(); i++) {  
                System.out.println(names.get(i) + " " + score); 
            }  }  scanner.close(); 
    }