十大排序算法总结 # 待完善

于 2021-08-06 11:09:08 发布
阅读量273 收藏
点赞数
分类专栏： 面试算法题 文章标签： java 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AudreyQCb/article/details/119449817
版权

先提前约定交换函数：

protected void swap(int[] nums, int i, int j){
    int temp = nums[i];
    nums[i] = nums[j];
    nums[j] = temp;
}

一、选择排序

思路：

从数组中选择最小元素，将它与数组的第一个元素交换位置。再从数组剩下的元素中选择出最小的元素，将它与数组的第二个元素交换位置。

不断进行这样的操作，直到将整个数组排序。

复杂度：

n个元素，第一次排序需要比较n-1次，第二次排序需要比较n-2次，则总共需要 ~ n^2次比较

每一轮排序都是进行一次交换，所以选择排序需要 ~ n 次交换

特点：

选择排序的运行时间与输入无关，这个特点使得它对一个已经排序的数组也需要这么多的比较和交换操作。

选择排序的运行时间

代码：

public void sort(int[] nums){
    int N = nums.length;
    for(int i = 0; i < N - 1; i++){
        int min = i;
        for(int j = i+1; j<N;j++){
            if(num[j]<num[i]){
                min=j;
            }
        }
        swap(nums,i,min);
    }
}

二、冒泡排序

思路：

相邻元素两两比较，反序则交换，第一轮将最大元素浮到数组顶端，第二轮将第二大数组浮到第二个位置，直到没有任何一对数字需要比较

在一轮循环中，如果没有发生交换，那么说明数组已经是有序的，此时可以直接退出。

复杂度：

代码：

public static void bubbleSort(int[] arr){
    int N = arr.length;
    if(arr==null || N<2){
        return;
    }
 
    boolean isSorted = false;
    
    for(int i = N-1; i > 0&&!isSorted; end--){
        isSorted = true;
        // 如果该轮比较没有发生交换，则说明数组已经有序,isSorted变量为true不会设置为false，如果要发生交换，则会被设置为false
        for(int j=0; j<i; j++){
            if(arr[j] > arr[j+1]){
                isSorted = false;
                swap(arr, j, j+1);
            }
        }
    }

}

三、插入排序

思路：

将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。

从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

复杂度：

对于数组{3，5，2，4，1}， 它具有以下逆序：(3,2), (3,1), (5,2), (5,4), (5,1), (2,1), (4,1), 插入排序每次只能交换相邻元素，令逆序数量减少1。每交换一次，逆序数量少一个，因此插入排序需要交换的次数为逆序数量。

插入排序的时间复杂度取决于数组的初始顺序，如果数组已经部分有序了，那么逆序较少，需要的交换次数也就较少，时间复杂度较低。

数组顺序即最好的情况下需要N-1次比较， 0 次交换

数组倒序即最差的情况下需要 ~ N^2 / 2次比较以及 ~ N^2/2次交换

平均情况下插入排序需要 ~ N^2/4比较以及 N^2/4次交换

代码：

public void sort(int nums){
    int N = nums.length;
    for(int i=1;i<N;i++){
        for(int j=i; j>0; j--){
            if(nums[j]<nums[j-1]){
                swap(nums, j, j-1);
            }
        }
    }
}

四、希尔排序

对于大规模的数组，插入排序很慢，因为它只能交换相邻的元素，每次只能将逆序数量减少1。

希尔排序的出现就是为了解决插入排序的上述局限性。希尔排序也称递减增量排序算法，它通过交换不相邻的元素，每次可以将逆序数量减少大于1.（因为当两个元素间隔较远时，一次交换可能会减少2个以上的逆序数，进而减少了交换次数）

思路:

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序时”，再对全体记录进行依次直接插入排序。

希尔排序使用插入排序对间隔h的序列进行排序。通过不断减小h，最后令h=1，就可以使得整个数组是有序的。

希尔排序的递增序列？

代码：

public void sort(int[] nums){
    int N = nums.length;
    int h = 1;
    
    // 1. 选择一个增量序列序列
    while(h < N/3){
        h = 3*h + 1; //1,4,13,40...
    }
    
    // 2. 按增量序列个数k，对序列进行k趟排序
    while(h>=1){
        // 3. 
        for(int i=h; i< N; i++){
            for(int j=i; j>=h;  j-=h){
                if(nums[j]<nums[j-h]){
                    swap(nums, j, j-h);
                }
            }
            h = h/3;
        }
    }
}

