void mergeSort(int[] nums) {
  mergeSort(nums, 0, nums.length - 1);
  return nums;
}

// Recursive helper function that sorts the specified subarray.
// Note: startIndex and endIndex are inclusive boundaries.
void mergeSort(int[] array, int startIndex, int endIndex) {
  // If the subarray is less than two elements, we're done.
  if(startIndex >= endIndex) {
    return;
  }

  // Split the subarray into two sub-subarrays and mergesort them.
  int centerIndex = (startIndex + endIndex) / 2;
  mergeSort(array, startIndex, centerIndex);
  mergeSort(array, centerIndex + 1, endIndex);

  // Merge the two sorted sub-subarrays into a single subarray.
  merge(array, startIndex, centerIndex, endIndex);
}

// Merge two sorted halves of a subarray into a single sorted subarray.
// Note: startIndex and endIndex are inclusive boundaries.
void merge(int[] array, int startIndex, int centerIndex, int endIndex) {
  // Create copies of the left and right halves.
  // Arrays.copyOfRange endIndex is exclusive, so add one.
  int[] leftArray = Arrays.copyOfRange(array, startIndex, centerIndex + 1);
  int[] rightArray = Arrays.copyOfRange(array, centerIndex + 1, endIndex + 1);

  int arrayIndex = startIndex;
  int leftIndex = 0;
  int rightIndex = 0;

  // Look through the left and right halves, selecting the smallest from each in order.
  while(leftIndex < leftArray.length && rightIndex < rightArray.length) {
    if(leftArray[leftIndex] < rightArray[rightIndex]) {
      array[arrayIndex] = leftArray[leftIndex];
      leftIndex++;
    } else {
      array[arrayIndex] = rightArray[rightIndex];
      rightIndex++;
    }

    arrayIndex++;
  }

  // Copy the remaining values from the left array into the output.
  while(leftIndex < leftArray.length) {
    array[arrayIndex] = leftArray[leftIndex];
    leftIndex++;
    arrayIndex++;
  }

  // Copy the remaining values from the right array into the output.
  while(rightIndex < rightArray.length) {
    array[arrayIndex] = rightArray[rightIndex];
    rightIndex++;
    arrayIndex++;
  }
}