【用Java学习数据结构系列】七大排序要悄咪咪的学（直接插入，希尔，归并，选择，堆排，冒泡，快排）以及计数排序（非比较排序）

最新推荐文章于 2024-10-01 22:51:02 发布

Gu Gu Study

最新推荐文章于 2024-10-01 22:51:02 发布

阅读量1k

点赞数 10

文章标签：数据结构 java 学习

本文链接：https://blog.csdn.net/2302_81249757/article/details/142667490

版权

看到这句话的时候证明：此刻你我都在努力

加油陌生人

个人主页：Gu Gu Study
专栏：用Java学习数据结构系列
喜欢的一句话：常常会回顾努力的自己，所以要为自己的努力留下足迹

喜欢的话可以点个赞谢谢了。
作者：小闭

前言

今天就写一篇关于排序的文章，本文章包含了，如标题所写的八大排序。八大排序各有各的使用场景，在某个特定场景，那么可能有一个排序就非常适合，所以排序我们是多多益善。

直接插入排序（Straight Insertion Sort）

直接插入排序（Straight Insertion Sort）是一种简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

排序特点：

稳定性：直接插入排序是稳定的排序算法，因为相等的元素的相对顺序不会改变。

时间复杂度：在最好的情况下（数组已经是排序的），时间复杂度为O(n)；在最坏的情况下（数组是逆序的），时间复杂度为O(n^2)；平均时间复杂度为O(n^2)。

空间复杂度：由于直接插入排序是原地排序，不需要额外的存储空间，所以空间复杂度为O(1)。

排序适用场景：

数据规模较小：直接插入排序由于其简单性，适用于数据规模较小的情况。

部分已经排序：如果数组部分已经排序，直接插入排序的性能会比较好。

代码实现：

public static void insetSort(int[] array) {
    for (int i = 1; i < array.length; i++) {
        int tmp = array[i];
        int j = i - 1;
        for (; j >= 0; j--) {
            if (array[j] > tmp) {
                array[j + 1] = array[j];
            } else {

                break;
            }
        }
        array[j + 1] = tmp;

    }

}

排序实现：

从第一个元素开始，该元素可以认为已经被排序。
取出下一个元素，在已经排序的元素序列中从后向前扫描。
如果该元素（已排序）大于新元素，将该元素移到下一位置。
重复步骤3，直到找到已排序的元素小于或者等于新元素的位置。
将新元素插入到该位置后，即挑出循环直接给array[j+1]赋值，然后重复步骤2~4。
对于所有的元素重复步骤1~5。

希尔排序（Shell Sort）

希尔排序（Shell Sort）是一种经典的排序算法，由Donald Shell在1959年提出。它是插入排序的一种改进版，也称为缩小增量排序。希尔排序的核心思想是将待排序的序列分割成若干子序列，对每个子序列进行插入排序，随着增量的逐渐减小，子序列逐渐合并，最终整个序列变得有序。

排序特点：

希尔排序是不稳定的排序算法，因为相同元素可能在排序过程中改变相对位置。

它的时间复杂度在最坏情况下为O(n^2)，但平均情况下通常为O(nlogn)到O(n^(3/2))，这取决于增量序列的选择。

希尔排序的空间复杂度为O(1)，因为它是一种原地排序算法。

适用场景：

希尔排序适用于中等规模的数据排序，因为它比简单的插入排序有更快的效率，但比快速排序和归并排序慢。在数据规模不是特别大的情况下，希尔排序可以作为一个不错的选择。

复杂度分析：

希尔排序的性能与增量序列的选择密切相关。一个好的增量序列可以使得算法在最坏情况下的时间复杂度接近O(nlogn)。然而，目前还没有找到一个通用的最优增量序列，这仍然是一个开放的数学问题。

代码实现：

public static void shellSort(int[] array) {
    int gap = array.length;
    while (gap > 1) {

        gap = gap / 2;
        shell(array, gap);
    }
}

private static void shell(int[] array, int gap) {
    for (int i = gap; i < array.length; i++) {
        int tmp = array[i];
        int j = i - gap;
        for (; j >= 0; j -= gap) {
            if (array[j] > tmp) {
                array[j + gap] = array[j];
            } else {
                break;
            }
        }
        array[j + gap] = tmp;
    }
}

排序实现：

选择一个增量序列，常见的选择是将增量逐渐缩小，例如初始增量为gap/2，然后每次缩小一半，直到增量为1。
按照增量将待排序序列分割成若干子序列，每个子序列的元素在原序列中间隔增量个位置。
对每个子序列进行插入排序。
逐步缩小增量，重复步骤2和3，直到增量减小到1，此时对整个序列进行插入排序。

