用Java写一个二路归并排序

### 回答1：
好的，以下是Java语言实现二路归并排序的代码：

public class MergeSort {
    public static void mergeSort(int[] arr, int low, int high) {
        if (low < high) {
            int mid = (low + high) / 2;
            mergeSort(arr, low, mid);
            mergeSort(arr, mid + 1, high);
            merge(arr, low, mid, high);
        }
    }

    public static void merge(int[] arr, int low, int mid, int high) {
        int[] temp = new int[high - low + 1];
        int i = low;
        int j = mid + 1;
        int k = 0;
        while (i <= mid && j <= high) {
            if (arr[i] < arr[j]) {
                temp[k++] = arr[i++];
            } else {
                temp[k++] = arr[j++];
            }
        }
        while (i <= mid) {
            temp[k++] = arr[i++];
        }
        while (j <= high) {
            temp[k++] = arr[j++];
        }
        for (int x = 0; x < temp.length; x++) {
            arr[low + x] = temp[x];
        }
    }
}

使用方法如下：

int[] arr = {9, 8, 7, 6, 5, 4, 3, 2, 1};
MergeSort.mergeSort(arr, 0, arr.length - 1);
System.out.println(Arrays.toString(arr));

输出结果为：

[1, 2, 3, 4, 5, 6, 7, 8, 9]

希望能对你有所帮助。

### 回答2：
二路归并排序是一种经典的排序算法，使用Java编写该算法可以通过递归的方式将数组分成两半，然后再将两个有序子数组合并成一个有序数组。以下是用Java编写的二路归并排序算法：

public class MergeSort {
   public void mergeSort(int[] arr) {
      if (arr == null || arr.length <= 1) {
         return;
      }
      int[] temp = new int[arr.length];
      mergeSort(arr, 0, arr.length - 1, temp);
   }

   private void mergeSort(int[] arr, int start, int end, int[] temp) {
      if (start < end) {
         int mid = start + (end - start) / 2;
         mergeSort(arr, start, mid, temp);
         mergeSort(arr, mid + 1, end, temp);
         merge(arr, start, mid, end, temp);
      }
   }

   private void merge(int[] arr, int start, int mid, int end, int[] temp) {
      int i = start;
      int j = mid + 1;
      int k = start;
      while (i <= mid && j <= end) {
         if (arr[i] <= arr[j]) {
            temp[k++] = arr[i++];
         } else {
            temp[k++] = arr[j++];
         }
      }
      while (i <= mid) {
         temp[k++] = arr[i++];
      }
      while (j <= end) {
         temp[k++] = arr[j++];
      }
      for (int m = start; m <= end; m++) {
         arr[m] = temp[m];
      }
   }
}

以上代码中，`mergeSort`方法是对外提供的方法，调用者只需要传入待排序的数组即可。`mergeSort`方法又调用了私有方法`mergeSort`，该方法实现了递归调用，将数组分成两半并进行排序。最后，私有方法`merge`用于将两个有序子数组合并成一个有序数组。整个过程中，使用了一个辅助数组temp来存储排序后的结果。最后，将排序后的结果复制到原数组中。

以上就是用Java编写的二路归并排序的代码，希望对您有所帮助。

### 回答3：
二路归并排序是一种经典的排序算法，在Java中可以很容易地实现。

首先，我们需要定义一个二路归并排序的方法。这个方法将接收一个整数数组作为参数，并返回排序后的数组。具体实现如下：

public class MergeSort {
    public static int[] mergeSort(int[] arr) {
        if (arr.length <= 1) {
            return arr;
        }

        int mid = arr.length / 2;
        int[] left = new int[mid];
        int[] right = new int[arr.length - mid];

        System.arraycopy(arr, 0, left, 0, mid);
        System.arraycopy(arr, mid, right, 0, arr.length - mid);

        left = mergeSort(left);
        right = mergeSort(right);

        return merge(left, right);
    }

    private static int[] merge(int[] left, int[] right) {
        int[] merged = new int[left.length + right.length];
        int i = 0, j = 0, k = 0;

        while (i < left.length && j < right.length) {
            if (left[i] <= right[j]) {
                merged[k++] = left[i++];
            } else {
                merged[k++] = right[j++];
            }
        }

        while (i < left.length) {
            merged[k++] = left[i++];
        }

        while (j < right.length) {
            merged[k++] = right[j++];
        }

        return merged;
    }

    public static void main(String[] args) {
        int[] arr = {9, 5, 7, 3, 1, 6, 2, 8, 4};
        int[] sortedArr = mergeSort(arr);

        // 打印排序后的数组
        for (int num : sortedArr) {
            System.out.print(num + " ");
        }
    }
}

上述代码中，mergeSort() 方法使用递归的方式进行二路归并排序。它首先判断传入的数组长度是否小于等于1，如果是，则直接返回原数组。否则，找到数组的中间位置，将数组分为左右两部分，并递归地调用 mergeSort() 方法对左右两部分进行排序。最后，使用 merge() 方法将排序完的左右两部分进行合并。

merge() 方法用于合并两个已排序的数组。初始化一个新的数组 merged，以及三个指针 i、j 和 k。当左右两个数组都还有元素时，比较两个指针指向元素的大小，将较小的元素放入 merged 数组，并将相应的指针后移一位。最后，将剩余的未插入 merged 数组中的元素添加到 merged 数组中。

在 main() 方法中，我们定义了一个未排序的整数数组 arr，并调用 mergeSort() 方法对其进行排序。最后，输出排序后的数组。

以上就是用Java实现二路归并排序的方法，通过该算法可将数组按照升序进行排序。