数据结构和算法-排序算法(一)

参考：

https://blog.csdn.net/weixin_41190227/article/details/86600821

https://www.cnblogs.com/itsharehome/p/11058010.html

超详细十大经典排序算法总结（java代码）

0、排序算法说明

0.1 排序的定义
对一序列对象根据某个关键字进行排序。

0.2 术语说明

稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面；

不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；

内排序：所有排序操作都在内存中完成；

外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；

时间复杂度：一个算法执行所耗费的时间。

空间复杂度：运行完一个程序所需内存的大小。

0.3 算法总结

图片名词解释：

n: 数据规模

k: “桶”的个数

In-place: 占用常数内存，不占用额外内存

Out-place: 占用额外内存

0.5 算法分类

0.6 比较和非比较的区别

    常见的快速排序、归并排序、堆排序、冒泡排序等属于比较排序。在排序的最终结果里，元素之间的次序依赖于它们之间的比较。每个数都必须和其他数进行比较，才能确定自己的位置。

    在冒泡排序之类的排序中，问题规模为n，又因为需要比较n次，所以平均时间复杂度为O(n²)。在归并排序、快速排序之类的排序中，问题规模通过分治法消减为logN次，所以时间复杂度平均O(nlogn)。

    比较排序的优势是，适用于各种规模的数据，也不在乎数据的分布，都能进行排序。可以说，比较排序适用于一切需要排序的情况。

    计数排序、基数排序、桶排序则属于非比较排序。非比较排序是通过确定每个元素之前，应该有多少个元素来排序。针对数组arr，计算arr[i]之前有多少个元素，则唯一确定了arr[i]在排序后数组中的位置。

    非比较排序只要确定每个元素之前的已有的元素个数即可，所有一次遍历即可解决。算法时间复杂度O(n)。

    非比较排序时间复杂度底，但由于非比较排序需要占用空间来确定唯一位置。所以对数据规模和数据分布有一定的要求。

1、冒泡排序（Bubble Sort）

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

1.3 代码实现

1.1 算法描述

步骤1: 比较相邻的元素。如果第一个比第二个大，就交换它们两个；

步骤2: 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；

步骤3: 针对所有的元素重复以上的步骤，除了最后一个；

步骤4: 重复步骤1~3，直到排序完成。

1.2 动图演示
/**
     * 冒泡排序
     *
     * @param array
     * @return
     */
    public static int[] bubbleSort(int[] array) {
        if (array.length == 0)
            return array;
        for (int i = 0; i < array.length; i++)
            for (int j = 0; j < array.length - 1 - i; j++)
                if (array[j + 1] < array[j]) {
                    int temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                }
        return array;
    }
1.4 算法分析

最佳情况：T(n) = O(n)

最差情况：T(n) = O(n2)

平均情况：T(n) = O(n2)

2、选择排序（Selection Sort）

选择排序是表现最稳定的排序算法之一，因为无论什么数据进去都是O(n2)的时间复杂度，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲，选择排序可能也是平时排序一般人想到的最多的排序方法了吧。

选择排序(Selection-sort) 是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

2.3 代码实现
2.1 算法描述

n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：

步骤1：初始状态：无序区为R[1…n]，有序区为空；

