八大排序方法（二）：桶排序、选择排序、插入排序、希尔排序

桶排序

桶排序的基本过程

**桶排序（Bucket Sort）**又称箱排序，是一种比较常用的排序算法。其算法原理是将数组分到有限数量的桶里，再对每个桶分别排好序（可以是递归使用桶排序，也可以是使用其他排序算法将每个桶分别排好序），最后一次将每个桶中排好序的数输出。
桶排序的基本步骤
1、确定桶的数量和范围：
首先确定数据的范围和桶的数量。例如，如果数据范围是 [0, 100)，并且希望将数据分成 10 个桶，则每个桶的范围是 10。
2、将元素分配到桶中：
遍历待排序的元素，将每个元素放到对应的桶中。这个过程依赖于元素的值与桶的范围，可以通过一些数学方法（如取整法）确定每个元素应放入哪个桶。
3、对每个桶进行排序：
对每个非空桶内部的数据进行排序。通常可以使用其他简单的排序算法，如插入排序（因为桶内的数据通常较少，可以高效排序）。
4、合并所有桶中的数据：
将所有桶中的数据按顺序合并，得到最终的排序结果。

定义10个桶，依次判断每一个数值对于10的余数，将对应的余数放到对应的桶当中，按先后顺序大小顺序依次从桶中拿出数据完成依次排序，重复上述步骤直到所有的数据都有序。
第一次排序后：

第三次排序后：

第四次：

最后一次排序：

时间复杂度

桶排序的时间复杂度
最佳时间复杂度：O(n + k)（当数据均匀分布时）
平均时间复杂度：O(n + k)（大部分情况下）
最坏时间复杂度：O(n^2)（当数据分布不均匀时，某些桶可能包含大量元素）

空间复杂度

桶排序的空间复杂度
空间复杂度：O(n + k)，其中 n 是元素数量，k 是桶的数量。
如果桶内的排序使用原地排序（如插入排序），则空间复杂度为 O(n)。但是如果使用额外空间的排序算法（如归并排序），空间复杂度会增加。

桶排序代码实现

代码如下：

import java.util.ArrayList;
import java.util.Collections;

public class BucketSort {

    // 函数：桶排序
    public static void bucketSort(int[] arr) {
        // 如果数组为空或只有一个元素，则无需排序
        if (arr == null || arr.length <= 1) {
            return;
        }

        // 1. 找出数组中的最大值和最小值
        int minValue = arr[0];
        int maxValue = arr[0];
        for (int num : arr) {
            if (num < minValue) minValue = num;
            if (num > maxValue) maxValue = num;
        }

        // 2. 计算桶的数量
        int bucketCount = arr.length;
        ArrayList<Integer>[] buckets = new ArrayList[bucketCount];

        // 初始化桶
        for (int i = 0; i < bucketCount; i++) {
            buckets[i] = new ArrayList<>();
        }

        // 3. 将元素分配到桶中
        for (int num : arr) {
            int bucketIndex = (num - minValue) * (bucketCount - 1) / (maxValue - minValue);
            buckets[bucketIndex].add(num);
        }

        // 4. 对每个桶进行排序
        for (int i = 0; i < bucketCount; i++) {
            Collections.sort(buckets[i]);
        }

        // 5. 将桶中的数据收集起来
        int index = 0;
        for (int i = 0; i < bucketCount; i++) {
            for (int num : buckets[i]) {
                arr[index++] = num;
            }
        }
    }

