归并排序处理复杂对象例子

对象TmpObject 包含了一个 int类型的变量，有一个List<TmpObject> 数组，如何根据这个int变量，进行归并排序？

import java.util.ArrayList;
import java.util.List;

/**
 * 归并排序（递归）
 */
public class Merge {
    public static void main(String[] args) {
        List<TmpObject> list = new ArrayList<>();
        list.add(new TmpObject(6));
        list.add(new TmpObject(5));
        list.add(new TmpObject(3));
        list.add(new TmpObject(8));
        list.add(new TmpObject(1));
        list.add(new TmpObject(7));
        list.add(new TmpObject(2));
        list.add(new TmpObject(9));
        list.add(new TmpObject(5));

        System.out.println("归并前输出：");
        for (TmpObject tmp : list) {
            System.out.print(tmp.getNum() +" ");
        }

        segment(list, 0, list.size() - 1);

        System.out.println("
归并后输出：");
        for (TmpObject tmp : list) {
            System.out.print(tmp.getNum() +" ");
        }
    }

    /**
     * 递归切分待排
     *
     * @param list  待切分数组
     * @param left  待切分最后第一个元素的索引
     * @param right 待切分数组最后一个元素的索引
     */
    private static void segment(List<TmpObject> list, int left, int right) {
        if (left < right) {
            // 找出中间索引
            int center = (left + right) / 2;
            // 对左边数组进行递归
            segment(list, left, center);
            // 对右边数组进行递归
            segment(list, center + 1, right);
            // 合并
            merge(list, left, center, right);
        }
    }

    /**
     * 两两归并排好序的数组（2路归并）
     *
     * @param list   带排序数组对象
     * @param left   左边数组的第一个索引
     * @param center 左数组的最后一个索引，center + 1右数组的第一个索引
     * @param right  右数组的最后一个索引
     */
    private static void merge(List<TmpObject> list, int left, int center, int right) {
        List<TmpObject> tmpArray = new ArrayList<TmpObject>(right - left + 1);
        int leftIndex = left;   //左数组第一个元素的索引
        int rightIndex = center + 1;   //右数组第一个元素索引

        // 把较小的数先移到新数组中
        while (leftIndex <= center && rightIndex <= right) {
            if (list.get(leftIndex).getNum() <= list.get(rightIndex).getNum()) {
                tmpArray.add(list.get(leftIndex++));
            } else {
                tmpArray.add(list.get(rightIndex++));
            }
        }

        //把左边剩余的数移入数组
        while (leftIndex <= center) {
            tmpArray.add(list.get(leftIndex++));
        }

        // 把右边边剩余的数移入数组
        while (rightIndex <= right) {
            tmpArray.add(list.get(rightIndex++));
        }

        // 把新数组中的数覆盖nums数组
        for (int i = 0; i < tmpArray.size(); i++) {
            list.set(left + i, tmpArray.get(i));
        }
    }
}

class TmpObject {
    private int num;

    TmpObject(int num) {
        this.num = num;
    }

    int getNum() {
        return num;
    }

    void setNum(int num) {
        this.num = num;
    }
}

 输出结果为：

归并前输出：
6 5 3 8 1 7 2 9 5
归并后输出：
1 2 3 5 5 6 7 8 9

可以使用Comparator 比较器来直接比较list，而且它的排序方法是TimSort 算法：

//java8 中自定义Comparator 可以使用lambda 表达式
private static void sortList(List<TmpObject> list) {
    Comparator comp = (o1, o2) -> {
        TmpObject tmpFirst = (TmpObject) o1;
        TmpObject tmpSecond = (TmpObject) o2;
        return tmpFirst.getNum() - tmpSecond.getNum();
    };
    list.sort(comp);
}