五、归并排序

该算法采用分治法，采用分而治之的思想。归并排序的思想是将数组分成两部分，分别进行排序，然后归并起来。

归并排序的实现有两种方法：

  • 自上而下的递归
  • 自下而上的迭代

和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好，因为每次都将问题对半分成两个子问题，这种对半分的算法复杂度一般为 O(NlogN) （推导可参考： 公式法求递归算法的时间复杂度_Victor_Gui的博客-CSDN博客_递归时间复杂度计算公式）

1. 归并方法

归并方法将数组中两个已经排序的部分归并成一个

  • 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；
  • 设定两个指针，最初位置分别为两个已经排序序列的起始位置；
  • 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；
  • 重复步骤 3 直到某一指针达到序列尾；
  • 将另一序列剩下的所有元素直接复制到合并序列尾。
// 归并方法将数组中两个已经排序的部分归并成一个
public abstract class MergeSort<T extends Comparable<T>> extends Sort<T> {

    protected T[] aux;


    protected void merge(T[] nums, int l, int m, int h) {

        int i = l, j = m + 1;

        for (int k = l; k <= h; k++) {
            aux[k] = nums[k]; // 将数据复制到辅助数组
        }

        for (int k = l; k <= h; k++) {
            if (i > m) {
                nums[k] = aux[j++];

            } else if (j > h) {
                nums[k] = aux[i++];

            } else if (aux[i].compareTo(aux[j]) <= 0) {
                nums[k] = aux[i++]; // 先进行这一步，保证稳定性

            } else {
                nums[k] = aux[j++];
            }
        }
    }
}

2. 自顶向下归并排序

将一个大数组分成两个小数组去求解

因为每次都将问题对半分成两个子问题，这种对半分的算法复杂度一般为O(NlogN)。

public class Up2DownMergeSort<T extends Comparable<T>> extends MergeSort<T> {

    @Override
    public void sort(T[] nums) {
        aux = (T[]) new Comparable[nums.length];
        sort(nums, 0, nums.length - 1);
    }

    private void sort(T[] nums, int l, int h) {
        if (h <= l) {
            return;
        }
        int mid = l + (h - l) / 2;
        sort(nums, l, mid);
        sort(nums, mid + 1, h);
        merge(nums, l, mid, h);
    }
}

3. 自底向上归并排序

先归并那些微型数组，然后成对归并得到的微型数组。

public class Down2UpMergeSort<T extends Comparable<T>> extends MergeSort<T> {

    @Override
    public void sort(T[] nums) {

        int N = nums.length;
        aux = (T[]) new Comparable[N];

        for (int sz = 1; sz < N; sz += sz) {
            for (int lo = 0; lo < N - sz; lo += sz + sz) {
                merge(nums, lo, lo + sz - 1, Math.min(lo + sz + sz - 1, N - 1));
            }
        }
    }
}

六、快速排序

快速排序采用分治思想，本质上来看，快速排序应该算是在冒泡排序基础上的递归分治法。

算法步骤

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

分区操作

取 a[l] 作为切分元素，然后从数组的左端向右扫描直到找到第一个大于等于它的元素，再从数组的右端向左扫描找到第一个小于它的元素，交换这两个元素。

不断进行这个过程，就可以保证左指针 i 的左侧元素都不大于切分元素，右指针 j 的右侧元素都不小于切分元素。

当两个指针相遇时，将切分元素 a[l] 和 a[j] 交换位置。

private int partition(int nums, int l, int h){
    int i = l, j=h+1;
    int pivot = nums[l];
    while(true){
        while(nums[++i]< pivot && i!=h) ;
        while(nums[--j] > pivot && j!=l);
        
        if(i>=j) // 两指针相遇
            break;
        swap(nums, i,j);
    }
    swap(nums,l,j);
    return j;
}

基本操作

private void sort(int nums, int l, int h){
    if(h <= l)
        return;
    int j = partition(nums, l,h);
    sort(nums, l, j-1);
    sort(nums, j+1,h)
}

性能分析

快速排序是原地排序，不需要辅助数组，但是递归调用需要辅助栈。

快速排序最好的情况下是每次都正好将数组对半分，这样递归调用次数才是最少的。这种情况下比较次数为 CN=2CN/2+N，复杂度为 O(NlogN)。