    // 测试桶排序算法
    public static void main(String[] args) {
        int[] arr = {421, 3122, 15123, 7218, 112, 1890, 5521};

        System.out.println("原始数组:");
        for (int num : arr) {
            System.out.print(num + " ");
        }
        System.out.println();

        // 执行桶排序
        bucketSort(arr);

        // 输出排序后的数组
        System.out.println("排序后的数组:");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

结果如下：

112 421 1890 3122 5521 7218 15123 

选择排序

快速排序的基本步骤

1、从未排序部分选择最小元素：
假设数组的第一个元素为最小值，并与数组中其他元素比较。
遍历数组中剩余部分的元素，找到最小的元素。
2、交换最小元素与当前元素：
将当前最小元素与数组中第一个元素交换位置。
这样，数组中第一个元素就变成了最小值，已排序部分增加一个元素。
3、继续处理剩余部分：
接着对剩下的未排序部分重复上述步骤，直到整个数组排序完成。
第一次中的最小值：


第二次排序：

每次找到最小值之后与其对应的位置的值相对换，此后重复上述操作，直到结束。

实现代码

实现代码如下：

public class selectionSort {

    // 选择排序方法
    public static void selectionSort(int[] arr) {
        // 外层循环用于遍历数组
        for (int i = 0; i < arr.length - 1; i++) {
            // 假设当前元素是最小值
            int minIndex = i;

            // 内层循环用于找出未排序部分的最小值
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j; // 更新最小值的索引
                }
            }

            // 如果最小值的索引不是当前索引，则交换
            if (minIndex != i) {
                int temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
        }
    }

    // 打印数组的方法
    public static void printArray(int[] arr) {
        for (int i : arr) {
            System.out.print(i + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        // 测试选择排序
        int[] arr = {64, 25, 12, 22, 11,71,20,1,0,57};

        System.out.println("排序前的数组:");
        printArray(arr);

        selectionSort(arr);

        System.out.println("排序后的数组:");
        printArray(arr);
    }
}

结果如下：

0 1 11 12 20 22 25 57 64 71 

时间复杂度

时间复杂度：选择排序的时间复杂度始终是 O(n²)，无论数组是已经有序、逆序还是随机排序的。

空间复杂度

选择排序是原地排序算法，空间复杂度为 O(1)，不需要额外的存储空间。

插入排序

插入排序（Insertion Sort）是一种简单的排序算法，其基本思路类似于我们整理扑克牌的过程：从第二张牌开始，与前面的牌比较，将其插入到合适的位置，直到所有的牌都整理完成。对于数组来说，插入排序通过将元素逐一插入到已经排序的部分，从而达到排序的目的。

实现基本思路

1、假设数组的第一个元素已经排序：在插入排序开始时，我们假设第一个元素已经是排序好的。然后从第二个元素开始，逐个与前面的已排序部分进行比较。

2、找到合适的位置插入：对于当前的元素（假设是 arr[i]），将其与已排序部分的元素进行比较，从已排序部分的最后一个元素开始，一直到第一个元素，找到合适的位置（即比 arr[i] 小的元素的位置），并将 arr[i] 插入该位置。

3、移动已排序部分的元素：在插入过程中，为了给新元素腾出位置，可能需要将已排序部分的元素向右移动一位。

4、重复以上步骤：对每一个元素进行上述操作，直到整个数组都有序。

代码实现

public class InsertionSort {
    // 插入排序的主函数
    public static void insertionSort(int[] arr) {
        // 从第二个元素开始遍历，因为假设第一个元素已经排好序
        for (int i = 1; i < arr.length; i++) {
            int current = arr[i]; // 当前要插入的元素
            int j = i - 1; // 从当前元素的前一个元素开始查找插入位置

            // 向前移动所有比当前元素大的元素，为当前元素腾出插入位置
            while (j >= 0 && arr[j] > current) {
                arr[j + 1] = arr[j]; // 元素右移
                j--; // 继续向前检查
            }

            // 插入当前元素到找到的位置
            arr[j + 1] = current;
        }
    }

    // 主函数，测试插入排序
    public static void main(String[] args) {
        int[] arr = {5, 2, 9, 1, 5, 6};

        System.out.println("原数组:");
        for (int num : arr) {
            System.out.print(num + " ");
        }
        System.out.println();

        insertionSort(arr); // 执行插入排序

        System.out.println("排序后的数组:");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

时间复杂度

最好情况：当数组已经有序时，每次插入操作只需要进行一次比较，因此时间复杂度为 O(n)。
最坏情况：当数组是逆序时，每次插入操作需要与数组中的所有元素比较，时间复杂度为 O(n²)。
平均情况：平均时间复杂度为 O(n²)，这意味着插入排序对于较大的数组效率较低。

空间复杂度

空间复杂度：O(1)

希尔排序

希尔排序（Shell Sort）是一种基于插入排序的改进算法，它通过将原始数据分成多个子序列来优化插入排序的性能。具体来说，希尔排序通过定义一个间隔（gap），先对间隔内的元素进行插入排序，接着逐步缩小间隔，直到最终间隔为1，此时进行普通的插入排序，最终使得整个数组有序。

希尔排序的基本思路

1、分组：

初始时，将数组按照一定的间隔（gap）分成多个子序列。每个子序列内部元素的相对顺序独立地进行插入排序。
间隔的选择是关键，通常希尔排序会从较大的间隔开始，然后逐渐减小间隔。
2、插入排序：

对每个子序列，进行插入排序。由于每个子序列的元素相隔较远，插入排序的效率通常比对整个数组的插入排序要高。
3、缩小间隔：

每次插入排序完成后，减小间隔（gap），例如将间隔减少为原来的 1/2，继续对新的子序列进行插入排序。
4、最终排序：

当间隔缩小为 1 时，进行一次完整的插入排序，此时元素已经有了一定程度的局部有序，插入排序的效率会大大提升。

代码实现

public class ShellSort {

    // Shell Sort算法
    public static void shellSort(int[] arr) {
        int n = arr.length;

        // 初始增量序列，通常增量初始值为n/2，逐步减小
        for (int gap = n / 2; gap > 0; gap /= 2) {
            // 对每个间隔gap进行插入排序
            for (int i = gap; i < n; i++) {
                int temp = arr[i];
                int j = i;
                
                // 插入排序：将arr[i]插入到对应的间隔位置
                while (j >= gap && arr[j - gap] > temp) {
                    arr[j] = arr[j - gap];
                    j -= gap;
                }
                arr[j] = temp;
            }
        }
    }

    // 打印数组的方法
    public static void printArray(int[] arr) {
        for (int i : arr) {
            System.out.print(i + " ");
        }
        System.out.println();
    }

    // 主函数
    public static void main(String[] args) {
        int[] arr = { 12, 34, 54, 2, 3 };
        System.out.println("原始数组：");
        printArray(arr);

        shellSort(arr);

        System.out.println("排序后的数组：");
        printArray(arr);
    }
}

时间复杂度

希尔排序的时间复杂度依赖于增量序列的选择，不同的增量序列会影响排序的效率。
最坏情况： 如果增量序列选择得不当（例如选择的增量逐步减少为1），希尔排序的时间复杂度可能退化为 O(n²)，与普通插入排序类似。
最佳情况： 如果增量序列选择得当（例如使用 Sedgewick 或 Hibbard 等增量序列），时间复杂度可以接近 O(n log n)。
平均情况： 平均情况下，时间复杂度大约是 O(n^1.3)，比普通插入排序 O(n²) 更有效。

空间复杂度

O(1)