步骤2：第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1…i-1]和R(i…n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；

步骤3：n-1趟结束，数组有序化了。

2.2 动图演示
 /**
     * 选择排序
     * @param array
     * @return
     */
    public static int[] selectionSort(int[] array) {
        if (array.length == 0)
            return array;
        for (int i = 0; i < array.length; i++) {
            int minIndex = i;
            for (int j = i; j < array.length; j++) {
                if (array[j] < array[minIndex]) //找到最小的数
                    minIndex = j; //将最小数的索引保存
            }
            int temp = array[minIndex];
            array[minIndex] = array[i];
            array[i] = temp;
        }
        return array;
    }
2.4 算法分析

最佳情况：T(n) = O(n2)

最差情况：T(n) = O(n2)

平均情况：T(n) = O(n2)

3、插入排序（Insertion Sort）

插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
3.1 算法描述

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

步骤1: 从第一个元素开始，该元素可以认为已经被排序；

步骤2: 取出下一个元素，在已经排序的元素序列中从后向前扫描；

步骤3: 如果该元素（已排序）大于新元素，将该元素移到下一位置；

步骤4: 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；

步骤5: 将新元素插入到该位置后；

步骤6: 重复步骤2~5。

3.2 动图演示

3.3 代码实现
   /**
     * 插入排序
     * @param array
     * @return
     */
    public static int[] insertionSort(int[] array) {
        if (array.length == 0)
            return array;
        int current;
        for (int i = 0; i < array.length - 1; i++) {
            current = array[i + 1];
            int preIndex = i;
            while (preIndex >= 0 && current < array[preIndex]) {
                array[preIndex + 1] = array[preIndex];
                preIndex--;
            }
            array[preIndex + 1] = current;
        }
        return array;
    }
3.4 算法分析

最佳情况：T(n) = O(n)

最坏情况：T(n) = O(n2)

平均情况：T(n) = O(n2)

4、希尔排序（Shell Sort）

    希尔排序是希尔（Donald Shell）于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序，同时该算法是冲破O(n2）的第一批算法之一。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

    希尔排序是把记录按下表的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

4.1 算法描述

    我们来看下希尔排序的基本步骤，在此我们选择增量gap=length/2，缩小增量继续以gap = gap/2的方式，这种增量选择我们可以用一个序列来表示，{n/2,(n/2)/2…1}，称为增量序列。希尔排序的增量序列的选择与证明是个数学难题，我们选择的这个增量序列是比较常用的，也是希尔建议的增量，称为希尔增量，但其实这个增量序列不是最优的。此处我们做示例使用希尔增量。

    先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：

步骤1：选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；

步骤2：按增量序列个数k，对序列进行k 趟排序；

步骤3：每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

4.2 过程演示
4.3 代码实现
/**
     * 希尔排序
     *
     * @param array
     * @return
     */
    public static int[] ShellSort(int[] array) {
        int len = array.length;
        int temp, gap = len / 2;
        while (gap > 0) {
            for (int i = gap; i < len; i++) {
                temp = array[i];
                int preIndex = i - gap;
                while (preIndex >= 0 && array[preIndex] > temp) {
                    array[preIndex + gap] = array[preIndex];
                    preIndex -= gap;
                }
                array[preIndex + gap] = temp;
            }
            gap /= 2;
        }
        return array;
    }
4.4 算法分析

最佳情况：T(n) = O(nlog2 n)

最坏情况：T(n) = O(nlog2 n)

平均情况：T(n) =O(nlog2n)

5、归并排序（Merge Sort）

和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(n log n）的时间复杂度。代价是需要额外的内存空间。

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

5.1 算法描述

步骤1：把长度为n的输入序列分成两个长度为n/2的子序列；

步骤2：对这两个子序列分别采用归并排序；

步骤3：将两个排序好的子序列合并成一个最终的排序序列。

5.2 动图演示

5.3 代码实现
/**
     * 归并排序
     *
     * @param array
     * @return
     */
    public static int[] MergeSort(int[] array) {
        if (array.length < 2) return array;
        int mid = array.length / 2;
        int[] left = Arrays.copyOfRange(array, 0, mid);
        int[] right = Arrays.copyOfRange(array, mid, array.length);
        return merge(MergeSort(left), MergeSort(right));
    }
    /**
     * 归并排序——将两段排序好的数组结合成一个排序数组
     *
     * @param left
     * @param right
     * @return
     */
    public static int[] merge(int[] left, int[] right) {
        int[] result = new int[left.length + right.length];
        for (int index = 0, i = 0, j = 0; index < result.length; index++) {
            if (i >= left.length)
                result[index] = right[j++];
            else if (j >= right.length)
                result[index] = left[i++];
            else if (left[i] > right[j])
                result[index] = right[j++];
            else
                result[index] = left[i++];
        }
        return result;
    }
5.4 算法分析

最佳情况：T(n) = O(n)

最差情况：T(n) = O(nlogn)

平均情况：T(n) = O(nlogn)

6、快速排序（Quick Sort）

快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

6.1 算法描述

快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

步骤1：从数列中挑出一个元素，称为 “基准”（pivot ）；

步骤2：重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；

步骤3：递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

6.2 动图演示

6.3 代码实现
/**
     * 快速排序方法
     * @param array
     * @param start
     * @param end
     * @return
     */
    public static int[] QuickSort(int[] array, int start, int end) {
        if (array.length < 1 || start < 0 || end >= array.length || start > end) return null;
        int smallIndex = partition(array, start, end);
        if (smallIndex > start)
            QuickSort(array, start, smallIndex - 1);
        if (smallIndex < end)
            QuickSort(array, smallIndex + 1, end);
        return array;
    }
    /**
     * 快速排序算法——partition
     * @param array
     * @param start
     * @param end
     * @return
     */
    public static int partition(int[] array, int start, int end) {
        int pivot = (int) (start + Math.random() * (end - start + 1));
        int smallIndex = start - 1;
        swap(array, pivot, end);
        for (int i = start; i <= end; i++)
            if (array[i] <= array[end]) {
                smallIndex++;
                if (i > smallIndex)
                    swap(array, i, smallIndex);
            }
        return smallIndex;
    }
 
    /**
     * 交换数组内两个元素
     * @param array
     * @param i
     * @param j
     */
    public static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
6.4 算法分析

最佳情况：T(n) = O(nlogn)

最差情况：T(n) = O(n2)

平均情况：T(n) = O(nlogn)

7、堆排序（Heap Sort）

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

7.1 算法描述

步骤1：将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；

步骤2：将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；

步骤3：由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

7.2 动图演示

7.3 代码实现
//声明全局变量，用于记录数组array的长度；
    static int len;
    /**
     * 堆排序算法
     *
     * @param array
     * @return
     */
    public static int[] HeapSort(int[] array) {
        len = array.length;
        if (len < 1) return array;
        //1.构建一个最大堆
        buildMaxHeap(array);
        //2.循环将堆首位（最大值）与末位交换，然后在重新调整最大堆
        while (len > 0) {
            swap(array, 0, len - 1);
            len--;
            adjustHeap(array, 0);
        }
        return array;
    }
    /**
     * 建立最大堆
     *
     * @param array
     */
    public static void buildMaxHeap(int[] array) {
        //从最后一个非叶子节点开始向上构造最大堆
        //for循环这样写会更好一点：i的左子树和右子树分别2i+1和2(i+1)
        for (int i = (len/2- 1); i >= 0; i--) {
            adjustHeap(array, i);
        }
    }
    /**
     * 调整使之成为最大堆
     *
     * @param array
     * @param i
     */
    public static void adjustHeap(int[] array, int i) {
        int maxIndex = i;
        //如果有左子树，且左子树大于父节点，则将最大指针指向左子树
        if (i * 2 < len && array[i * 2] > array[maxIndex])
            maxIndex = i * 2 + 1;
        //如果有右子树，且右子树大于父节点，则将最大指针指向右子树
        if (i * 2 + 1 < len && array[i * 2 + 1] > array[maxIndex])
            maxIndex = i * 2 + 2; 
        //如果父节点不是最大值，则将父节点与最大值交换，并且递归调整与父节点交换的位置。
        if (maxIndex != i) {
            swap(array, maxIndex, i);
            adjustHeap(array, maxIndex);
        }
    }
7.4 算法分析

最佳情况：T(n) = O(nlogn)

最差情况：T(n) = O(nlogn)

平均情况：T(n) = O(nlogn)

8、计数排序（Counting Sort）

计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。

计数排序(Counting sort) 是一种稳定的排序算法。计数排序使用一个额外的数组C，其中第i个元素是待排序数组A中值等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。它只能对整数进行排序。

8.1 算法描述

步骤1：找出待排序的数组中最大和最小的元素；

步骤2：统计数组中每个值为i的元素出现的次数，存入数组C的第i项；

步骤3：对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；

步骤4：反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。

8.2 动图演示

8.3 代码实现
    /**
     * 计数排序
     *
     * @param array
     * @return
     */
    public static int[] CountingSort(int[] array) {
        if (array.length == 0) return array;
        int bias, min = array[0], max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max)
                max = array[i];
            if (array[i] < min)
                min = array[i];
        }
        bias = 0 - min;
        int[] bucket = new int[max - min + 1];
        Arrays.fill(bucket, 0);
        for (int i = 0; i < array.length; i++) {
            bucket[array[i] + bias]++;
        }
        int index = 0, i = 0;
        while (index < array.length) {
            if (bucket[i] != 0) {
                array[index] = i - bias;
                bucket[i]--;
                index++;
            } else
                i++;
        }
        return array;
    }
8.4 算法分析

当输入的元素是n 个0到k之间的整数时，它的运行时间是 O(n + k)。计数排序不是比较排序，排序的速度快于任何比较排序算法。由于用来计数的数组C的长度取决于待排序数组中数据的范围（等于待排序数组的最大值与最小值的差加上1），这使得计数排序对于数据范围很大的数组，需要大量时间和内存。

最佳情况：T(n) = O(n+k)

最差情况：T(n) = O(n+k)

平均情况：T(n) = O(n+k)

9、桶排序（Bucket Sort）

桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。

桶排序 (Bucket sort)的工作的原理：
假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排

9.1 算法描述

步骤1：人为设置一个BucketSize，作为每个桶所能放置多少个不同数值（例如当BucketSize==5时，该桶可以存放｛1,2,3,4,5｝这几种数字，但是容量不限，即可以存放100个3）；

步骤2：遍历输入数据，并且把数据一个一个放到对应的桶里去；

步骤3：对每个不是空的桶进行排序，可以使用其它排序方法，也可以递归使用桶排序；

步骤4：从不是空的桶里把排好序的数据拼接起来。

注意，如果递归使用桶排序为各个桶排序，则当桶数量为1时要手动减小BucketSize增加下一循环桶的数量，否则会陷入死循环，导致内存溢出。

9.2 图片演示

9.3 代码实现
 /**
     * 桶排序
     *
     * @param array
     * @param bucketSize
     * @return
     */
    public static ArrayList<Integer> BucketSort(ArrayList<Integer> array, int bucketSize) {
        if (array == null || array.size() < 2)
            return array;
        int max = array.get(0), min = array.get(0);
        // 找到最大值最小值
        for (int i = 0; i < array.size(); i++) {
            if (array.get(i) > max)
                max = array.get(i);
            if (array.get(i) < min)
                min = array.get(i);
        }
        int bucketCount = (max - min) / bucketSize + 1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketCount);
        ArrayList<Integer> resultArr = new ArrayList<>();
        for (int i = 0; i < bucketCount; i++) {
            bucketArr.add(new ArrayList<Integer>());
        }
        for (int i = 0; i < array.size(); i++) {
            bucketArr.get((array.get(i) - min) / bucketSize).add(array.get(i));
        }
        for (int i = 0; i < bucketCount; i++) {
            if (bucketSize == 1) { // 如果带排序数组中有重复数字时
                for (int j = 0; j < bucketArr.get(i).size(); j++)
                    resultArr.add(bucketArr.get(i).get(j));
            } else {
                if (bucketCount == 1)
                    bucketSize--;
                ArrayList<Integer> temp = BucketSort(bucketArr.get(i), bucketSize);
                for (int j = 0; j < temp.size(); j++)
                    resultArr.add(temp.get(j));
            }
        }
        return resultArr;
    }
