经典排序算法Python实现

本文深入讲解了冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序及希尔排序等七种经典排序算法的原理、步骤及Python实现。通过对比分析,帮助读者全面理解各种排序算法的特点。

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

经典排序算法在面试中占有很大的比重,也是基础。
本篇博客所有排序实现均默认从小到大。

1.冒泡排序 BubbleSort

冒泡排序的原理非常简单,它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。

步骤:

  1. 比较相邻的元素。如果第一个比第二个大,就交换他们两个。
  2. 对第0个到第n-1个数据做同样的工作。这时,最大的数就“浮”到了数组最后的位置上。
  3. 针对所有的元素重复以上的步骤,除了最后一个。
  4. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

实现:

def bubble_sort(array):
    for i in range(len(array)):    #共需要遍历len(array)-1次
        for j in range(len(array)-1):
            if array[j] > array[j+1]:
                array[j],array[j+1] = array[j+1],array[j]
                
array = [5,2,7,1,8,3,4,6,9,0]
bubble_sort(array)

2.选择排序 SelectionSort

步骤:

  1. 在未排序序列中找到最小(大)元素,存放到排序序列的起始位置。
  2. 再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。
  3. 以此类推,直到所有元素均排序完毕。

实现:

def select_sort(array):
    for i in range(0, len(array)):
        min = i    #记录最小值的下标
        for j in range(i+1, len(array)):
            if array[j] < array[min]:
                min = j
        array[i], array[min] = array[min], array[i]
        print(array)
        
array = [5,2,7,1,8,3,4,6,9,0]
select_sort(array)

3.插入排序 InsertionSort

插入排序的工作原理是,对于每个未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。

步骤:

  1. 从第一个元素开始,该元素可以认为已经被排序
  2. 取出下一个元素,在已经排序的元素序列中从后向前扫描
  3. 如果被扫描的元素(已排序)大于新元素,将该元素后移一位
  4. 重复步骤3,直到找到已排序的元素小于或者等于新元素的位置
  5. 将新元素插入到该位置后
  6. 重复步骤2~5

在这里插入图片描述
实现:

 def insert_sort(array):
    for i in range(1, len(array)):
        current = array[i]
        index = i
        while index >= 1:
            if array[index-1] > current:
                array[index] = array[index-1]
                index -= 1
            else:
                break
        array[index] = current
        
array = [5,2,7,1,8,3,4,6,9,0]
insert_sort(array)   
array

4.快速排序 QuickSort

快速排序通常明显比同为Ο(n log n)的其他算法更快,因此常被采用,而且快排采用了分治法的思想。

步骤:

  1. 从数列中挑出一个元素作为基准数。
  2. 分区过程,将比基准数大的放到右边,小于或等于它的数都放到左边。
  3. 再对左右区间递归执行第二步,直至各区间只有一个数。

实现:

def quick_sort(array):
    return qsort(array, 0, len(array)-1)

def qsort(array, left_index, right_index):
    if left_index >= right_index:
        return array
    pivot = array[left_index]
    lp = left_index
    rp = right_index
    while lp < rp:
        while array[rp] >= pivot and lp < rp:
            rp -= 1
        while array[lp] <= pivot and lp < rp:
            lp += 1
        array[lp], array[rp] = array[rp], array[lp]
    array[left_index], array[lp] = array[lp], array[left_index]
    
    qsort(array, left_index, lp-1)
    qsort(array, lp+1, right_index)
    return array

array = [5,2,7,1,8,3,4,6,9,0]
quick_sort(array)
array

5.归并排序 MergeSort

步骤:
归并排序是采用分治法的一个非常典型的应用。归并排序的思想就是先递归分解数组,再合并数组。

先考虑合并两个有序数组,基本思路是比较两个数组的最前面的数,谁小就先取谁,取了后相应的指针就往后移一位。然后再比较,直至一个数组为空,最后把另一个数组的剩余部分复制过来即可。

再考虑递归分解,基本思路是将数组分解成left和right,如果这两个数组内部数据是有序的,那么就可以用上面合并数组的方法将这两个数组合并排序。如何让这两个数组内部是有序的?可以再二分,直至分解出的小组只含有一个元素时为止,此时认为该小组内部已有序。然后合并排序相邻二个小组即可。

在这里插入图片描述
实现:

def merge_sort(array):    #拆分操作
    if len(array) <= 1:
        return array
    num = int(len(array)/2)
    left = merge_sort(array[ :num])    #样本量减半
    right = merge_sort(array[num: ])    #样本量减半 
    return merge(left, right)