最坏的情况下，第一次从最小的元素切分，第二次从第二小的元素切分，如此这般。因此最坏的情况下需要比较 N2/2。为了防止数组最开始就是有序的，在进行快速排序时需要随机打乱数组。

基于切分的快速选择算法

快速排序的partition（）方法，会返回一个整数j使得 a[l…j-1]小于等于a[j]， 且a[j+1…h]大于等于a[j], 此时a[j]就是数组的第j大元素。

可以利用这个特性找出数组的第k个元素。

public int select(int nums, int k){
    int l=0, h = nums.length-1;
    while(h > l){
        int j = partition(nums, l, h);
        
        if(j==k){
            return nums[k];
        }else if(j>k){
            h = j-1;
        }else{
            l = j+1;
        }
    }
    return nums[k];
}

七、堆排序

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。

堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法：

  • 大顶堆：每个节点的值都大于或等于子节点的值，在堆排序算法中用于升序排列
  • 小顶堆：每个节点的值都小于或等于子节点的值，在堆排序算法中用于降序排列

堆可以用数组来表示，这是因为堆是完全二叉树，而完全二叉树很容易就存储在数组中。

位置k的节点的父节点位置为 k/2，而它的两个子节点的位置分别为 2k+1和2k+2

上浮和下沉

在堆中，当一个节点比父节点大，那么需要交换这两个节点。交换后还可能比它新的父节点大，因此需要不断地进行比较和交换操作，这个过程称为上浮

类似地，当一个节点比子节点来得小，也需要不断地向下进行比较和交换操作，把这种操作称为下沉。

一个节点如果有两个子节点，应当与两个子节点中最大那个节点进行交换。下沉操作即在父节点、两个子节点这上个节点中重新选出最大节点作父节点，其余两个节点做子节点。

构建堆

无序数组建立堆最直接的方法是从左到右遍历数组进行上浮操作。一个更高效的方法是从右至左进行下沉操作。

如果一个节点的两个节点都已经是堆有序，那么进行下沉操作可以使得这个节点为根节点的堆有序。

叶子节点不需要进行下沉操作，可以忽略叶子节点元素，即从最后一个非叶子节点 N/2开始下沉，因此只需要遍历一半的元素即可。

public int[] HeapSort(int[] sourceArray) throws Exception{
    // 对arr进行拷贝，不改变参数内容
    int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
    
    int len = arr.length;
    
    buildMaxHeap(arr,len);
    
    for(int i = len-1; i>0; i--){
        // 交换堆顶元素（即最大元素）与最后一个元素
        swap(arr, 0, i);
        len--;
        // 交换之后需要继续进行下沉操作
        sink(arr,0,len);
    }
    return arr;
}
   
    
// 建堆
private void buildMaxHeap(int[] arr, int len){
    // 从最后一个非叶子节点开始不断下沉
    // 疑问：为什么这里的i不是从 n/2-1开始？
    for(int i = (int)Math.floor(len/2); i>=0; i--){
        sink(arr, i, len);
    }
}
    
// 下沉
private void sink(int[] arr, int i, int len){
    int left = 2*i +1;
    int right = 2*i +2;
    int largest = i;

    if(left<len && arr[left] > arr[largest]){
        largest = left;
    }

    if(right <len && arr[right] > arr[largest]){
        largest = right;
    }

    if(largest !=i){
        swap(arr, i, largest);
        // 元素变动的话得从变动元素位置继续下沉
        sink(arr, largest, len);
        }
    }

复杂度分析

一个堆的高度为 logN, 因此在堆中插入元素和删除最大元素的复杂度为logN(从顶到叶)。

对于堆排序，要对N个节点进行下沉操作，因此复杂度为 NlogN

堆排序的平均时间复杂度为 Ο(nlogn)。

比较排序

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

比较排序的优势：适用于各种规模的数据，也不在乎数据的分布，都能进行排序。

非比较排序

计数排序、基数排序、桶排序属于非比较排序。非比较排序是确定每个元素之前应该有多少个元素来排序。

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

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

计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。

作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。

计数排序的特征

当输入的元素是n个0到k之间的整数时，它的运行时间是O(n+k).

计数排序不是比较排序，排序的速度快于任何比较排序算法。

计数排序是用来排序0到100之间的数字的最好的算法，但是它不适合按字母顺序排序人名。