9.4 算法分析

桶排序最好情况下使用线性时间O(n)，桶排序的时间复杂度，取决与对各个桶之间数据进行排序的时间复杂度，因为其它部分的时间复杂度都为O(n)。很显然，桶划分的越小，各个桶之间的数据越少，排序所用的时间也会越少。但相应的空间消耗就会增大。

最佳情况：T(n) = O(n+k)

最差情况：T(n) = O(n+k)

平均情况：T(n) = O(n2)

10、基数排序（Radix Sort）

基数排序也是非比较的排序算法，对每一位进行排序，从最低位开始排序，复杂度为O(kn),为数组长度，k为数组中的数的最大的位数；

基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以是稳定的。

10.1 算法描述

步骤1：取得数组中的最大数，并取得位数；

步骤2：arr为原始数组，从最低位开始取每个位组成radix数组；

步骤3：对radix进行计数排序（利用计数排序适用于小范围数的特点）；

10.2 动图演示

10.3 代码实现
 /**
     * 基数排序
     * @param array
     * @return
     */
    public static int[] RadixSort(int[] array) {
        if (array == null || array.length < 2)
            return array;
        // 1.先算出最大数的位数；
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            max = Math.max(max, array[i]);
        }
        int maxDigit = 0;
        while (max != 0) {
            max /= 10;
            maxDigit++;
        }
        int mod = 10, div = 1;
        ArrayList<ArrayList<Integer>> bucketList = new ArrayList<ArrayList<Integer>>();
        for (int i = 0; i < 10; i++)
            bucketList.add(new ArrayList<Integer>());
        for (int i = 0; i < maxDigit; i++, mod *= 10, div *= 10) {
            for (int j = 0; j < array.length; j++) {
                int num = (array[j] % mod) / div;
                bucketList.get(num).add(array[j]);
            }
            int index = 0;
            for (int j = 0; j < bucketList.size(); j++) {
                for (int k = 0; k < bucketList.get(j).size(); k++)
                    array[index++] = bucketList.get(j).get(k);
                bucketList.get(j).clear();
            }
        }
        return array;
    }
