利用Comparable接口实现对Student归并排序

基本思想：将待排序元素分成大小大致相同的2个子集合，分别对2个子集合进行排序，最终将排好序的子集合合并成为所要求的排好序的集合。（分治思想）

public class Student implements Comparable {
    private int id;
    private String name;

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

    @Override
    public int compareTo(Object o) {
       if(o instanceof Student){
           Student s = (Student) o;
           if(this.id > s.id) return 1;
           if(this.id < s.id) return -1;
           return 0;
       }
       throw new RuntimeException("类型不匹配无法不比较大小");
    }
}

import java.util.List;

public class 归并排序 {
    public static void sort(List list){
        int l = 0;
        int r = list.size() - 1;
        devide(list,l,r);
    }

    /**
     * 将list分开为左右两个子表
     * @param list
     * @param l
     * @param r
     */
    private static void devide(List list, int l, int r) {
        int mid = (l + r)/2;
        if(l < r){
            devide(list,l,mid);
            devide(list,mid + 1,r);
            //分完之后再左右两子表归并归并
            merge(list,l,mid,mid + 1,r);
        }
    }

    /**
     * 并
     * @param list
     * @param l
     * @param mid
     * @param i
     * @param r
     */
    private static void merge(List list, int l, int mid, int i, int r) {
        Object[] temp = new Object[list.size()];
        int index = l;
        int ls = l,le = mid;//左边数组起始索引
        int rs = i,re = r;//右边数组起始索引
        while(ls <= le && rs <= re){
            Comparable o1 = (Comparable) list.get(ls);
            Comparable o2 = (Comparable) list.get(rs);
            if(o1.compareTo(o2) == -1){
                temp[index] = o1;
                ls++;
            }else {
                temp[index] = o2;
                rs++;
            }
            index++;
        }
        //判断左边元素是否有剩余
        if(ls <= le){
            for(int j = ls;j <= le;j++){
                temp[index++] = list.get(j);
            }
        }
        //判断右边元素是否有剩余
        if(rs <= re){
            for(int j = rs;j <= re;j++){
                temp[index++] = list.get(j);
            }
        }
        //将排好的元素放回原数组
        for(int j = l;j <= r;j++){
            list.set(j,temp[j]);
        }
    }
}

测试：

public class TestSort {
    public static void main(String[] args) {
        List s = new ArrayList();
        s.add(new Student(23,"陈"));
        s.add(new Student(13,"王"));
        s.add(new Student(22,"孙"));
        s.add(new Student(18,"李"));
        归并排序.sort(s);
        Iterator iter = s.iterator();
        while(iter.hasNext()){
            System.out.println(iter.next());
        }
    }
}

输出：