Merge Sort

public class MergeSort {

    public static void sortIntegers(int[] array) {
        // write your code here
        if (array == null || array.length ==0 ) {
            return ;
        }
        //!!!write outside could save some space than writing inside the merge function
        int[] helper = new int[array.length] ;
        mergeSort(array, helper, 0, array.length-1) ;
    }

    private static void mergeSort(int[] array, int[] helper, int left, int right) {
        //exist recursion
        if (left>=right) {
            return;
        }
        int mid = left + (right-left)/2 ;
        /*
        * 注意这里不用的原因 [0,1] start = 0 mid = 0(1/2 in java = 0) end = 1
        * mergeSort(A, helper, start, mid-1 )  (0,-1) will exit in the mergeSort so its ok
        * mergeSort(A, helper, mid, end, ),  (0,1) will become the same as the input, input size not decrease, so timeout!
        * */
        mergeSort(array, helper, left, mid );
        mergeSort(array, helper,mid +1, right);
        merge(array, helper, left, mid, right);
    }
    //merge //这两边往中间夹的算法，都要考虑一边先结
    private static void merge(int[] array,int[] helper, int left, int mid, int right) {
        /*note
        1) here both the left and right are index! so use <= right
        2) when it comes to merge, left part and right part already sorted in the array!
        [ 1,3,5 ; 6,7,9]
        * */
        //copy [1,3,5 ; 6,7,9] from array to helper to save ori. value, so later we could use original val. from it to overwrite array
        for (int i = left; i <= right; i++) {
            helper[i] = array[i] ;
        }
        // use left as the pointer for array, use leftIndex and rightIndex as two pointers for helper array
        int leftIndex = left ;
        int rightIndex = mid + 1 ;
        while (leftIndex <=mid && rightIndex <= right){
            if (helper[leftIndex] <= helper[rightIndex]){
                array[left++] = helper[leftIndex++] ;
            } else{
                array[left++] = helper[rightIndex++] ;
            }
        }
        //two pointers related ques. always have to do checking for one side left situation
        //[ 6,7,9 ; 1,3,5 ]: the array will be [1,3,5;1,3,5], use the helper which keep the original value to overwrite it
        while(leftIndex<=mid){
            array[left++] = helper[leftIndex++] ;
        }
        //[ 1,3,5 ; 6,7,9] === in this case, there would be left on the right but no need handle at all, the array already [1,3,5;6,7,9]

    }

    public static void main(String[] args){
        int[] array = {6,7,9 , 1,3,5} ;
        sortIntegers(array) ;
        print(array);

    }
    public static void print(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}