归并与快排

java代码

以下是对一个整型数组进行归并排序和快速排序，并输出结果及时间复杂度分析：

import java.util.Arrays;

public class SortingAlgorithms {

    /**
     * 归并排序
     *
     * 时间复杂度：O(nlogn)
     * 空间复杂度：O(n)
     */
    public static void mergeSort(int[] arr) {
        if (arr == null || arr.length <= 1) {
            return;
        }
        int mid = arr.length / 2;
        int[] left = Arrays.copyOfRange(arr, 0, mid);
        int[] right = Arrays.copyOfRange(arr, mid, arr.length);
        mergeSort(left);
        mergeSort(right);
        merge(left, right, arr);
    }

    private static void merge(int[] left, int[] right, int[] result) {
        int i = 0, j = 0, k = 0;
        while (i < left.length && j < right.length) {
            if (left[i] <= right[j]) {
                result[k++] = left[i++];
            } else {
                result[k++] = right[j++];
            }
        }
        while (i < left.length) {
            result[k++] = left[i++];
        }
        while (j < right.length) {
            result[k++] = right[j++];
        }
    }

    /**
     * 快速排序
     *
     * 时间复杂度：
     *      最优情况下：O(nlogn)
     *      最坏情况下：O(n^2)
     *      平均情况下：O(nlogn)
     * 空间复杂度：
     *      最优情况下：O(logn)
     *      最坏情况下：O(n)
     *      平均情况下：O(logn)
     */
    public static void quickSort(int[] arr, int start, int end) {
        if (start >= end) {
            return;
        }
        int pivot = partition(arr, start, end);
        quickSort(arr, start, pivot - 1);
        quickSort(arr, pivot + 1, end);
    }

    private static int partition(int[] arr, int start, int end) {
        int pivot = arr[end];
        int i = start - 1;
        for (int j = start; j < end; j++) {
            if (arr[j] <= pivot) {
                i++;
                swap(arr, i, j);
            }
        }
        swap(arr, i + 1, end);
        return i + 1;
    }

    private static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

}

测试类：

import java.util.Arrays;

public class SortingAlgorithmsTest {

    public static void main(String[] args) {
        int[] arr = {5, 2, 8, 3, 6, 9};
        System.out.println("排序前：" + Arrays.toString(arr));

        SortingAlgorithms.mergeSort(arr);
        System.out.println("归并排序后：" + Arrays.toString(arr));

        SortingAlgorithms.quickSort(arr, 0, arr.length - 1);
        System.out.println("快速排序后：" + Arrays.toString(arr));
    }

}

输出结果：

排序前：[5, 2, 8, 3, 6, 9]
归并排序后：[2, 3, 5, 6, 8, 9]
快速排序后：[2, 3, 5, 6, 8, 9]

对于归并排序，我们将原序列不断拆分成两个子序列，直到只剩下一个元素或空序列，然后再将它们合并为有序序列。因此，归并排序的时间复杂度为 O(nlogn)，空间复杂度为 O(n)。

对于快速排序，我们先通过 partition 方法将序列划分成两个部分，左边的小于等于 pivot，右边的大于 pivot。然后分别对这两个部分进行递归排序。最优情况下的时间复杂度是 O(nlogn)，即每次 partition 的结果都平均划

伪代码

函数 mergeSort(整数数组 arr):
    如果 arr 为空或长度小于等于1，返回
    定义中间位置 mid 为 arr 长度除以2
    定义左半部分 left 为复制 arr 数组从0到mid-1位置的子数组
    定义右半部分 right 为复制 arr 数组从mid到末尾位置的子数组
    调用自身传入参数 left 进行归并排序
    调用自身传入参数 right 进行归并排序
    调用 merge 函数将 left 和 right 合并到原数组 arr 中

函数 merge(整数数组 left, 整数数组 right, 整数数组 result):
    定义三个索引变量 i、j、k 分别初始化为 0
    当 i < left 数组的长度 并且 j < right 数组的长度 时执行循环：
        如果 left[i] <= right[j]，则将 result[k] 赋值为 left[i]，i 和 k 同时加1
        否则，将 result[k] 赋值为 right[j]，j 和 k 同时加1
    如果 left 数组还有剩余，则将剩余元素依次放入 result 数组
    如果 right 数组还有剩余，则将剩余元素依次放入 result 数组

函数 quickSort(整数数组 arr, 整数 start, 整数 end):
    如果 start >= end，返回
    定义 pivot 等于 arr[end]
    定义 i 等于 start-1
    从 start 循环到 end-1，定义变量 j：
        如果 arr[j] <= pivot，i 加1，交换 arr[i] 和 arr[j] 的值
    交换 arr[i+1] 和 arr[end] 的值
    调用自身传入参数 arr、start 和 pivot-1 进行快速排序
    调用自身传入参数 arr、pivot+1 和 end 进行快速排序

函数 swap(整数数组 arr, 整数 i, 整数 j):
    定义临时变量 tmp 为 arr[i]
    将 arr[i] 赋值为 arr[j]
    将 arr[j] 赋值为 tmp

主函数 SortingAlgorithmsTest：
    定义整数数组 arr 并赋值为 {5, 2, 8, 3, 6, 9}
    输出 "排序前：" 和 Arrays.toString(arr)
    调用 mergeSort 函数传入参数 arr 进行归并排序
    输出 "归并排序后：" 和 Arrays.toString(arr)
    调用 quickSort 函数传入参数 arr、0 和 arr.length-1 进行快速排序
    输出 "快速排序后：" 和 Arrays.toString(arr)