选择排序（Selection Sort）

选择排序（Selection Sort）是一种简单直观的比较排序算法。它的工作原理是每次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

算法特点：

选择排序是一种不稳定的排序算法，因为相同的元素可能因为排序而改变顺序。

它的时间复杂度为O(n^2)，其中n是序列的长度。无论数组是否已经排序，选择排序的性能都是最差的。

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

适用场景：

选择排序由于其简单性，适用于数据规模较小的情况。在数据规模较大时，由于其时间复杂度较高，通常不推荐使用。

性能分析：

最好、最坏和平均时间复杂度都是O(n^2)。

空间复杂度为O(1)。

代码实现：

public static void selectSort2(int[] array) {

    for (int i = 0; i < array.length; i++) {
        int mindIndex = i;
        for (int j = i + 1; j < array.length; j++) {
            if (array[j] < array[mindIndex]) {
                mindIndex = j;
            }
        }
        swap(array, i, mindIndex);
    }
}

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

排序实现：

找到最小值：从未排序的序列中找到最小（或最大）的元素。
交换：将找到的最小（或最大）元素与序列的起始位置交换。
重复查找：从剩余的未排序元素中继续寻找最小（或最大）元素，然后与下一个位置交换，重复这个过程。
结束：当所有元素都被排序时，算法结束。

我们也可以对这个排序进行优化，即：让数组两边都开始找，一边找最大值，一边找最小值。

优化后的选择排序：

public static void selectSort(int[] array) {
    int left = 0;
    int right = array.length - 1;
    while (left < right) {
        int minIndex = left;
        int maxIndex = left;
        for (int i = left + 1; i <= right; i++) {
            if (array[i] < array[minIndex]) {
                minIndex = i;
            }
            if (array[i] > array[maxIndex]) {
                maxIndex = i;
            }
        }
        swap(array, left, minIndex);
        //最大值正好是  left下标  此时 把最大值换到了minIndex的位置了
        if (maxIndex == left) {
            maxIndex = minIndex;
        }
        swap(array, right, maxIndex);
        left++;
        right--;
    }
}

冒泡排序（Bubble Sort）

冒泡排序（Bubble Sort）是一种简单的排序算法，它重复地遍历待排序的序列，比较每对相邻元素，如果它们的顺序错误就把它们交换过来，遍历序列的工作重复进行，直到没有再需要交换的元素，这表明序列已经排序完成。

排序特点：

冒泡排序是一种稳定的排序算法，因为它不会改变相同元素之间的顺序。

它的时间复杂度为O(n^2)，在所有情况下都是如此，无论是最好、最坏还是平均情况。

冒泡排序的空间复杂度为O(1)，因为它是原地排序，不需要额外的存储空间。

适用场景：

冒泡排序由于其简单性，适用于数据规模较小且要求稳定性的场景。在数据规模较大时，由于其时间复杂度较高，通常不推荐使用。

代码实现：

public static void bubbleSort(int[] array) {
    for (int i = 0; i < array.length - 1; i++) {
        boolean flg = false;
        for (int j = 0; j < array.length - 1 - i; j++) {
            if (array[j] > array[j + 1]) {
                swap(array, j, j + 1);
                flg = true;
            }
        }
        if (!flg) {
            break;
        }
    }
}

排序步骤：

比较相邻的元素：从第一个元素开始，比较相邻的元素对，如果它们的顺序错误（即前一个比后一个大），就交换它们。
交换元素：对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在一趟遍历中，最大的元素会移动到它最终的位置。
重复遍历：针对所有的元素重复以上的步骤，除了最后一个已经排好的元素。
优化：在每次遍历中，最大的元素会移动到序列的末端，因此下一次遍历时可以忽略这个元素，即减少下一次遍历的序列长度。

堆排序（Heap Sort）

堆排序（Heap Sort）是一种高效的比较类排序算法，利用了二叉堆的数据结构来实现。堆是一个满足以下性质的完全二叉树：对于最大堆，父节点的值总是大于或等于它的子节点的值；对于最小堆，父节点的值总是小于或等于它的子节点的值。

排序特点：

堆排序是一种选择排序，它不改变相同元素之间的顺序，因此是一种稳定的排序算法。

它的时间复杂度为O(nlogn)，无论是最好、最坏还是平均情况。

堆排序的空间复杂度为O(1)，因为它是原地排序，不需要额外的存储空间。

