MergeSort

1. Method 1 (for beginners) 

   class Solution {
       public int[] sortArray(int[] nums) {
           if(nums == null || nums.length == 1){
               return nums;
           }
           return mergeSort(nums, 0, nums.length - 1);
       }
       
       private int[] mergeSort(int[] arr, int left, int right){
           if(left == right){
               return new int[] {arr[left]};
           }
           int mid = left + (right - left) / 2;
           int[] leftPart = mergeSort(arr, left, mid);
           int[] rightPart = mergeSort(arr, mid + 1, right);
           return merge(leftPart, rightPart);
       }
       
       // Merge two subarrays
       private int[] merge(int[] left, int[] right){
           int[] res = new int[left.length + right.length];
           int leftIndex = 0, rightIndex = 0, resIndex = 0;
           while(leftIndex < left.length && rightIndex < right.length){
               if(left[leftIndex] <= right[rightIndex]){
                   res[resIndex++] = left[leftIndex++];
               }else{
                   res[resIndex++] = right[rightIndex++];
               }
           }
           while(leftIndex < left.length){
               res[resIndex++] = left[leftIndex++];
           }
           while(rightIndex < right.length){
               res[resIndex++] = right[rightIndex++];
           }
           return res;
       }
   }

2. Method 2 (better, using a helper array)
                                                 arr:

   left

   right

   
                                                 helper:

   left

   mid

   mid+1

   right

   class Solution {
       public int[] sortArray(int[] nums) {
           if(nums == null || nums.length == 1){
               return nums;
           }
           int[] helper = new int[nums.length];
           mergeSort(nums, helper, 0, nums.length - 1);
           return nums;
       }
       private void mergeSort(int[] nums, int[] helper, int left, int right){
           if(left == right){
               return;
           }
           int mid = left + (right - left) / 2;
           mergeSort(nums, helper, left, mid);
           mergeSort(nums, helper, mid + 1, right);
           merge(nums, helper, left, mid, right);
       }
       // The subarray is [left, right]
       private void merge(int[] nums, int[] helper, int left, int mid, int right){
           // Copy the content to helper array and we will 
           // merge from the helper array
           for(int i = left; i <= right; i++){
               helper[i] = nums[i];
           }
           int leftIndex = left, rightIndex = mid + 1;
           while(leftIndex <= mid && rightIndex <= right){
               if(helper[leftIndex] <= helper[rightIndex]){
                   nums[left++] = helper[leftIndex++];
               }else{
                   nums[left++] = helper[rightIndex++];
               }
           }
           // If we still have some elements at left side, we need to copy them.
           while(leftIndex <= mid){
               nums[left++] = helper[leftIndex++];
           }
           // If there are some elements at right side, we do not need to copy them
           // because they are already in the correct place.
       }
   }