10.4 算法分析

最佳情况：T(n) = O(n * k)

最差情况：T(n) = O(n * k)

平均情况：T(n) = O(n * k)

10.5 基数排序有两种方法：

MSD 从高位开始进行排序

LSD 从低位开始进行排序

基数排序 vs 计数排序 vs 桶排序

这三种排序算法都利用了桶的概念，但对桶的使用方法上有明显差异：

基数排序：根据键值的每位数字来分配桶

计数排序：每个桶只存储单一键值

桶排序：每个桶存储一定范围的数值

十大经典排序算法

前言说明

十大排序算法可以说是每个程序员都必须得掌握的了，花了一天的时间把代码实现且整理了一下，为了方便大家学习，我把它整理成一篇文章，每种算法会有简单的算法思想描述，为了方便大家理解，我还找来了动图演示；这还不够，我还附上了对应的优质文章，看完不懂你来砍我，如果不想砍我就给我来个好看。

术语解释

有些人可能不知道什么是稳定排序、原地排序、时间复杂度、空间复杂度，我这里先简单解释一下：

1、稳定排序：如果 a 原本在 b 的前面，且 a == b，排序之后 a 仍然在 b 的前面，则为稳定排序。

2、非稳定排序：如果 a 原本在 b 的前面，且 a == b，排序之后 a 可能不在 b 的前面，则为非稳定排序。

3、原地排序：原地排序就是指在排序过程中不申请多余的存储空间，只利用原来存储待排数据的存储空间进行比较和交换的数据排序。

4、非原地排序：需要利用额外的数组来辅助排序。

5、时间复杂度：一个算法执行所消耗的时间。

6、空间复杂度：运行完一个算法所需的内存大小。

十大排序

为了方便大家查找，我这里弄一个伪目录。

选择排序
插入排序
冒泡排序

非优化版本
优化版本

希尔排序
归并排序

递归式归并排序
非递归式归并排序

快速排序
堆排序
基数排序

非优化版本
优化版本

桶排序
基数排序

1、选择排序

过程简单描述：
首先，找到数组中最小的那个元素，其次，将它和数组的第一个元素交换位置(如果第一个元素就是最小元素那么它就和自己交换)。其次，在剩下的元素中找到最小的元素，将它与数组的第二个元素交换位置。如此往复，直到将整个数组排序。这种方法我们称之为选择排序。

为方便理解我还准备了动图：

如果还是不懂的话我还给你准备了优质的文章讲解：选择排序

代码如下：

 1 public class SelectSort {
 2     public static int[] selectSort(int[] a) {
 3         int n = a.length;
 4        for (int i = 0; i < n - 1; i++) {
 5             int min = i;
 6             for (int j = i + 1; j < n; j++) {
 7                if(a[min] > a[j]) min = j;
 8             }
 9             //交换
10             int temp = a[i];
11             a[i] = a[min];
12             a[min] = temp;
13         }
14         return a;
15     }
16 }

性质：1、时间复杂度：O(n2) 2、空间复杂度：O(1) 3、非稳定排序 4、原地排序

2、插入排序

我们在玩打牌的时候，你是怎么整理那些牌的呢？一种简单的方法就是一张一张的来，将每一张牌插入到其他已经有序的牌中的适当位置。当我们给无序数组做排序的时候，为了要插入元素，我们需要腾出空间，将其余所有元素在插入之前都向右移动一位，这种算法我们称之为插入排序。

过程简单描述：

1、从数组第2个元素开始抽取元素。

2、把它与左边第一个元素比较，如果左边第一个元素比它大，则继续与左边第二个元素比较下去，直到遇到不比它大的元素，然后插到这个元素的右边。

3、继续选取第3，4，….n个元素,重复步骤 2 ，选择适当的位置插入。

为方便理解我还准备了动图：

如果还是不懂的话我还给你准备了优质的文章讲解：插入排序

