【题目】

病人登记看病，编写一个程序，将登记的病人按照以下原则排出看病的先后顺序：

老年人（年龄 >= 60岁）比非老年人优先看病。
老年人按年龄从大到小的顺序看病，年龄相同的按登记的先后顺序排序。
非老年人按登记的先后顺序看病。

【输入格式】

第1行，输入一个小于100的正整数，表示病人的个数；
后面按照病人登记的先后顺序，每行输入一个病人的信息，包括：一个长度小于10的字符串表示病人的ID（每个病人的ID各不相同，且只包含数字和字母），一个整数表示病人的年龄，中间用单个空格隔开。

【输出格式】

按排好的看病顺序输出病人的ID，每行一个。

【样例】

样例输入

5

021075 40

004003 15

010158 67

021033 75

102012 30

样例输出

021033

010158

021075

004003

102012

【思路】

1. 先把输入的数据，按照年龄分成两个 LinkedHashMap，一个是年龄大于等于 60岁的老年人，一个是非老年人；

2. 对老年人的 LinkedHashMap按照年龄大小进行从大到小排序；

3. 非老年人的 LinkedHashMap就按照登记顺序（即在数组中的顺序）输出就可以。

【注意】这里需要考虑到排序的稳定性问题

排序算法的稳定性是指当存在两个相等的元素时，排序后它们的相对位置是否保持不变。

具体来说，如果在排序前，有两个相等的元素 A 和 B，且 A 出现在 B 的前面，那么如果排序算法是稳定的，经过排序后，A 仍然应该出现在 B 的前面。

稳定性对于某些应用场景非常重要。例如，在按照 老年人的年龄 进行排序的情况下，如果有两个 年龄相同 的老人，他们的顺序可能会影响到他们的排名。如果排序算法是稳定的，相同年龄的老人的 相对顺序 将被保留，而这个相对顺序恰好就是 登记的先后顺序。

【注意】观察题目的输入

Main函数里面的public static String[] sort(String[] id, int[] age){ return id; }

这个函数的输入是 String[] id 和 int[] age的，也就是说题目已经帮我们把输入的

5

021075 40

004003 15

010158 67

021033 75

102012 30

转换成了分离的

021075

004003

010158

021033

102012

和

40

15

67

75

30

所以我们要建立一下 String[] id 和 int[] age 的映射关系，由于可能会存在老年人年龄相同的情况（Key值相同），所以不用二叉搜索树，而是用 Hashmap 。

【排序算法】

基本的冒泡算法就可以

【踩坑】

在这里插入图片描述
所以要用 Map<String,Integer> map = new LinkedHashMap<>();

另外，由于年龄可能存在相同的情况，所以如果把 age 作为 Map 的 Key 值，会存在相同 Key 值的被覆盖的问题，比如说有 011111 44, 022222 44 ，后面的022222 44 就会把前面的覆盖掉，因为 Key 值只可能是唯一对应的。

【代码】

import java.util.*;

public class test {
    public static String[] coupons(String[] id, int[] age) {
//     错误写法：   HashMap<Integer, String> map = new HashMap<>();

// 建立一个有序的LinkedHashMap存放所有数据
        Map<String,Integer> map = new LinkedHashMap<>();
        for (int i = 0; i < age.length; i++) {
            map.put(id[i],age[i]);
        }
        System.out.println(map);

// 把数据分成 老年人 map 和 非老年人 map
        Map<String,Integer> oldMap = new LinkedHashMap<>();
        Map<String,Integer> youngMap = new LinkedHashMap<>();
        for (String key : map.keySet()) {
            int value = map.get(key);
            if (value >= 60) {
                oldMap.put(key, value);
            } else {
                youngMap.put(key, value);
            }
        }
        
// 用List把他们包裹起来
        List<Map.Entry<String,Integer>> sortedOldList = new ArrayList<>(oldMap.entrySet());
        List<Map.Entry<String,Integer>> youngList = new ArrayList<>(youngMap.entrySet());
        System.out.println(youngList);
        
 // 对老年人进行按照年龄大小的冒泡排序
        for (int i = 0; i < sortedOldList.size(); i++) {
            for (int j = 0; j < sortedOldList.size() - 1 - i; j++) {
                if (sortedOldList.get(j).getValue() < sortedOldList.get(j + 1).getValue()) {
                    Collections.swap(sortedOldList, j, j + 1);
                }
            }
        }

// 输出
        for (int i = 0; i < sortedOldList.size(); i++) {
            id[i] = sortedOldList.get(i).getKey();
        }
        for (int i = sortedOldList.size(); i < (sortedOldList.size() + youngList.size()); i++) {
            id[i] = youngList.get(i - sortedOldList.size()).getKey();
        }
        return id;
    }

    // APPEND BEGIN
    public static void main(String[] args){
        Scanner reader = new Scanner(System.in);
        int n = reader.nextInt();
        String[] id = new String[n];
        int[] age = new int[n];
        int i = 0;
        while (reader.hasNext()){
            id[i] = reader.next();
            age[i++] = reader.nextInt();
            if (i == age.length) break;
        }
        String[] result = coupons(id,age);
        for (String re : result){
            System.out.println(re);
        }
    }
}