排序算法总结

最新推荐文章于 2025-04-25 22:24:52 发布

JeffCoding

最新推荐文章于 2025-04-25 22:24:52 发布

阅读量435

点赞数

分类专栏：算法与数据结构基础文章标签：排序算法

算法与数据结构基础专栏收录该内容

23 篇文章

订阅专栏

这里写图片描述

排序算法	时间复杂度	空间复杂度	是否稳定
计数排序	O(N+K)	O(N+K)	稳定排序
基数排序	O(N)	O(N)	稳定排序
桶排序	O(N+K)	O(N+K)	稳定排序

N为排序的数组大小，K为查找的整数范围

一、插入排序

原理

遍历当前数组，不断比较当前下标和旁边值，小的往左移动

1. 时间复杂度

最好的情况下：正序有序(从小到大)，这样只需要比较n次，不需要移动。因此时间复杂度为O(n)
最坏的情况下：逆序有序,这样每一个元素就需要比较n次，共有n个元素，因此实际复杂度为O(n2)
平均情况下：O(n2)

2. 稳定性

稳定
在插入排序中，K1是已排序部分中的元素，当K2和K1比较时，直接插到K1的后面(没有必要插到K1的前面，这样做还需要移动！！)，因此，插入排序是稳定的。

3. 代码

public class InsertSort {

    static int[] array = new int[]{9, 1, 5, 8, 3, 7, 4, 6, 2};

    public static void sort() {
        for (int i = 1; i < array.length; i++) {
            //如果数据基本有序，这里的判断基本不会进入，此时On
            while (i > 0 && array[i] < array[i - 1]) {
                swap(i, i - 1);
                i--;
            }
        }
    }

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

    public static void swap2(int i, int j) {
        int tmp = array[i] ^ array[j];
        array[i] = array[i] ^ tmp;
        array[j] = array[j] ^ tmp;
    }

    public static void main(String[] args) {
        sort();
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

二、希尔排序

1. 时间复杂度。

最好情况：由于希尔排序的好坏和步长d的选择有很多关系，因此，目前还没有得出最好的步长如何选择(现在有些比较好的选择了，但不确定是否是最好的)。
一般来说，时间复杂度跟步长的选择有关，是通过数学推论出来的，可能是O(logn)或者是O(n^1.3)

2. 稳定性

不稳定
由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以shell排序是不稳定的。(有个猜测，方便记忆：一般来说，若存在不相邻元素间交换，则很可能是不稳定的排序。)

三、冒泡排序

1. 时间复杂度

最好情况下：正序有序，则只需要比较n次。故，为O(n)
最坏情况下: 逆序有序，则需要比较(n-1)+(n-2)+……+1，故，为O(N*N)

2. 稳定性

稳定
排序过程中只交换相邻两个元素的位置。因此，当两个数相等时，是没必要交换两个数的位置的。所以，它们的相对位置并没有改变，冒泡排序算法是稳定的！

四、快速排序

1. 算法复杂度

最好的情况下：因为每次都将序列分为两个部分(一般二分都复杂度都和logN相关)，故为 O(N*logN)
最坏的情况下：基本有序（正序或者反序）时，退化为冒泡排序，几乎要比较N*N次，故为O(N*N)

2. 稳定性

不稳定
由于每次都需要和中轴元素交换，因此原来的顺序就可能被打乱。如序列为 5 3 3 4 3 8 9 10 11会将3的顺序打乱。所以说，快速排序是不稳定的！

3. 空间复杂度

由于递归造成栈空间的使用，递归树的深度为logn，所以空间复杂度也为logn，最坏情况，需要进行n-1次递归，所以空间复杂度为O(n)

五、直接选择排序

原理

第一次遍历，找出最小的值交换到数组第一个位置；
第二次遍历，找出从第2个位置到最后，最小的值交换到数组的第二个位置；
……..

1. 时间复杂度

最好情况下：交换0次，但是每次都要找到最小的元素，因此大约必须遍历N*N次，因此为O(N*N)。减少了交换次数！
最坏情况下：平均情况下：O(N*N)

2. 稳定性

不稳定
由于每次都是选取未排序序列A中的最小元素x与A中的第一个元素交换，因此跨距离了，很可能破坏了元素间的相对位置，因此选择排序是不稳定的！

3. 代码

public static void sort() {
        int min;
        //i记录当前要插入的位置
        for (int i = 0; i < array.length; i++) {
            min = i;
            //找出当前最小的值的下标
            for (int j = i+1; j < array.length; j++) {
                if (array[min] > array[j]) {
                    min = j;
                }
            }

            if (min != i) {
                swap(i, min);
            }
        }
    }

六、堆排序

1. 算法复杂度

最坏情况下，接近于最差情况下：O(N*logN)，因此它是一种效果不错的排序算法。

2. 稳定性

堆排序需要不断地调整堆，因此它是一种不稳定的排序！

七、归并排序

1. 算法时间复杂度

最好的情况下：一趟归并需要n次，总共需要logN次，因此为O(N*logN)
最坏的情况下，接近于平均情况下，为O(N*logN)
说明：对长度为n的文件，需进行logN 趟二路归并，每趟归并的时间为O(n)，故其时间复杂度无论是在最好情况下还是在最坏情况下均是O(nlgn)。

2. 稳定性

稳定
归并排序最大的特色就是它是一种稳定的排序算法。归并过程中是不会改变元素的相对位置的

3. 空间复杂度

需要用到一个n大小的辅助数组，所以空间复杂度为O(n)

八、基数排序

1. 算法的时间复杂度

分配需要O(n),收集为O(r),其中r为分配后链表的个数，以r=10为例，则有0～9这样10个链表来将原来的序列分类。而d，也就是位数(如最大的数是1234，位数是4，则d=4)，即”分配-收集”的趟数。因此时间复杂度为O(d*(n+r))。

2. 稳定性

稳定
基数排序过程中不改变元素的相对位置，因此是稳定的！

排序算法使用场景总结

(1)若n较小(如n≤50)，可采用直接插入或直接选择排序。
　当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直接插人，应选直接选择排序为宜。
(2)若数据基本有序(指正序)，则应选用直接插人、冒泡；
(3)若n较大，则应采用时间复杂度为O(nlgn)的排序方法：快速排序、堆排序或归并排序。
　快速排序是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；
　堆排序所需的辅助空间少于快速排序，并且不会出现快速排序可能出现的最坏情况。这两种排序都是不稳定的。
　若要求排序稳定，则可选用归并排序。

转自：
http://blog.youkuaiyun.com/whuslei/article/details/6442755