代码如下：

 1 public class InsertSort {
 2     public static int[] insertSort(int[] arr) {
 3         if(arr == null || arr.length < 2)
 4             return arr;
 5 
 6         int n = arr.length;
 7         for (int i = 1; i < n; i++) {
 8             int temp = arr[i];
 9             int k = i - 1;
10             while(k >= 0 && arr[k] > temp)
11                 k--;
12             //腾出位置插进去,要插的位置是 k + 1;
13             for(int j = i ; j > k + 1; j--)
14                 arr[j] = arr[j-1];
15             //插进去
16             arr[k+1] = temp;
17         }
18         return arr;
19     }
20 }

性质：1、时间复杂度：O(n2) 2、空间复杂度：O(1) 3、稳定排序 4、原地排序

3、冒泡排序

1、把第一个元素与第二个元素比较，如果第一个比第二个大，则交换他们的位置。接着继续比较第二个与第三个元素，如果第二个比第三个大，则交换他们的位置….

我们对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样一趟比较交换下来之后，排在最右的元素就会是最大的数。

除去最右的元素，我们对剩余的元素做同样的工作，如此重复下去，直到排序完成。

为方便理解我还准备了动图：

如果还是不懂的话我还给你准备了优质的文章讲解：冒泡排序

代码如下

 1 public class BubbleSort {
 2     public static int[] bubbleSort(int[] arr) {
 3         if (arr == null || arr.length < 2) {
 4             return arr;
 5         }
 6         int n = arr.length;
 7         for (int i = 0; i < n; i++) {
 8             for (int j = 0; j < n -i - 1; j++) {
 9                 if (arr[j + 1] < arr[j]) {
10                     int t = arr[j];
11                     arr[j] = arr[j+1];
12                     arr[j+1] = t;
13                 }
14             }
15         }
16         return arr;
17     }
18 )

性质：1、时间复杂度：O(n2) 2、空间复杂度：O(1) 3、稳定排序 4、原地排序

优化一下冒泡排序的算法

假如从开始的第一对到结尾的最后一对，相邻的元素之间都没有发生交换的操作，这意味着右边的元素总是大于等于左边的元素，此时的数组已经是有序的了，我们无需再对剩余的元素重复比较下去了。

代码如下：

 1 public class BubbleSort {
 2     public static int[] bubbleSort(int[] arr) {
 3         if (arr == null || arr.length < 2) {
 4             return arr;
 5         }
 6         int n = arr.length;
 7         for (int i = 0; i < n; i++) {
 8             boolean flag = true;
 9             for (int j = 0; j < n -i - 1; j++) {
10                 if (arr[j + 1] < arr[j]) {
11                     flag = false;
12                     int t = arr[j];
13                     arr[j] = arr[j+1];
14                     arr[j+1] = t;
15                 }
16             }
17             //一趟下来是否发生位置交换
18             if(flag)
19                 break;
20         }
21         return arr;
22     }
23 }

4、希尔排序（插入排序的变种）

希尔排序可以说是插入排序的一种变种。无论是插入排序还是冒泡排序，如果数组的最大值刚好是在第一位，要将它挪到正确的位置就需要 n - 1 次移动。也就是说，原数组的一个元素如果距离它正确的位置很远的话，则需要与相邻元素交换很多次才能到达正确的位置，这样是相对比较花时间了。

希尔排序就是为了加快速度简单地改进了插入排序，交换不相邻的元素以对数组的局部进行排序。

希尔排序的思想是采用插入排序的方法，先让数组中任意间隔为 h 的元素有序，刚开始 h 的大小可以是 h = n / 2,接着让 h = n / 4，让 h 一直缩小，当 h = 1 时，也就是此时数组中任意间隔为1的元素有序，此时的数组就是有序的了。

为方便理解我还准备了图片：

如果还是不懂的话我还给你准备了优质的文章讲解：希尔排序

代码如下

 1 public class ShellSort {
 2     public static int[] shellSort(int arr[]) {
 3         if (arr == null || arr.length < 2) return arr;
 4         int n = arr.length;
 5         // 对每组间隔为 h的分组进行排序，刚开始 h = n / 2;
 6          for (int h = n / 2; h > 0; h /= 2) {
 7             //对各个局部分组进行插入排序
 8              for (int i = h; i < n; i++) {
 9                 // 将arr[i] 插入到所在分组的正确位置上
10                 insertI(arr, h, i);
11             }
12      }
13      return arr;
14     }
15 
16     /**
17      * 将arr[i]插入到所在分组的正确位置上
18      * arr[i]] 所在的分组为 ... arr[i-2*h],arr[i-h], arr[i+h] ...
19      */
20     private static void insertI(int[] arr, int h, int i) {
21         int temp = arr[i];
22         int k;
23         for (k = i - h; k > 0 && temp < arr[k]; k -= h) {
24             arr[k + h] = arr[k];
25         }
26         arr[k + h] = temp;
27     }
28 }

需要注意的是，对各个分组进行插入的时候并不是先对一个组排序完了再来对另一个组排序，而是轮流对每个组进行排序。

性质：1、时间复杂度：O(nlogn) 2、空间复杂度：O(1) 3、非稳定排序 4、原地排序

5、归并排序

将一个大的无序数组有序，我们可以把大的数组分成两个，然后对这两个数组分别进行排序，之后在把这两个数组合并成一个有序的数组。由于两个小的数组都是有序的，所以在合并的时候是很快的。

