ArrayList上的MergeSort仅与ArrayList（Collection <? extends E> c）不是ArrayList（int initialCapacity）吗？

Question

I am working on sort interval which exist on an ArrayList with its start property, the full definition of interval will show in sample code as private class.

The implementation I am using is MergeSort , and very similar to Princeton's stuff which I refer to, but problem is I find this implementation only work with creating auxiliary ArrayList aux with ArrayList(Collection<? extends E> c) and initialize it with aux.set(i, intervals.get(i)); which try to fill aux with same order of interval items from original list

I try to work it out with creating aux with ArrayList(int initialCapacity) and initialize it with aux.add(intervals.get(i)) , but failed. And I still could not figure out why this way doesn't work ?

The full code which can directly used for debug:

public class Test {
    private class Interval {
        // Will use start property to sort
        int start;
        int end;
        Interval() { 
            start = 0; 
            end = 0; 
        }
        Interval(int s, int e) { 
            start = s; 
            end = e; 
        }
        @Override
        public String toString() {
            return "[" + start + "," + end + "]";
        }
    }

    public void sortHelper(List<Interval> intervals) {
        int len = intervals.size();
        // Only this way works
        List<Interval> aux = new ArrayList<Interval>(intervals);
        // This way NOT work ?
        //List<Interval> aux = new ArrayList<Interval>(len);
        sort(intervals, aux, 0, len - 1);
    }

    public void sort(List<Interval> intervals, List<Interval> aux, int lo, int hi) {
        if(hi <= lo) {
            return;
        }
        int mid = lo + (hi - lo) / 2;
        sort(intervals, aux, lo, mid);
        sort(intervals, aux, mid + 1, hi);
        mergeHelper(intervals, aux, lo, mid, hi);
    }

    public void mergeHelper(List<Interval> intervals, List<Interval> aux, int lo, int mid, int hi) {
        // Only this way works
        for(int i = lo; i <= hi; i++) {
            aux.set(i, intervals.get(i));
        }
        // Combine with List<Interval> aux = new ArrayList<Interval>(len);
        // this way NOT work ?
        //for(int i = lo; i <= hi; i++) {
        //    aux.add(intervals.get(i));
        //}
        int left = lo;
        int right = mid + 1;
        for(int k = lo; k <= hi; k++) {
            if(left > mid) {
                intervals.set(k, aux.get(right++));
            } else if(right > hi) {
                intervals.set(k, aux.get(left++));
            } else if(less(aux.get(right), aux.get(left))) {
                intervals.set(k, aux.get(right++));
            } else {
                intervals.set(k, aux.get(left++));
            }
        }
    }

    public boolean less(Interval a, Interval b) {
        return a.start - b.start < 0;
    }

    public static void main(String[] args) {
        Test m = new Test();
        Interval one = m.new Interval(1, 3);
        Interval two = m.new Interval(2, 6);
        Interval three = m.new Interval(8, 10);
        Interval four = m.new Interval(15, 18);
        List<Interval> intervals = new ArrayList<Interval>();
        // Adding order as [2,6],[1,3],[8,10],[15,18]
        intervals.add(two);
        intervals.add(one);
        intervals.add(three);
        intervals.add(four);
        m.sortHelper(intervals);
        // Expected sort result should be
        // [1,3],[2,6],[8,10],[15,18]
        for(Interval i : intervals) {
            System.out.println(i);
        }
    }    
}

Could anyone help me on understanding why must create auxiliary ArrayList aux with ArrayList<Collection<? extends E> c> ArrayList<Collection<? extends E> c> and initialize it with aux.set(i, intervals.get(i)); ? Or my understanding goes the wrong way ? Thanks

Answer 1

Thanks for important hint from @maraca and @Dukeling, after some work, below is my opinion for the issue here:

Q1 : Why using List<Interval> aux = new ArrayList<Interval>(len); with aux.add(intervals.get(i)); not work ?

A1 : There are two main issues here, I should admit I fail into some habitual thoughts as previous work with array implementation of MergeSort , the impact here are (1) new ArrayList<Interval>(len) equal to new Interval[len] or not ? (2) aux[i] = intervals[i] (just for explain, not use = in real code) equal to aux.add(intervals.get(i)) ?

For problem (1), the real case here is using new ArrayList<Interval>(len) will only define the initial limitation of ArrayList size, but no real items used like space holder to fill into the initialized list, eg If we set len = 4 , the initialized list is actually [] , not [interval obj, interval obj, interval obj, interval obj] . Assume using new ArrayList<Interval>(len) with aux.set(i, intervals.get(i)) , IDE will throw out java.lang.IndexOutOfBoundsException: Index: 0, Size: 0 , that's because no real object fill into this list as initialized and set method cannot work on an empty list. The solution for this issue is create len numbers of dummy interval objects to fill in list when initialized, such as List<Interval> aux = new ArrayList<Interval>((Arrays.asList(new Interval(), new Interval(), new Interval(), new Interval()))); , but since we don't care what initialized first on auxiliary list, just used as place holder and in case of the objects are too many, above code can be replaced with List<Interval> aux = new ArrayList<Interval>(intervals); which return to our right solution.

For problem (2), the real case here is using aux.add(intervals.get(i)) not equal to aux[i] = intervals[i] , at least we should use set() instead of add() , because add() will continually append on aux , which not MergeSort suppose to, because MergeSort require exactly same size auxiliary collection copy to help sorting. Still use same example to explain what happened when using add()

Note after the 3rd merge, the aux size increase to double size of original list, this will cause indices issue when copy back to original list. But if we are using set() will not cause this trouble.

Q2 : If still want to use add() what is the proper way ?

A2 : As mentioned by @Dukeling, we need to clear() the aux before final round copy from original list to auxiliary list, eg like before the 3rd merge happen on above example.

The working code with add() and clear() below:

public void mergeHelper(List<Interval> intervals, List<Interval> aux, int lo, int mid, int hi) {
    aux.clear();
    for(int i = 0; i < lo; i++) {
        aux.add(null);
    }
    for(int i = lo; i <= hi; i++) {
        aux.add(intervals.get(i));
    }
    int left = lo;
    int right = mid + 1;
    for(int k = lo; k <= hi; k++) {
        if(left > mid) {
            intervals.set(k, aux.get(right++));
        } else if(right > hi) {
            intervals.set(k, aux.get(left++));
        } else if(less(aux.get(right), aux.get(left))) {
            intervals.set(k, aux.get(right++));
        } else {
            intervals.set(k, aux.get(left++));
        }
    }
}