歸併排序理解（java實現）

1、歸併排序

public class MergeSort {
    public static void main(String[] args) {
        Random random = new Random();
        Entity[] entities = new Entity[30000000];
        for (int i = 0;i < 30000000;++i){
            Entity entity = new Entity(random.nextInt(30000000));
            entities[i] = entity;
        }
        long start = System.currentTimeMillis();
        MergeSort(entities,0,entities.length - 1);
        long end = System.currentTimeMillis();
        System.out.println((end - start) / 1000);
        assert SortUtil.isSorted(entities);
    }

    private static void merge(Entity[] entities,int lo,int mid,int ho){

        Entity[] left = new Entity[mid - lo + 1];
        Entity[] rigth = new Entity[ho - mid];
        System.arraycopy(entities,lo,left,0,mid - lo + 1);
        System.arraycopy(entities,mid + 1,rigth,0,ho - mid);
        int i = 0;
        int j = 0;
        while (i < left.length && j < rigth.length){
            Entity entity = left[i];
            Entity entity1 = rigth[j];
            if (entity.compareTo(entity1) < 0) {
                i++;
                entities[lo] = entity;
            }else if (entity.compareTo(entity1) == 0){
                i++;
                j++;
                entities[lo] = entity;
                entities[++lo] = entity1;
            }else {
                j++;
                entities[lo]=entity1;
            }
            lo++;
        }
        while (j < rigth.length){
            entities[lo++] =  rigth[j];
            j++;
        }

        while (i < left.length){
            entities[lo++]=left[i];
            i++;
        }
    }
    public static void MergeSort(Entity[] entities,int lo,int ho){
        if (entities == null || entities.length== 0){
            return;
        }
        if (ho <= lo){
            return;
        }
        int mid = lo + (ho - lo) / 2;
        MergeSort(entities,lo , mid);
        MergeSort(entities,mid + 1,ho);
        merge(entities,lo ,mid, ho);
    }
}

public class SortUtil {
    public static boolean isSorted(List<Entity> arr) {
        for (int i = 1; i < arr.size(); i++)
            if (less(arr.get(i), arr.get(i-1))) return false;
        return true;
    }
    public static boolean isSorted(Entity[] arr) {
        for (int i = 1; i < arr.length; i++)
            if (less(arr[i], arr[i-1])) return false;
        return true;
    }
    // is v < w ?
    private static boolean less(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }
}

2、代碼理解