通过递归的方式将大的数组一直分割，直到数组的大小为 1，此时只有一个元素，那么该数组就是有序的了，之后再把两个数组大小为1的合并成一个大小为2的，再把两个大小为2的合并成4的 ….. 直到全部小的数组合并起来。

为方便理解我还准备了动图：

如果还是不懂的话我还给你准备了优质的文章讲解：归并排序

代码如下：

 1 public class MergeSort {
 2     // 归并排序
 3     public static int[] mergeSort(int[] arr, int left, int right) {
 4         // 如果 left == right，表示数组只有一个元素，则不用递归排序
 5         if (left < right) {
 6             // 把大的数组分隔成两个数组
 7             int mid = (left + right) / 2;
 8             // 对左半部分进行排序
 9             arr = mergeSort(arr, left, mid);
10             // 对右半部分进行排序
11             arr = mergeSort(arr, mid + 1, right);
12             //进行合并
13             merge(arr, left, mid, right);
14         }
15         return arr;
16     }
17 
18     // 合并函数，把两个有序的数组合并起来
19     // arr[left..mif]表示一个数组，arr[mid+1 .. right]表示一个数组
20     private static void merge(int[] arr, int left, int mid, int right) {
21         //先用一个临时数组把他们合并汇总起来
22         int[] a = new int[right - left + 1];
23         int i = left;
24         int j = mid + 1;
25         int k = 0;
26         while (i <= mid && j <= right) {
27             if (arr[i] < arr[j]) {
28                 a[k++] = arr[i++];
29             } else {
30                 a[k++] = arr[j++];
31             }
32         }
33         while(i <= mid) a[k++] = arr[i++];
34         while(j <= right) a[k++] = arr[j++];
35         // 把临时数组复制到原数组
36         for (i = 0; i < k; i++) {
37             arr[left++] = a[i];
38         }
39     }
40 }

性质：1、时间复杂度：O(nlogn) 2、空间复杂度：O(n) 3、稳定排序 4、非原地排序

然而面试官要你写个非递归式的归并排序怎么办？别怕，我这还撸了个非递归式的归并排序，代码如下：

 1 public class MergeSort {
 2     // 非递归式的归并排序
 3     public static int[] mergeSort(int[] arr) {
 4         int n = arr.length;
 5         // 子数组的大小分别为1，2，4，8...
 6         // 刚开始合并的数组大小是1，接着是2，接着4....
 7         for (int i = 1; i < n; i += i) {
 8             //进行数组进行划分
 9             int left = 0;
10             int mid = left + i - 1;
11             int right = mid + i;
12             //进行合并，对数组大小为 i 的数组进行两两合并
13             while (right < n) {
14                 // 合并函数和递归式的合并函数一样
15                 merge(arr, left, mid, right);
16                 left = right + 1;
17                 mid = left + i - 1;
18                 right = mid + i;
19             }
20             // 还有一些被遗漏的数组没合并，千万别忘了
21             // 因为不可能每个字数组的大小都刚好为 i
22             if (left < n && mid < n) {
23                 merge(arr, left, mid, n - 1);
24             }
25         }
26         return arr;
27     }
28 }

6、快速排序

我们从数组中选择一个元素，我们把这个元素称之为中轴元素吧，然后把数组中所有小于中轴元素的元素放在其左边，所有大于或等于中轴元素的元素放在其右边，显然，此时中轴元素所处的位置的是有序的。也就是说，我们无需再移动中轴元素的位置。

从中轴元素那里开始把大的数组切割成两个小的数组(两个数组都不包含中轴元素)，接着我们通过递归的方式，让中轴元素左边的数组和右边的数组也重复同样的操作，直到数组的大小为1，此时每个元素都处于有序的位置。

为方便理解我还准备了动图：

如果还是不懂的话我还给你准备了优质的文章讲解：不要在问我快速排序

代码如下：

 1 public class QuickSort {
 2     public static int[] quickSort(int[] arr, int left, int right) {
 3         if (left < right) {
 4             //获取中轴元素所处的位置
 5             int mid = partition(arr, left, right);
 6             //进行分割
 7             arr = quickSort(arr, left, mid - 1);
 8             arr = quickSort(arr, mid + 1, right);
 9         }
10         return arr;
11     }
12 
13     private static int partition(int[] arr, int left, int right) {
14         //选取中轴元素
15         int pivot = arr[left];
16         int i = left + 1;
17         int j = right;
18         while (true) {
19             // 向右找到第一个小于等于 pivot 的元素位置
20             while (i <= j && arr[i] <= pivot) i++;
21             // 向左找到第一个大于等于 pivot 的元素位置
22             while(i <= j && arr[j] >= pivot ) j--;
23             if(i >= j)
24                 break;
25             //交换两个元素的位置，使得左边的元素不大于pivot,右边的不小于pivot
26             int temp = arr[i];
27             arr[i] = arr[j];
28             arr[j] = temp;
29         }
30         arr[left] = arr[j];
31         // 使中轴元素处于有序的位置
32         arr[j] = pivot;
33         return j;
34     }
35 }

性质：1、时间复杂度：O(nlogn) 2、空间复杂度：O(logn) 3、非稳定排序 4、原地排序

7、堆排序

堆的特点就是堆顶的元素是一个最值，大顶堆的堆顶是最大值，小顶堆则是最小值。