def merge(left, right):    #合并操作:外排
    l, r = 0, 0
    result = []    #外排需要一个装结果的辅助数组
    while l<len(left) and r<len(right):
        if left[l] < right[r]:
            result.append(left[l])
            l += 1
        else:
            result.append(right[r])
            r += 1
    result += left[l:]
    result += right[r:]
    return result

array = [5,2,7,1,8,3,4,6,9,0]
merge_sort(array)
array

6.堆排序 HeapSort

堆排序在 top K 问题中使用比较频繁。堆排序是采用二叉堆的数据结构来实现的,虽然实质上还是一维数组。二叉堆是一个近似完全二叉树 .

二叉堆具有以下性质:

  1. 父节点的键值总是大于或等于(小于或等于)任何一个子节点的键值。
  2. 每个节点的左右子树都是一个二叉堆(都是最大堆或最小堆)。

步骤:

  1. 构造最大堆(Build_Max_Heap):若数组下标范围为0~n,考虑到单独一个元素是大根堆,则从下标n/2开始的元素均为大根堆。于是只要从n/2-1开始,向前依次构造大根堆,这样就能保证,构造到某个节点时,它的左右子树都已经是大根堆。
  2. 堆排序(HeapSort):由于堆是用数组模拟的。得到一个大根堆后,数组内部并不是有序的。因此需要将堆化数组有序化。思想是移除根节点,并做最大堆调整的递归运算。第一次将heap[0]与heap[n-1]交换,再对heap[0…n-2]做最大堆调整。第二次将heap[0]与heap[n-2]交换,再对heap[0…n-3]做最大堆调整。重复该操作直至heap[0]和heap[1]交换。由于每次都是将最大的数并入到后面的有序区间,故操作完后整个数组就是有序的了。
  3. 最大堆调整(Max_Heapify):该方法是提供给上述两个过程调用的。目的是将堆的末端子节点作调整,使得子节点永远小于父节点 。

在这里插入图片描述

def heapSort(arr):
    for i in range(len(arr)-1):
        heapInsert(arr, i)
    #至此大根堆构造完毕,下面开始不断的取出最大值,同时调整大根堆
    print("The heap has been constructed:" + str(array))
    
    size = len(arr)
    arr[0], arr[size-1] = arr[size-1], arr[0]
    size -= 1
    while size > 0:
        heapify(arr, 0, size)    # heapify后,arr[0]又是堆中的最大值
        arr[0], arr[size-1] = arr[size-1], arr[0]
        size -= 1

#创建大根堆  
def heapInsert(arr, index):
    while arr[index] > arr[int((index-1)/2)]:    # (index01)/2 是父节点的下标
        arr[index], arr[int((index-1)/2)] = arr[int((index-1)/2)], arr[index]
        index = int((index-1)/2)
        
#堆化(就是将不是最大值的堆顶,不断下沉到应该的位置)        
def heapify(array, index, heap_size):
    leftindex = index*2 + 1    #左子节点
    rightindex = leftindex + 1    #右子节点
    while leftindex < heap_size:
        largest = rightindex if ( rightindex < heap_size and array[rightindex] > array[leftindex] ) else leftindex           
        largest = largest if array[largest] > array[index] else index
        
        if largest == index:
            break
        array[index], array[largest] = array[largest], array[index]
        
        index = largest
        leftindex = index*2 + 1
        rightindex = leftindex + 1

array = [5,2,7,1,8,3,4,6,9,0]
heapSort(array)
print(array)

希尔排序 ShellSort

希尔排序,也称递减增量排序算法,实质是分组插入排序。由 Donald Shell 于1959年提出。希尔排序是非稳定排序算法。

希尔排序的基本思想是:将数组列在一个中并对分别进行插入排序,重复这过程,不过每次用更长的列(步长更长了,列数更少了)来进行。最后整个表就只有一列了。将数组转换至表是为了更好地理解这算法,算法本身还是使用数组进行排序。

假设有这样一组数[ 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10]
如果我们以步长为5开始进行排序,我们可以通过将这列表放在有5列的表中来更好地描述算法,这样他们就应该看起来是这样:
13 14 94 33 82
25 59 94 65 23
45 27 73 25 39
10

然后我们对每列进行排序:
10 14 73 25 23
13 27 94 33 39
25 59 94 65 82
45
将上述四行数字,依序接在一起时我们得到:[ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ]。这时10已经移至正确位置了,然后再以3为步长进行排序:
10 14 73
25 23 13
27 94 33
39 25 59
94 65 82
45
排序之后变为:
10 14 13
25 23 33
27 25 59
39 65 73
45 94 82
94
此时依序连接在一起时得到:[10, 14, 13, 25, 23, 33, 27, 25, 59, 39, 65, 73, 45, 94, 82, 94]
最后以1步长进行排序(此时就是简单的插入排序了)。

