排序算法

最新推荐文章于 2023-07-05 09:31:50 发布

HHozi

最新推荐文章于 2023-07-05 09:31:50 发布

阅读量82

点赞数 1

分类专栏：数据结构与算法

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

17 篇文章 0 订阅

订阅专栏

在这里插入图片描述
原地排序：在排序过程中不申请多余的存储空间，只利用原来存储待排数据的存储空间进行比较和交换的数据排序。即空间复杂度是O(1)
O(n²)的执行时间不一定比O(nlogn)长。因为算理论上的时间复杂度时，忽略了低阶，常数。
所以在执行数据量少的情况，可以使用不需要递归的插入排序。

1、冒泡排序
优化：当某次冒泡操作无数据交换时，可以认为已经有序了
最好情况：O(n)；
最坏情况：O(n²)
平均情况下的时间复杂度是 O(n²)
有序度：n*(n-1)/2
逆序度：逆序度=满有序度-有序度
移动操作的次数是固定的，就等于逆序度。

2、选择排序
最好情况：O(n)；
最坏情况：O(n²)
平均情况下的时间复杂度是 O(n²)
原地排序：空间复杂度是O(1)
不稳定（稍微逊色）

3、插入排序
最好情况：O(n)；
最坏情况：O(n²)
平均情况下的时间复杂度是 O(n²)
原地排序：空间复杂度是O(1)

    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];//大于current的右移一位
                preIndex--;
            }
            array[preIndex +1 ] = current;
        }
        return array;
    }

所以这三种排序算法中，最优的应该是插入排序。

4、希尔排序
选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
按增量序列个数k，对序列进行k 趟排序；
每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
在这里插入图片描述

5、归并排序(递归)
把长度为n的输入序列分成两个长度为n/2的子序列；
对这两个子序列分别采用归并排序；
将两个排序好的子序列合并成一个最终的排序序列。
时间复杂度是O(nlogn)
空间复杂度是O(n)（所以应用并不广泛）

在这里插入图片描述
我们假设对 n 个元素进行归并排序需要的时间是 T(n)，那分解成两个子数组排序的时间都是T(n/2)。我们知道，merge()函数合并两个有序子数组的时间复杂度是O(n)。所以，套用前面的公式，归并排序的时间复杂度计算公式是：
在这里插入图片描述

6、快速排序
不稳定
时间复杂度是O(nlogn)
极端情况下，时间复杂度是O(n²)(分区点的选择不够合理)
选择分区点的方法：
1/三数取中法，取中间值。
2/随机法

分治和分区思想
从数列中挑出一个元素，称为 “基准”（pivot）；
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

    public static void quickSort2(int[] arr,int low,int high){
        int i,j,temp,t;
        if(low>high){
            return;
        }
        i = low;
        j = high;
        //temp为基准位
        temp = arr[low];
        while(i<j){
            //一定要先看右边，一次往左递减
            //哪边开始，得先看选取得位置，选了左边为基数，就要在右边先开始。2 1 4 9；如果选了左边先开始会 2 1 9 4
            while(temp<=arr[j]&&i<j){
                j--;
            }
            //再看左边，依次往右递增
            while(temp>=arr[i]&&i<j){
                i++;
            }
            //如果满足条件就交换
            if(i<j){
                t = arr[j];
                arr[j] = arr[i];
                arr[i] = t;
            }
        }
        //最后将基准为i和j相等位置的数字交换
        arr[low] = arr[i];
        arr[i] = temp;
        //递归左边数组
        quickSort2(arr,low,j-1);
        //递归右边数组
        quickSort2(arr,j+1,high);
    }

7、堆排序
将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

8、计数排序
只能用于数据范围不大的场景中，如果数据范围k比要排序的数据n大很多，就不适用于计数排序，且只能用于非负的情况。
找出待排序的数组中最大和最小的元素；
统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。
在这里插入图片描述

    public void countingSort(int[] arr){
        int length = arr.length;
        int max = arr[0];
        for(int i = 1;i<length;i++){
            if (max<arr[i]){
                max = arr[i];       
            }
        }
        //开辟空间
        int[] c = new int[max+1];
        //依次放入
        for(int i = 0;i<length;i++){
            c[arr[i]]++;
        }
        //累加
        for(int i = 1;i<c.length;i++){
            c[i] = c[i]+c[i-1];
        }
        //创一个空间放入数组
        int[] r = new int[length];
        //反向遍历
        for(int i = length-1;i>=0;i--){
            int index = c[arr[i]]-1;
            r[index] = arr[i];
            c[arr[i]]--;
        }
        //放回数组
        for(int i =0;i<length;i++){
            arr[i] = r[i];
        }
    }

9、桶排序（适用再外部排序中）
人为设置一个BucketSize，作为每个桶所能放置多少个不同数值（例如当BucketSize==5时，该桶可以存放｛1,2,3,4,5｝这几种数字，但是容量不限，即可以存放100个3）；
遍历输入数据，并且把数据一个一个放到对应的桶里去；
对每个不是空的桶进行排序，可以使用其它排序方法，也可以递归使用桶排序；
从不是空的桶里把排好序的数据拼接起来。
注意，如果递归使用桶排序为各个桶排序，则当桶数量为1时要手动减小BucketSize增加下一循环桶的数量，否则会陷入死循环，导致内存溢出。
在这里插入图片描述

10、基数排序
取得数组中的最大数，并取得位数；
arr为原始数组，从最低位开始取每个位组成radix数组；
对radix进行计数排序（利用计数排序适用于小范围数的特点）；

举例：
Glibc中的qsort()算法：
1.优先使用归并排序（数据量少的话）
2.快速排序–三数取中法（数据量大的话）
3.插入排序(数据量少于4)

Arrays.sort()
主要采用TimSort算法, 大致思路是这样的：
1 元素个数 < 32, 采用二分查找插入排序(Binary Sort)
2 元素个数 >= 32, 采用归并排序，归并的核心是分区(Run)
3 找连续升或降的序列作为分区，分区最终被调整为升序后压入栈
4 如果分区长度太小，通过二分插入排序扩充分区长度到分区最小阙值
5 每次压入栈，都要检查栈内已存在的分区是否满足合并条件，满足则进行合并
6 最终栈内的分区被全部合并，得到一个排序好的数组

Timsort的合并算法非常巧妙：
1 找出左分区最后一个元素(最大)及在右分区的位置
2 找出右分区第一个元素(最小)及在左分区的位置
3 仅对这两个位置之间的元素进行合并，之外的元素本身就是有序的