shenshengzhiwen
2019-12-09 10:44
采纳率: 0%
浏览 294

请教一个java排序算法

假如有一个对象有两个属性:name姓名,age年龄,现在有一组数据
按姓名排好序,如下:
name:aaa, age:19
name:aaa, age:20
name:aaa, age:21
name:aaa, age:22
name:aaa, age:23
name:aaa, age:24
name:aaa, age:25
name:bbb, age:21
name:bbb, age:22
name:bbb, age:23
name:bbb, age:24
name:bbb, age:25
name:bbb, age:26
现在我数据一个年龄:23
那么获得的新的排序如下:
name:aaa, age:23
name:aaa, age:22
name:aaa, age:24
name:aaa, age:21
name:aaa, age:25
name:aaa, age:20
name:aaa, age:19
name:bbb, age:23
name:bbb, age:22
name:bbb, age:24
name:bbb, age:21
name:bbb, age:25
请教大神们如果用java怎么实现这个算法?
是一大一小轮流排序的,不是直接从大到小,或者从小到大排序

  • 写回答
  • 关注问题
  • 收藏
  • 邀请回答

5条回答 默认 最新

  • 502203305 2019-12-09 11:05
    int len = array.length();
    for ( int i = 0 ; i < len ; i++ )
    {
        for(int j = i ; j < len ; j++)
        {
            if ( array[i].name < array[j].name || (array[i].name == array[j].name && array[i].age < array[j].age) )
            {
                swap(array[i],array[j]);
            }
        }
    }
    
    

    伪代码

    打赏 评论
  • VICTOR_fusheng 2019-12-09 11:38

    ?你的数据是不是反了,如果你要规范排序的话应该是先按姓名排序相同的按年龄排序,可以了解一下Comparable接口

    按姓名分成Map<\String,\List>,list根据年龄排序后,从中间取,+1,-1循环取出来放到一个新的集合,

         public static void main(String[] args) throws CloneNotSupportedException {
            Student s1 = Student.of("aaa",20);
            Student s2 = Student.of("aaa",23);
            Student s3 = Student.of("aaa",21);
            Student s4 = Student.of("aaa", 24);
            Student s5 = Student.of("bbb",22);
            Student s6 = Student.of("bbb",23);
            Student s7 = Student.of("bbb",21);
            Student s8 = Student.of("bbb", 24);
            Student s9= Student.of("bbb",25);
            List<Student> list = new ArrayList<>();
            list.add(s1);
            list.add(s2);
            list.add(s3);
            list.add(s4);
            list.add(s5);
            list.add(s6);
            list.add(s7);
            list.add(s8);
            list.add(s9);
            list.sort((o1, o2) -> {
                int c1 = o1.getName().compareTo(o2.getName());
                if (c1 != 0){
                    return c1;
                }
                return o1.getAge()-o2.getAge();
            });
            //第一次按姓名+年龄排序的结果
            System.out.println(JSON.toJSONString(list));
            Scanner scanner = new Scanner(System.in);
            int age = scanner.nextInt();
            Map<String,List<Student>> map = list.stream().collect(Collectors.groupingBy(Student::getName));
            //转成treemap按名字排序
            TreeMap<String, List<Student>> treeMap = new TreeMap<>();
            for (Map.Entry<String, List<Student>> entry : map.entrySet()) {
                String key = entry.getKey();
                List<Student> value = entry.getValue();
                List<Student> newList = new ArrayList<>();
                value.sort(Comparator.comparing(Student::getAge));
                int size = value.size();
                int targetIndex = halfSearch(age, value,0, size);
                //targetIndex=-1这边要结束,报错
                newList.add(value.get(targetIndex));
                //得到要遍历的次数
                int interval = Math.max(targetIndex,size-1-targetIndex)+1;
                for (int i = 1; i < interval; i++) {
                    int min = targetIndex - i;
                    int max = targetIndex + i;
                    if (min >= 0){
                        newList.add(value.get(min));
                    }
                    if (max<size){
                        newList.add(value.get(max));
                    }
                }
                treeMap.put(key, newList);
            }
            List<Student> finalList = new ArrayList<>();
            for (List<Student> students : treeMap.values()) {
                finalList.addAll(students);
            }
    
            System.out.println(JSON.toJSONString(finalList));
        }
    
        /**
         * 查询满足输入的年龄的同学的位置下标
         * @param age
         * @param list
         * @return
         */
        private static int halfSearch(int age, List<Student> list, int left, int right){
            if (left > right){
                //-1表示没找到,如果想正常运行,可以根据需求返回left或者right
                return -1;
            }
            int mid = left + (right - left) / 2;
            int midAge = list.get(mid).getAge();
            if (midAge > age){
                return halfSearch(age,list,left, mid-1);
            }
            if (midAge < age){
                return halfSearch(age,list, mid + 1, right);
            }
            return mid;
        }
    
    打赏 评论
  • dsxjinzhiqiang 2019-12-09 11:39
          //list 就是数据集合   DatasBean就是你的类
            Collections.sort(list, new Comparator<DatasBean>() {
                @Override
                public int compareDatasBean datasBean, DatasBean t1) {
    
                    return datasBean.getName().compareTo(t1.getName());
                }
            });
            Collections.sort(list, new Comparator<DatasBean>() {
                @Override
                public int compare(DatasBean datasBean,DatasBean t1) {
    
                    return datasBean.getAge()-datasBean.getAge();
                }
            });
                    //最后得到的结果就是先用名称排序,再用年龄排序
    
    打赏 评论
  • 一切顺势而行 2019-12-09 11:45

    @Data
    @AllArgsConstructor
    public class Student implements Comparator {

    private  String name;
    
    private  Integer age;
    
    @Override
    public int compare(Student o1, Student o2) {
        if(0==o1.name.compareTo(o2.name)){
            if(o1.age==o2.age){
                return 0;
            }else if (o1.age>o2.age){
                return 1;
            }else {
                return -1;
            }
        }
        return o1.name.compareTo(o2.name);
    }
    
    public static void main(String[] args) {
        List<Student> sList = new ArrayList<>();
        Student s1 = new Student("aaa",19);
        Student s2 = new Student("aaa",25);
        Student s3 = new Student("bbb",24);
        Student s4 = new Student("bbb",21);
        Student s5 = new Student("ccc",19);
        Student s6 = new Student("ccc",23);
        Student s11 = new Student("ccc",25);
        Student s7 = new Student("ccc",12);
        Student s8 = new Student("ddd",21);
        Student s9 = new Student("ddd",25);
        Student s10 = new Student("ddd",29);
        sList.add(s1);
        sList.add(s2);
        sList.add(s3);
        sList.add(s4);
        sList.add(s5);
        sList.add(s6);
        sList.add(s7);
        sList.add(s8);
        sList.add(s9);
        sList.add(s10);
        sList.add(s11);
        sList.sort((Student o1, Student o2)-> {
            if(0==o1.name.compareTo(o2.name)){
                if(o1.age==o2.age){
                    return 0;
                }else if (o1.age>o2.age){
                    return 1;
                }else {
                    return -1;
                }
            }
            return o1.name.compareTo(o2.name);
        });
        Scanner scanner = new Scanner(System.in);
        int age = scanner.nextInt();
        Map<String,List<Student>> resultMap = sList.stream().collect(Collectors.groupingBy(Student::getName));
        Set<String> keySet = resultMap.keySet();
        List<Student> s = new ArrayList<>();
        for (String key:keySet){
            List<Student> list  = resultMap.get(key);
            Map<Integer,List<Student>> map = list.stream().collect(Collectors.groupingBy(Student::getAge));
            if(map.get(age)!=null){
                s.addAll(map.get(age));
                list = list.stream().filter(stu->age!=stu.getAge()).collect(Collectors.toList());
                s.addAll(list);
            }else {
               s.addAll(list);
            }
        }
        s.sort((Student o1, Student o2)-> {
            return o1.name.compareTo(o2.name);
        });
        s.stream().forEach(stu->System.out.println(stu));
      }
    

    }

    打赏 评论
  • JonathanYan 2019-12-09 12:42

    比较规则改为如下就行

    bool isLesser(T a, T b, age c){
        int da = a.age >= c ? a.age : c + ( c - a.age ) - 0.5;
        int db = b.age >= c ? b.age : c + ( c - b.age ) - 0.5;
    
        if(a.name != b.name)
            return a.name < b.name;
        return da <= db;
    }
    //23 22   24 21   25   20   19
    //对应
    //23 23.5 24 24.5 25.5 26.5 27.5
    //这样再按正常的方法排序就行了
    

    对应的情况是a排在b前面

    打赏 评论

相关推荐 更多相似问题