适用场景：

堆排序适用于数据规模较大且对排序效率有一定要求的场景。由于其时间复杂度稳定，它在很多情况下都是一个不错的选择。

复杂度分析：

时间复杂度：O(nlogn)。

空间复杂度：O(1)。

代码实现：

public static void heapSort(int[] array) {
    createHeap(array);
    int end = array.length - 1;
    while (end > 0) {
        swap(array, 0, end);
        siftDown(array, 0, end);
        end--;
    }
}

private static void createHeap(int[] array) {
    for (int parent = (array.length - 1 - 1) / 2; parent >= 0; parent--) {
        siftDown(array, parent, array.length);
    }

}

 private static void siftDown(int[] array, int parent, int length) {
        int child = 2 * parent + 1;
        while (child < length) {
            if (child + 1 < length && array[child] < array[child + 1]) {
                child++;
            }
            if (array[child] > array[parent]) {
                swap(array, parent, child);
                parent = child;
                child = 2 * parent + 1;
            } else {
                break;
            }
        }
    }

排序步骤：

建立最大堆：将待排序的序列构造成一个最大堆，即父节点的值总是大于或等于它的子节点的值。
交换并调整堆：将堆顶元素（最大值）与序列的最后一个元素交换，然后将序列的最后一个元素移除（即排序完成），并对交换后的堆进行调整，使其继续保持最大堆的性质。
重复交换和调整：重复步骤2，直到整个序列排序完成。

注意：这里我们将建堆和向下调整单独封装成单个私有函数。

快速排序（Quick Sort）

快速排序（Quick Sort）是一种高效的排序算法，由C. A. R. Hoare在1960年提出。它采用分治法（Divide and Conquer）的策略来对一个数组进行排序。但是他最坏的情况时间复杂度为O(n^2)，但是下面我们将用到三数取中法，范围内进行直接插入排序来优化快排，在一般情况下快排还是很高效的。

排序特点：

快速排序是一种分治法策略的应用，它将一个大问题分解成小问题解决。

它是一个原地排序（不需要额外存储空间）。

快速排序是非稳定的排序算法，相同元素的相对顺序可能会改变。

在平均状况下，快速排序的时间复杂度为O(nlogn)，但最坏情况下会退化到O(n^2)。

适用场景：

快速排序适用于大部分需要排序的场景，尤其是数据规模较大的情况。它通常比其他O(nlogn)算法更快，因为它的内部循环非常高效。

性能分析：

最佳和平均时间复杂度：O(nlogn)。

最坏时间复杂度：O(n^2)，当数据已经是有序或接近有序时（包括逆序）。

空间复杂度：O(logn)，递归栈的深度。


public static void quick(int[] array, int start, int end) {
    if (start >= end) {
        return;
    }
    if (end - start + 1 <= 7) {
        insertSortRange(array, start, end);
        return;
    }
   
    int midIndex = getMiddleNum(array, start, end);
    swap(array, start, midIndex);

    int pivot = partition(array, start, end);
    quick(array, start, pivot - 1);
    quick(array, pivot + 1, end);
}

private static void insertSortRange(int[] array, int start, int end) {
    for (int i = start + 1; i <= end; i++) {
        int tmp = array[i];
        int j = i - 1;
        for (; j >= start; j--) {
            if (array[j] > tmp) {
                array[j + 1] = array[j];
            } else {
                array[j + 1] = tmp;
                break;
            }
        }
        array[j + 1] = tmp;
    }
}

private static int getMiddleNum(int[] array, int left, int right) {
    int mid = (left + right) / 2;
    if (array[left] < array[right]) {
        if (array[mid] < array[left]) {
            return left;
        } else if (array[mid] > array[right]) {
            return right;
        } else {
            return mid;
        }
    } else {
        if (array[mid] > array[left]) {
            return left;
        } else if (array[mid] < array[right]) {
            return right;
        } else {
            return mid;
        }
    }
}


private static int partition(int[] array, int left, int right) {
        int tmp = array[left];
        while (left < right) {
            while (left < right && array[right] >= tmp) {
                right--;
            }
            array[left] = array[right];
            while (left < right && array[left] <= tmp) {
                left++;
            }
            array[right] = array[left];
        }
        array[left] = tmp;
        return left;
    }

这里展示的是经过优化后的快排，这样的快排就不会那么容易出现时间复杂度为：O(n^2)的情况。

排序步骤：

