JAVA 中的六大排序算法，含案例和详细注释

JAVA 中的六大排序算法，含案例和详细注释

在 Java 中常用的六大排序算法包括：冒泡排序、选择排序、插入排序、希尔排序、快速排序和归并排序。

下面将逐一介绍这些排序算法并附上案例和详细注释。

冒泡排序（Bubble Sort）

冒泡排序是最简单的排序算法之一，它的基本思路是将相邻的两个元素进行比较，如果它们的顺序不对就交换它们的位置，一遍排序过后最大的元素就会“浮”到最后面，然后对剩下的元素进行同样的操作，直到所有元素都被排序。冒泡排序的时间复杂度为 O(n^2)。

javaCopy codepublic static void bubbleSort(int[] arr) {
    int n = arr.length;

    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

在上面的代码中，我们使用了两个嵌套的 for 循环，外层循环控制排序的轮数，内层循环用于比较相邻的两个元素。如果它们的顺序不对就交换它们的位置。

选择排序（Selection Sort）

选择排序的基本思路是从待排序的数组中选出最小的元素，然后将其与数组中的第一个元素交换位置，然后从剩下的元素中选出最小的元素，再与数组中的第二个元素交换位置，以此类推，直到所有元素都被排序。选择排序的时间复杂度为 O(n^2)。

javaCopy codepublic static void selectionSort(int[] arr) {
    int n = arr.length;

    for (int i = 0; i < n - 1; i++) {
        int minIndex = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        int temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
}

在上面的代码中，我们使用了两个嵌套的 for 循环，外层循环控制排序的轮数，内层循环用于找到待排序数组中的最小元素，然后将其与当前轮次的第一个元素交换位置。

插入排序（Insertion Sort）

插入排序的基本思路是将待排序的数组分成两部分，第一部分包含了一个元素，它是已经排好序的部分，第二部分包含了除了第一个元素以外的所有元素，它是待排序的部分。然后从第二部分开始依次取出元素，插入到第一部分中，直到所有元素都被排序。插入排序的时间复杂度为 O(n^2)。

javaCopy codepublic static void insertionSort(int[] arr) {
    int n = arr.length;

    for (int i = 1; i < n; i++) {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}

在上面的代码中，我们使用了一个 for 循环和一个 while 循环。for 循环用于遍历待排序的数组，while 循环用于将当前元素插入到已经排好序的部分中。

希尔排序（Shell Sort）

希尔排序是一种基于插入排序的排序算法，它的基本思路是将待排序的数组分成若干个子序列，对每个子序列进行插入排序，最后再对整个数组进行一次插入排序。希尔排序的时间复杂度为 O(n log n)。

javaCopy codepublic static void shellSort(int[] arr) {
    int n = arr.length;

    for (int gap = n / 2; gap > 0; gap /= 2) {
        for (int i = gap; i < n; i++) {
            int key = arr[i];
            int j = i;
            while (j >= gap && arr[j - gap] > key) {
                arr[j] = arr[j - gap];
                j -= gap;
            }
            arr[j] = key;
        }
    }
}

在上面的代码中，我们使用了两个嵌套的 for 循环和一个 while 循环。外层循环控制子序列的步长，内层循环用于对每个子序列进行插入排序，while 循环用于将当前元素插入到已经排好序的部分中。

快速排序（Quick Sort）

快速排序是一种基于分治思想的排序算法，它的基本思路是选择一个元素作为基准值，然后将所有小于基准值的元素放到基准值的左边，所有大于基准值的元素放到基准值的右边，然后递归地对左右两个部分进行同样的操作，直到所有元素都被排序。快速排序的时间复杂度为 O(n log n)。

javaCopy codepublic static void quickSort(int[] arr, int left, int right) {
    if (left < right) {
        int pivot = partition(arr, left, right);
        quickSort(arr, left, pivot - 1);
        quickSort(arr, pivot + 1, right);
    }
}

private static int partition(int[] arr, int left, int right) {
    int pivot = arr[right];
    int i = left - 1;

    for (int j = left; j < right; j++) {
        if (arr[j] < pivot) {
            i++;
            swap(arr, i, j);
        }
    }

    swap(arr, i + 1, right);

    return i + 1;
}

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

在上面的代码中，我们使用了递归来实现快速排序。其中 partition 方法用于选择基准值，并将小于基准值的元素放到基准值的左边，大于基准值的元素放到基准值的右边。swap 方法用于交换数组中的两个元素。

归并排序（Merge Sort）

归并排序（Merge Sort）是一种稳定的排序算法，采用了分治思想。将待排序的数组按照一定规则分成若干个子序列，每个子序列都是有序的，然后将相邻的子序列合并成一个有序的序列，直到所有子序列合并成为一个完整的有序序列。

javaCopy codepublic class MergeSort {
    /**
     * 归并排序
     *
     * @param arr 待排序的数组
     * @param left 数组的起始位置
     * @param right 数组的结束位置
     */
    public static void mergeSort(int[] arr, int left, int right) {
        if (left < right) {
            int mid = (left + right) / 2;
            // 将数组分成左右两部分
            mergeSort(arr, left, mid);
            mergeSort(arr, mid + 1, right);
            // 将左右两部分归并
            merge(arr, left, mid, right);
        }
    }

    /**
     * 归并
     *
     * @param arr 待归并的数组
     * @param left 左边部分数组的起始位置
     * @param mid 数组的中间位置
     * @param right 右边部分数组的结束位置
     */
    public static void merge(int[] arr, int left, int mid, int right) {
        int[] temp = new int[right - left + 1]; // 临时数组用于存储归并后的结果
        int i = left; // 左部分数组的起始位置
        int j = mid + 1; // 右部分数组的起始位置
        int k = 0; // 临时数组的起始位置

        // 将左右两部分数组归并到临时数组中
        while (i <= mid && j <= right) {
            if (arr[i] <= arr[j]) {
                temp[k++] = arr[i++];
            } else {
                temp[k++] = arr[j++];
            }
        }

        // 将左部分数组剩余的元素归并到临时数组中
        while (i <= mid) {
            temp[k++] = arr[i++];
        }

        // 将右部分数组剩余的元素归并到临时数组中
        while (j <= right) {
            temp[k++] = arr[j++];
        }

        // 将临时数组的元素复制回原数组中
        for (int m = 0; m < temp.length; m++) {
            arr[left + m] = temp[m];
        }
    }
}

在上面的代码中，我们使用了递归来实现归并排序。其中 mergeSort 方法用于将待排序的数组分成若干个子序列，每个子序列都是有序的，然后将相邻的子序列合并成一个有序的序列，直到所有子序列合并成为一个完整的有序序列。merge 方法用于将两个有序子序列合并成一个。