堆排序就是把堆顶的元素与最后一个元素交换，交换之后破坏了堆的特性，我们再把堆中剩余的元素再次构成一个大顶堆，然后再把堆顶元素与最后第二个元素交换….如此往复下去，等到剩余的元素只有一个的时候，此时的数组就是有序的了。

为方便理解我还准备了动图：

如果还是不懂的话我还给你准备了优质的文章讲解：堆排序是什么鬼？

代码如下：

 1 public class Head {
 2     // 堆排序
 3     public static int[] headSort(int[] arr) {
 4         int n = arr.length;
 5         //构建大顶堆
 6         for (int i = (n - 2) / 2; i >= 0; i--) {
 7             downAdjust(arr, i, n - 1);
 8         }
 9         //进行堆排序
10         for (int i = n - 1; i >= 1; i--) {
11             // 把堆顶元素与最后一个元素交换
12             int temp = arr[i];
13             arr[i] = arr[0];
14             arr[0] = temp;
15             // 把打乱的堆进行调整，恢复堆的特性
16             downAdjust(arr, 0, i - 1);
17         }
18         return arr;
19     }
20 
21         //下沉操作
22     public static void downAdjust(int[] arr, int parent, int n) {
23         //临时保存要下沉的元素
24         int temp = arr[parent];
25         //定位左孩子节点的位置
26         int child = 2 * parent + 1;
27         //开始下沉
28         while (child <= n) {
29             // 如果右孩子节点比左孩子大，则定位到右孩子
30             if(child + 1 <= n && arr[child] < arr[child + 1])
31                 child++;
32             // 如果孩子节点小于或等于父节点，则下沉结束
33             if (arr[child] <= temp ) break;
34             // 父节点进行下沉
35             arr[parent] = arr[child];
36             parent = child;
37             child = 2 * parent + 1;
38         }
39         arr[parent] = temp;
40     }
41 }

性质：1、时间复杂度：O(nlogn) 2、空间复杂度：O(1) 3、非稳定排序 4、原地排序

8、计数排序

计数排序是一种适合于最大值和最小值的差值不是不是很大的排序。

基本思想：就是把数组元素作为数组的下标，然后用一个临时数组统计该元素出现的次数，例如 temp[i] = m, 表示元素 i 一共出现了 m 次。最后再把临时数组统计的数据从小到大汇总起来，此时汇总起来是数据是有序的。

为方便理解我还准备了动图：

如果还是不懂的话我还给你准备了优质的文章讲解：什么是计数排序？

代码如下：

 1 public class Counting {
 2     public static int[] countSort(int[] arr) {
 3         if(arr == null || arr.length < 2) return arr;
 4 
 5         int n = arr.length;
 6         int max = arr[0];
 7         // 寻找数组的最大值
 8         for (int i = 1; i < n; i++) {
 9             if(max < arr[i])
10                 max = arr[i];
11         }
12         //创建大小为max的临时数组
13         int[] temp = new int[max + 1];
14         //统计元素i出现的次数
15         for (int i = 0; i < n; i++) {
16             temp[arr[i]]++;
17         }
18         int k = 0;
19         //把临时数组统计好的数据汇总到原数组
20         for (int i = 0; i <= max; i++) {
21             for (int j = temp[i]; j > 0; j--) {
22                 arr[k++] = i;
23             }
24         }
25         return arr;
26     }
27 }

性质：1、时间复杂度：O(n+k) 2、空间复杂度：O(k) 3、稳定排序 4、非原地排序

注：K表示临时数组的大小，下同

优化一下

上面的代码中，我们是根据 max 的大小来创建对应大小的数组，假如原数组只有10个元素，并且最小值为 min = 10000，最大值为 max = 10005，那我们创建 10005 + 1 大小的数组不是很吃亏，最大值与最小值的差值为 5，所以我们创建大小为6的临时数组就可以了。

也就是说，我们创建的临时数组大小 (max - min + 1)就可以了，然后在把 min作为偏移量。优化之后的代码如下所示：

 1 public class Counting {
 2     public static int[] sort(int[] arr) {
 3         if(arr == null || arr.length < 2) return arr;
 4 
 5         int n = arr.length;
 6         int min = arr[0];
 7         int max = arr[0];
 8         // 寻找数组的最大值与最小值
 9         for (int i = 1; i < n; i++) {
10             if(max < arr[i])
11                 max = arr[i];
12             if(min > arr[i])
13                 min = arr[i];
14         }
15         int d = max - min + 1;
16         //创建大小为max的临时数组
17         int[] temp = new int[d];
18         //统计元素i出现的次数
19         for (int i = 0; i < n; i++) {
20             temp[arr[i] - min]++;
21         }
22         int k = 0;
23         //把临时数组统计好的数据汇总到原数组
24         for (int i = 0; i < d; i++) {
25             for (int j = temp[i]; j > 0; j--) {
26                 arr[k++] = i + min;
27             }
28         }
29         return arr;
30     }
31 }

9、桶排序

桶排序就是把最大值和最小值之间的数进行瓜分，例如分成 10 个区间，10个区间对应10个桶，我们把各元素放到对应区间的桶中去，再对每个桶中的数进行排序，可以采用归并排序，也可以采用快速排序之类的。

之后每个桶里面的数据就是有序的了，我们在进行合并汇总。

为方便理解我还准备了图片：

如果还是不懂的话我还给你准备了优质的文章讲解：什么是桶排序？