选择基准值：在数据集之中，选择一个元素作为基准值（pivot）。
分区操作：重新排列数据集，比基准值小的元素摆放在基准前面，比基准值大的元素摆在基准后面，相等的则可以放到任一边。在这个分区退出之后，该基准就处于集合的中间位置。
递归排序：递归地将小于基准值的子数组和大于基准值的子数组排序。

然后就是优化部分：

首先我们在递归过程中如果此时子数组的长度小于等于7时，我们就对这个数组进行直接插入排序，因为这时数组其实已经趋于有序，这时使用直接插入排序的效率是比较高的。然后我们取基准值时我们尽量取数组中值比较中间得数作为基准值（pviot），这样也可以提高快排得效率。

归并排序（Merge Sort）

归并排序（Merge Sort）是一种高效的比较排序算法，采用分治法（Divide and Conquer）的一个典型应用。它将数组分成两半，对每一半递归地进行排序，然后将结果归并（合并）起来。

排序特点：

归并排序是稳定的排序算法，它保持相同元素的相对顺序不变。

它的时间复杂度为O(nlogn)，无论是最好、最坏还是平均情况。

归并排序的空间复杂度为O(n)，因为它需要额外的空间来存储合并后的数组。

适用场景：

归并排序适用于数据规模较大且需要稳定排序结果的场景。它在外部排序（数据太大，无法一次性加载到内存中）中特别有用。

复杂度分析：

时间复杂度：O(nlogn)。

空间复杂度：O(n)。

private static void mergeSortTmp(int[] array, int left, int right) {
    if (left >= right) {
        return;
    }
    int mid = (left + right) / 2;
    mergeSortTmp(array, left, mid);
    mergeSortTmp(array, mid + 1, right);
    //走到这里 全部分解完毕
    // 合并
    merge(array, left, mid, right);
}

private static void merge(int[] array, int left, int mid, int right) {
    int[] tmp = new int[right - left + 1];
    int k = 0;
    int s1 = left;
    
    int s2 = mid + 1;
   
    while (s1 <= mid && s2 <= right) {
        if (array[s1] <= array[s2]) {
            tmp[k++] = array[s1++];
        } else {
            tmp[k++] = array[s2++];
        }
    }
    while (s1 <= mid) {
        tmp[k++] = array[s1++];
    }
    while (s2 <= right) {
        tmp[k++] = array[s2++];
    }
    //可以保证tmp数组 是有序的
    for (int i = 0; i < k; i++) {
        array[i + left] = tmp[i];
    }
}

排序步骤：

分解：将当前序列从中间分成两个子序列。
递归排序：递归地对两个子序列进行归并排序。
合并：将两个排序好的子序列合并成一个最终的排序序列。

计数排序（Counting Sort）

计数排序一个不需要进行比较也能进行排序的排序方式，是不是觉得很神奇呢。那么下面我们就看看吧。

计数排序（Counting Sort）是一种非比较型整数排序算法，其核心思想是使用一个额外的数组（称为计数数组）来统计待排序数组中每个元素的出现次数，然后根据这些计数来确定每个元素在排序数组中的位置。

排序特点：

计数排序是一种稳定的排序算法，它不会改变相同元素之间的相对顺序。

它的时间复杂度为O(n+k)，其中n是待排序数组的长度，k是待排序数组中最大和最小值的差。

计数排序的空间复杂度为O(k)，因为需要额外的数组来存储计数信息。

适用场景：

计数排序适用于整数排序，特别是当整数的数值范围不是很大时。它在处理大量数据时非常高效，尤其是当数据分布比较均匀时。

性能分析：

时间复杂度：O(n+k)，n是数组长度，k是数值范围。
空间复杂度：O(k)。

public static void countSort(int[] array) {
    //1. 找最大值 和 最小值 来确定 计数数组的大小
    int maxVal = array[0];
    int minVal = array[0];
    for (int i = 1; i < array.length; i++) {
        if (array[i] < minVal) {
            minVal = array[i];
        }
        if (array[i] > maxVal) {
            maxVal = array[i];
        }
    }
    int len = maxVal - minVal + 1;
    int[] count = new int[len];

    //2. 遍历原来的数组array把 每个元素 放到对应的计数数组当中 进行计数
    for (int i = 0; i < array.length; i++) {
        int index = array[i];
        count[index - minVal]++;
    }
    //3.依次 遍历计数数组 O(范围)
    int index = 0;
    for (int i = 0; i < count.length; i++) {
        while (count[i] != 0) {
            array[index] = i + minVal;
            index++;
            count[i]--;
        }
    }
}

排序步骤：