计数排序对于数据范围很大的数字，需要大量时间和内存，但是计数排序可以用在基数排序中的算法来排序数据范围很大的数组

计数排序的通俗理解：

假如有10个年龄不同的人，统计出有8个人的年龄比A小，那么A的年龄就排在第9位，用这个方法可以得到其他每个人的位置，也就排好了序

算法步骤：

  • （1）找出待排序的数组中最大和最小的元素
  • （2）统计数组中每个值为i的元素出现的次数，存入数组C的第i项
  • （3）对所有的计数累加（从C中第一个元素开始，每一项和前一项相加）
  • （4）反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1
public static int[] countSort(int[] arr){
    if(arr==null||arr.length==0){
        return null;
    }
    
    // 找出数组中的最大最小值
    for(int i=0;i<arr.length;i++){
        max = Math.max(max,arr[i]);
        min = Math.min(min,arr[i]);
    }
    
    //辅助数组，记录每个数对应的个数 help[i]记录数字i+min的个数
    int help[]=new int[max-min+1];
    
    //找出每个数字出现的次数
    for(int i=0;i<arr.length;i++){
        int mapPos = arr[i]-min;
        help[mapPos]++;
    }
    
    int index=0;
    for(int i=0;i<help.length;i++){
        while(help[i]-->0){
            arr[index++]=i+min;
        }
    }
    return arr;
}

九、桶排序

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

为了使桶排序更加高效，需要做到两点

    1. 在额外空间充足的情况下，尽量增大桶的数量
    2. 使用的映射函数能够将输入的N个数据均匀的分配搭配K个桶中

桶排序的基本思想

把数组arr划分为n个大小相同子区间（桶），每个子区间各自排序，最后合并。

计数排序是桶排序的一种特殊情况，可以把计数排序当成每个桶里只有一个元素的情况

算法步骤

  1. 找出待排序数组中的最大值max和最小值min

  2. 使用动态数组ArrayList存储桶，桶里放的元素也用ArrayList存储。

  3. 遍历数组arr，计算每个数组arr[i]放的桶

  4. 每个桶各自排序

  5. 遍历桶数组，把排序好的数组放进输出数组

public class BucketSort implements IArraySort {

    private static final InsertSort insertSort = new InsertSort();

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 对 arr 进行拷贝，不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        return bucketSort(arr, 5);
    }

    private int[] bucketSort(int[] arr, int bucketSize) throws Exception {
        if (arr.length == 0) {
            return arr;
        }

        int minValue = arr[0];
        int maxValue = arr[0];
        for (int value : arr) {
            if (value < minValue) {
                minValue = value;
            } else if (value > maxValue) {
                maxValue = value;
            }
        }

        int bucketCount = (int) Math.floor((maxValue - minValue) / bucketSize) + 1;
        int[][] buckets = new int[bucketCount][0];

        // 利用映射函数将数据分配到各个桶中
        for (int i = 0; i < arr.length; i++) {
            int index = (int) Math.floor((arr[i] - minValue) / bucketSize);
            buckets[index] = arrAppend(buckets[index], arr[i]);
        }

        int arrIndex = 0;
        for (int[] bucket : buckets) {
            if (bucket.length <= 0) {
                continue;
            }
            // 对每个桶进行排序，这里使用了插入排序
            bucket = insertSort.sort(bucket);
            for (int value : bucket) {
                arr[arrIndex++] = value;
            }
        }

        return arr;
    }

    /**
     * 自动扩容，并保存数据
     *
     * @param arr
     * @param value
     */
    private int[] arrAppend(int[] arr, int value) {
        arr = Arrays.copyOf(arr, arr.length + 1);
        arr[arr.length - 1] = value;
        return arr;
    }

}

十、基数排序

总结

在这里插入图片描述
在这里插入图片描述

  • In-place：占用常数内存，不占用额外内存
  • Out-place：占用额外内存
  • 稳定性：排序后 2 个相等键值的顺序和排序之前它们的顺序相同

快速排序是最快的通用排序算法，它的内循环的指令很少，而且它还能利用缓存，因为它总是顺序地访问数据。它的运行时间近似为 ~ cNlogN, 这里的c比其他线性对数级别的排序算法都要小。

Java主要排序方法为 java.util.Arrays.sort(),对于原始数据类型使用三向切分的快速排序，对于引用类型使用归并排序。

# 参考

快乐小谯
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值