代码如下：

 1 public class BucketSort {
 2     public static int[] BucketSort(int[] arr) {
 3         if(arr == null || arr.length < 2) return arr;
 4 
 5         int n = arr.length;
 6         int max = arr[0];
 7         int min = arr[0];
 8         // 寻找数组的最大值与最小值
 9         for (int i = 1; i < n; i++) {
10             if(min > arr[i])
11                 min = arr[i];
12             if(max < arr[i])
13                 max = arr[i];
14         }
15         //和优化版本的计数排序一样，弄一个大小为 min 的偏移值
16         int d = max - min;
17         //创建 d / 5 + 1 个桶，第 i 桶存放  5*i ~ 5*i+5-1范围的数
18         int bucketNum = d / 5 + 1;
19         ArrayList<LinkedList<Integer>> bucketList = new ArrayList<>(bucketNum);
20         //初始化桶
21         for (int i = 0; i < bucketNum; i++) {
22             bucketList.add(new LinkedList<Integer>());
23         }
24         //遍历原数组，将每个元素放入桶中
25         for (int i = 0; i < n; i++) {
26             bucketList.get((arr[i]-min)/d).add(arr[i] - min);
27         }
28         //对桶内的元素进行排序，我这里采用系统自带的排序工具
29         for (int i = 0; i < bucketNum; i++) {
30             Collections.sort(bucketList.get(i));
31         }
32         //把每个桶排序好的数据进行合并汇总放回原数组
33         int k = 0;
34         for (int i = 0; i < bucketNum; i++) {
35             for (Integer t : bucketList.get(i)) {
36                 arr[k++] = t + min;
37             }
38         }
39         return arr;
40     }
41 }

性质：1、时间复杂度：O(n+k) 2、空间复杂度：O(n+k) 3、稳定排序 4、非原地排序

注：k 表示桶的个数，下同

10、基数排序

基数排序的排序思路是这样的：先以个位数的大小来对数据进行排序，接着以十位数的大小来多数进行排序，接着以百位数的大小……

排到最后，就是一组有序的元素了。不过，他在以某位数进行排序的时候，是用“桶”来排序的。

由于某位数（个位/十位….，不是一整个数）的大小范围为0-9，所以我们需要10个桶，然后把具有相同数值的数放进同一个桶里，之后再把桶里的数按照0号桶到9号桶的顺序取出来，这样一趟下来，按照某位数的排序就完成了

为方便理解我还准备了动图：

如果还是不懂的话我还给你准备了优质的文章讲解：为什么说O(n)复杂度的基数排序没有快速排序快？

代码如下：

 1 public class RadioSort {
 2     public static int[] radioSort(int[] arr) {
 3         if(arr == null || arr.length < 2) return arr;
 4 
 5         int n = arr.length;
 6         int max = arr[0];
 7         // 找出最大值
 8         for (int i = 1; i < n; i++) {
 9             if(max < arr[i]) max = arr[i];
10         }
11         // 计算最大值是几位数
12         int num = 1;
13         while (max / 10 > 0) {
14             num++;
15             max = max / 10;
16         }
17         // 创建10个桶
18         ArrayList<LinkedList<Integer>> bucketList = new ArrayList<>(10);
19         //初始化桶
20         for (int i = 0; i < 10; i++) {
21             bucketList.add(new LinkedList<Integer>());
22         }
23         // 进行每一趟的排序，从个位数开始排
24         for (int i = 1; i <= num; i++) {
25             for (int j = 0; j < n; j++) {
26                 // 获取每个数最后第 i 位是数组
27                 int radio = (arr[j] / (int)Math.pow(10,i-1)) % 10;
28                 //放进对应的桶里
29                 bucketList.get(radio).add(arr[j]);
30             }
31             //合并放回原数组
32             int k = 0;
33             for (int j = 0; j < 10; j++) {
34                 for (Integer t : bucketList.get(j)) {
35                     arr[k++] = t;
36                 }
37                 //取出来合并了之后把桶清光数据
38                 bucketList.get(j).clear();
39             }
40         }
41         return arr;
42     }
43 }

性质：1、时间复杂度：O(kn) 2、空间复杂度：O(n+k) 3、稳定排序 4、非原地排序

总结

用一张图汇总了10大排序算法的性质

如果你是复习/学习十大排序算法，一定要自己不看示例代码手动实现一遍，一定要自己不看示例代码手动实现一遍，一定要自己不看示例代码手动实现一遍。

本文转自《必学十大经典排序算法，看这篇就够了(附完整代码/动图/优质文章)》

posted on 2020-10-31 15:11 秦羽的思考阅读(186) 评论(0) 编辑收藏举报

数据结构和算法-排序算法(一)

超详细十大经典排序算法总结（java代码）

0、排序算法说明

1、冒泡排序（Bubble Sort）

2、选择排序（Selection Sort）

3、插入排序（Insertion Sort）

4、希尔排序（Shell Sort）

5、归并排序（Merge Sort）

6、快速排序（Quick Sort）

7、堆排序（Heap Sort）

8、计数排序（Counting Sort）

9、桶排序（Bucket Sort）

10、基数排序（Radix Sort）

十大经典排序算法

前言说明

术语解释

十大排序

1、选择排序

2、插入排序

3、冒泡排序

4、希尔排序（插入排序的变种）

5、归并排序

6、快速排序

7、堆排序

8、计数排序

9、桶排序

10、基数排序

总结

搜索

常用链接

我的标签

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论