数据结构与算法(四) - 十大排序算法

本文介绍了十大排序算法,包括冒泡排序、快速排序、选择排序、归并排序、插入排序、希尔排序、计数排序、桶排序、基数排序和堆排序。其中,冒泡排序、插入排序和选择排序的时间复杂度为O(n^2),归并排序和快速排序平均时间复杂度为O(nlogn),而计数排序、桶排序和基数排序可以在特定条件下达到线性时间复杂度。堆排序是基于比较的排序,时间复杂度为O(nlogn),但不是稳定的排序算法。文章还探讨了各种排序算法的空间复杂度和稳定性,并提供了部分算法的代码实现。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

数据结构与算法(四) - 排序算法

1. 概述

评判排序算法好坏的标准,之后算法性能评判的都在此基础之上进行:

  • 时间复杂度:分析算法的时间复杂度时要分别给出最好情况、最坏情况、平均情况下的时复杂度。在对同一阶时间复杂度的排序算法性能对比时,我们要把系数、常数、低阶也考虑进来。
  • 空间复杂度:简单理解为算法的内存消耗,引入另一个概念**in-placeout-place**。in-place,原地排序,指空间复杂度为O(1)的排序算法,只占用常数内存;out-place,非原地排序,算法需要占用额外内存。
  • 算法稳定性:如果待排序的序列中存在值相等的元素,结果排序之后,相等元素之间原有的先后顺序不变。例如3,7,2,7,8排序之后为2,3,7,7,8其中两个7的先后次序没有发生变化则称该算法是文档的排序算法。(一般会优先选择具有稳定性的算法

在这里插入图片描述

冒泡、选择、插入、归并、快速、希尔、堆排序,都是基于比较的排序,平均时间复杂度最低是O(nlogn)。

计数排序、桶排序、基数排序,都不是基于比较的排序,它们是典型的用空间换时间,在某些时候,平均时间复杂度可以比O(nlogn)更低。


2. 冒泡排序

从待排序序列的第一个元素开始,依次比较相邻元素的值,发现不满足大小关系则交换,将值较大的元素逐渐从前向后移动。每一次冒泡会让至少一个元素移动到它应该在的位置上。

在这里插入图片描述

coding:

public int[] bubbleSort(int[] arr){
   
    for (int i = 0; i < arr.length; i++) {
   
        //相临元素的比较
        for (int j = 0; j < arr.length - 1 - i; j++) {
   
            if (arr[j] > arr[j + 1]) {
   
                int tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
    }
    return arr;
}

优化:如果某次排序中没有发生交换,则可以结束排序

public int[] bubbleSort(int[] arr){
   
    for (int i = 0; i < arr.length; i++) {
   
        boolean flag = true;
        //相临元素的比较
        for (int j = 0; j < arr.length - 1 - i; j++) {
   
            if (arr[j] > arr[j + 1]) {
   
                int tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
                flag = false;//说明要排序
            }
        }
        if(flag) return arr;//说明此时数据已经有序 直接返回即可
    }
    return arr;
}

1.时间复杂度

最好情况下数据已经有序,只需要进行一次冒泡操作,就可以结束。冒泡排序最好的时间复杂度是O(n)。而最坏的情况就是所有数据刚好倒序与目的顺序,就需要进行n次冒泡排序,最坏的时间复杂度为O(n*n)

2.空间复杂度

过程中只涉及相邻数据的交换,只需要常量级的临时空间,空间复杂度为O(1),是in-place排序算法。

3.是否为稳定排序算法

冒泡排序在相邻数据相同时我们不做交换,则属于稳定排序算法。(可修改)


3. 快速排序

快速排序简称快排,是对冒泡排序的一种改进,利用分治思想。基本思想是:选择一个数作为 基准点(我选的最后一个数),通过一趟排序将要排序的数据分割成独立的三部分,其中 左部分 的所有数据都比 基准点 的数据小,基准点的数据比 右部分 的所有数据都要小,然后再按此方法对这左右两部分数据分别进行快速排序,直到左右数据长度为1时结束。整个排序过程可以递归进行,以此达到整个数据变成有序序列。

在这里插入图片描述

coding:

public int[] quickSort(int[] arr, int start, int end) {
   
   if (start < end) {
   //这是必须一开始就判断是的点!!!
       int left = start, right = end, datum = arr[start];
       //实现
       while (left < right) {
   
           //右边数大于或等于基准点 指针左移一
           while (left < right && arr[right] >= datum) right--;
           //右边数组小于基准点 放在左边去
           arr[left] = arr[right];
           left++;
           //左边数小于基准点 指针右移一
           while (left < right && arr[left] < datum) left++;
           //左边数大于或等于基准点 放到右边
           arr[right] = arr[left];
           right--;
       }
       //一趟循环结束 此时left=right 将基准点数据载入
       arr[left] = datum;
       //分治递归
       quickSort(arr, start, left - 1);
       quickSort(arr, left + 1, end);
   }
   return arr;
}

1.时间复杂度

最好时间复杂和平均时间复杂度为O(nlogn),极端情况下为O(n^2)

2.空间复杂度

不需要额外空间,所以空间复杂度是O(n),in-place原地排序算法。

3.是否为稳定排序算法

分区后,我们使用的策略是如果两个数据相同也可能会会交换,所以快速排序不是一个稳定的排序算法


4. 选择排序

分为已排序区间未排序区间。已排序区间初始为空。每次排序会从 未排序区间 找到最小的元素,将其放到 已排序区间 末尾,实现升序,降序反之。

在这里插入图片描述

基本思想:

第一次从 arr[0]~arr[n-1]中选取最小值,与 arr[0]交换
第二次从 arr[1]~arr[n-1]中选取最小值,与 arr[1]交换
第三次从 arr[2]~arr[n-1]中选取最小值,与 arr[2] 交换
第 i 次从 arr[i-1]~arr[n-1]中选取最小值,与 arr[i-1]交换
第 n-1 次从 arr[n-2]~arr[n-1]中选取最小值,与 arr[n-2]交换

总共通过 n-1 次,得到一个按排序码从小到大排列的有序序列。coding:

public int[] selectSort(int[] arr){
   
    for (int i = 0; i < arr
评论 4
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值