实现:

def shell_sort(array):
    n = len(array)
    gap = round(n/2)    #用round()函数四舍五入
    while gap>0:
        for i in range(gap, n):
            temp = array[i]
            j = i    # 插入排序中要用到的————最后插入位置的下标:j
            while j>=gap and array[j-gap]>temp:    #这里用插入排序
                array[j] = array[j-gap]
                j = j-gap
            array[j] = temp
            
        gap = round(gap/2)
    return array

array = [5,2,7,1,8,3,4,6,9,0]
shell_sort(array)

总结

下面为七种经典排序算法指标对比情况:
在这里插入图片描述

标题基于SpringBoot+Vue的学生交流互助平台研究AI更换标题第1章引言介绍学生交流互助平台的研究背景、意义、现状、方法与创新点。1.1研究背景与意义分析学生交流互助平台在当前教育环境下的需求及其重要性。1.2国内外研究现状综述国内外在学生交流互助平台方面的研究进展与实践应用。1.3研究方法与创新点概述本研究采用的方法论、技术路线及预期的创新成果。第2章相关理论阐述SpringBoot与Vue框架的理论基础及在学生交流互助平台中的应用。2.1SpringBoot框架概述介绍SpringBoot框架的核心思想、特点及优势。2.2Vue框架概述阐述Vue框架的基本原理、组件化开发思想及与前端的交互机制。2.3SpringBoot与Vue的整合应用探讨SpringBoot与Vue在学生交流互助平台中的整合方式及优势。第3章平台需求分析深入分析学生交流互助平台的功能需求、非功能需求及用户体验要求。3.1功能需求分析详细阐述平台的各项功能需求,如用户管理、信息交流、互助学习等。3.2非功能需求分析对平台的性能、安全性、可扩展性等非功能需求进行分析。3.3用户体验要求从用户角度出发,提出平台在易用性、美观性等方面的要求。第4章平台设计与实现具体描述学生交流互助平台的架构设计、功能实现及前后端交互细节。4.1平台架构设计给出平台的整体架构设计,包括前后端分离、微服务架构等思想的应用。4.2功能模块实现详细阐述各个功能模块的实现过程,如用户登录注册、信息发布与查看、在线交流等。4.3前后端交互细节介绍前后端数据交互的方式、接口设计及数据传输过程中的安全问题。第5章平台测试与优化对平台进行全面的测试,发现并解决潜在问题,同时进行优化以提高性能。5.1测试环境与方案介绍测试环境的搭建及所采用的测试方案,包括单元测试、集成测试等。5.2测试结果分析对测试结果进行详细分析,找出问题的根源并
内容概要:本文详细介绍了一个基于灰狼优化算法(GWO)优化的卷积双向长短期记忆神经网络(CNN-BiLSTM)融合注意力机制的多变量多步时间序列预测项目。该项目旨在解决传统时序预测方法难以捕捉非线性、复杂时序依赖关系的问题,通过融合CNN的空间特征提取、BiLSTM的时序建模能力及注意力机制的动态权重调节能力,实现对多变量多步时间序列的精准预测。项目不仅涵盖了数据预处理、模型构建与训练、性能评估,还包括了GUI界面的设计与实现。此外,文章还讨论了模型的部署、应用领域及其未来改进方向。 适合人群:具备一定编程基础,特别是对深度学习、时间序列预测及优化算法有一定了解的研发人员和数据科学家。 使用场景及目标:①用于智能电网负荷预测、金融市场多资产价格预测、环境气象多参数预报、智能制造设备状态监测与预测维护、交通流量预测与智慧交通管理、医疗健康多指标预测等领域;②提升多变量多步时间序列预测精度,优化资源调度和风险管控;③实现自动化超参数优化,降低人工调参成本,提高模型训练效率;④增强模型对复杂时序数据特征的学习能力,促进智能决策支持应用。 阅读建议:此资源不仅提供了详细的代码实现和模型架构解析,还深入探讨了模型优化和实际应用中的挑战与解决方案。因此,在学习过程中,建议结合理论与实践,逐步理解各个模块的功能和实现细节,并尝试在自己的项目中应用这些技术和方法。同时,注意数据预处理的重要性,合理设置模型参数与网络结构,控制多步预测误差传播,防范过拟合,规划计算资源与训练时间,关注模型的可解释性和透明度,以及持续更新与迭代模型,以适应数据分布的变化。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值