【算法】排序算法总结

可可卷

已于 2022-04-08 11:05:24 修改

阅读量1.7k

点赞数 7

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

于 2021-12-05 21:36:49 首次发布

本文链接：https://blog.csdn.net/weixin_45825073/article/details/121736081

版权

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

19 篇文章 21 订阅

订阅专栏

本文介绍了使用Python实现生成随机数列、基本有序数列的生成、以及冒泡排序、选择排序和插入排序等经典算法的示例，并通过测试性能来展示排序算法的效率。通过这些内容，读者可以理解基础的数组操作和排序算法在实际编程中的应用。

摘要由CSDN通过智能技术生成

生成随机数列

from random import randint

def generateRandomArray(n=10, min=0, max=100):
    return [randint(min, max) for _ in range(n)]

生成基本有序的数列

def generateNearlyOrderedArray(n=10, swapTimes=2):
    arr = list(range(n))
    for _ in range(swapTimes):
        i,j = randint(0, n-1),randint(0, n-1)
        arr[i], arr[j] = arr[j], arr[i]
    return arr

测试算法性能

from timeit import Timer

def testSort(func, nums):# func：检测的算法函数；nums：传入的数组
    nums =  func(nums)
    assert len(nums), "返回数组为空\n"

t1 = Timer('testSort(XXXSort, nums)', 'from __main__ import testSort, XXXSort, nums')
print('XX排序算法：%s s' %t1.timeit(number=1))

冒泡排序

def bubbleSort(nums):
    n=len(nums)
    for i in range(n-1,0,-1):
        for j in range(i):
            if nums[j]>nums[j+1]:
                nums[j],nums[j+1]=nums[j+1],nums[j]
    return nums

上面这个是向后冒泡，还有个向前冒泡的版本：(可以由i判断向哪冒泡)

def bubbleSort(nums):
    for i in range(n:=len(nums)):
        for j in range(n-1,i,-1):
            if nums[j]<nums[j-1]:
                nums[j], nums[j - 1] = nums[j - 1], nums[j]
    return nums

选择排序

def selectionSort(nums):
    n = len(nums)
    for i in range(n - 1):
        idx = i
        for j in range(i+1, n):
            if nums[j] < nums[idx]:
                idx = j
        nums[i], nums[idx] = nums[idx], nums[i]
    return nums

插入排序

def insertionSort(nums):
    n=len(nums)
    for i in range(1,n):
        value,pos=nums[i],i
        while nums[pos-1]>value and pos>0:
            nums[pos],pos=nums[pos-1],pos-1
        nums[pos]=value
    return nums

快速排序

def quickSort(nums,l,r):	# 闭区间[l,r]
    if l>=r:return
    i,j,x=l,r,nums[l+r>>1]
    while i<j:
   	    i+=1;j-=1;  # 想一想为什么不能少了这一行
        while nums[i]<x:i+=1
        while nums[j]>x:j-=1
        if i<j:nums[i],nums[j]=nums[j],nums[i]
    quickSort(nums,l,j)
    quickSort(nums,j+1,r)

归并排序

tmp=[0]*n
def mergeSort(nums,l,r):	# 闭区间[l,r]
    if l>=r:return
    mid=l+(r-l>>1)
    mergeSort(nums,l,mid)
    mergeSort(nums,mid+1,r)

    k,i,j=0,l,mid+1
    while i<=mid and j<=r:
        if nums[i]<nums[j]:
            tmp[k]=nums[i];k+=1;i+=1
        else:
            tmp[k] = nums[j];k += 1;j += 1
    while i<=mid:
        tmp[k] = nums[i];k += 1;i += 1
    while j<=r:
        tmp[k] = nums[j];k += 1;j += 1

    nums[l:r+1]=tmp[0:r+1-l]

中间部分可以这样记忆（虽然不可以这样运行）

    k,i,j=0,l,mid+1	# 分成两部分，[l,mid],[mid+1,r]
    while i<=mid and j<=r:
        if nums[i]<nums[j]:
            tmp[k++]=nums[i++]
        else:
            tmp[k++] = nums[j++]
    while i<=mid:
        tmp[k++] = nums[i++]
    while j<=r:
        tmp[k++] = nums[j++]

希尔排序

def shellSort(nums):
    gap = len(nums)
    while gap:=gap//2 > 0:
        for i in range(gap):
            gapInsetionSort(nums, i, gap)
    return nums
    
def gapInsetionSort(nums,startpos,gap): # 辅助函数
    n=len(nums)
    for i in range(startpos+gap,n,gap):
        value,pos=nums[i],i
        while pos>startpos and nums[pos-gap]>value:
            nums[pos],pos=nums[pos-gap],pos-gap
        nums[pos]=value

为什么python不支持自增(i++)?

《learning python》这样解释:

although Python now supports statements like X += Y, it still does not
have C’s auto-increment/decrement operators (e.g., X++, −−X). These
don’t quite map to the Python object model because Python has no
notion of in-place changes to immutable objects like numbers.