java 歸併排序與快速排序

歸併排序

private static void merge(int[] nums, int[] tempArray, int leftPos, int rightPos, int rightEnd) {
    int leftEnd = rightPos - 1;
    int currPos = leftPos;
    int allNum = rightEnd - leftPos + 1;
    while (leftPos <= leftEnd && rightPos <= rightEnd) {
        if (nums[leftPos] <= nums[rightPos]) tempArray[currPos ++] = nums[leftPos ++];
        else tempArray[currPos ++] = nums[rightPos ++];
    }
    while (leftPos <= leftEnd) tempArray[currPos ++] = nums[leftPos ++];
    while (rightPos <= rightEnd) tempArray[currPos ++] = nums[rightPos ++];
    for (int i = 0; i < allNum; i ++) {
        nums[rightEnd] = tempArray[rightEnd];
        rightEnd --;
    }
}

private static void mergeSort(int[] nums, int[] temp, int left, int right) {
    if (left < right) {
        int mid = (left + right) / 2;
        mergeSort(nums, temp, left, mid);
        mergeSort(nums, temp, mid + 1, right);
        merge(nums, temp, left, mid + 1, right);
    }
}

public static void mergeSort(int[] nums) {
    int length = nums.length;
    int[] tempArray = new int[length];
    mergeSort(nums, tempArray, 0, length - 1);
}

快速排序

public static void swap(int[] nums, int indexA, int indexB) {
    int temp = nums[indexA];
    nums[indexA] = nums[indexB];
    nums[indexB] = temp;
}

public static void MyQuickSort(int[] nums) {
    MyQuickSort(nums, 0, nums.length - 1);
}

private static void MyQuickSort(int[] nums, int start, int end) {
    if (start == end) return;
    int pivotIndex = partition(nums, start, end);
    if (start < pivotIndex) MyQuickSort(nums, start, pivotIndex - 1);
    if (end > pivotIndex) MyQuickSort(nums, pivotIndex + 1, end);
}

private static int partition(int[] nums, int start, int end) {
    if (start == end) return start;
    int pivotIndex = new Random().nextInt(end - start + 1) + start;
    int pivot = nums[pivotIndex];
    swap(nums, pivotIndex, end);
    int left = start - 1, right = end;
    while (true) {
        if (left < end) while (nums[++left] < pivot) {if (left == end) break;}
        if (right > start) while (nums[--right] > pivot) {if (right == start) break;}
        if (left < right) swap(nums, left, right);
        else break;
    }
    swap(nums, left, end);
    return left;
}