Python排序算法

最新推荐文章于 2022-05-07 19:05:33 发布

原创最新推荐文章于 2022-05-07 19:05:33 发布 · 405 阅读

1 ·

CC 4.0 BY-SA版权

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

4 篇文章

订阅专栏

冒泡排序

每次比较相邻两个元素，若从小到大排序，则交换大数到列表末尾；若从大到小排序，则交换小数到列表开头
主要时间消耗是比较次数，N个元素需要比较(N-1)+(N-2)+…+1=N(N-1)/2，即算法的时间复杂度是O(N^2)

def bubbleSort(a):
    for i in range(len(a)-1,-1,-1):   #子列表长度，逐渐变短   #N-1 ~ 0
        for j in range(i):   #遍历子列表，最大元素冒泡向后移
            if a[j]>a[j+1]:
                a[j],a[j+1]=a[j+1],a[j]
    return a
    
#test:
abS=[59,12,77,64,72,69,46,89,31,9]
print bubbleSort(abS)
#Output:[9, 12, 31, 46, 59, 64, 69, 72, 77, 89]

选择排序

按递增(减)顺序排序，每次在无序数组里找最小(大)值，并把该最小(大)值放到首位
主要时间消耗是比较次数，N个元素需要比较(N-1)+(N-2)+…+1=N(N-1)/2，即算法的时间复杂度是O(N^2)

def selectionSort(a):
    for i in range(0,len(a)):   #遍历待存放最小元素的位置 0 ~ N-1
        m=i   #m用于记录最小位置
        for j in range(i+1,len(a)):   #遍历子列表，找最小元素的位置
            if a[j]<a[m]:
                m=j
        a[i],a[m]=a[m],a[i]
    return a
#test:
asS=[59,12,77,64,72,69,46,89,31,9]
print selectionSort(asS)
#Output:[9, 12, 31, 46, 59, 64, 69, 72, 77, 89]

插入排序

从左到右遍历列表每个元素，将该元素插入到左侧"已排好序的列表"里，则待插入元素从"已排好序的列表的右侧"开始比较
最好情况————列表处于排序状态，总运行次数为线性
最差情况————列表处于逆序状态，总运行次数为1+2+…+N-1=N(N-1)/2，即算法的时间复杂度是O(N^2)

def insertSort(a):   #从小到大排序
    for i in range(1,len(a)):   #遍历未排序列表的待插入元素 1 ~ N-1
        j=i
        while j>0 and a[j]<a[j-1]:   #从"已排好序的列表的右侧"开始比较
            a[j-1],a[j]=a[j],a[j-1]
            j -= 1
    return a
#test:
aiS=[59,12,77,64,72,69,46,89,31,9]
print insertSort(aiS)
#Output:[9, 12, 31, 46, 59, 64, 69, 72, 77, 89]

归并排序

将含N个元素的列表分成2个子列表，对2个子列表递归调用归并排序；合并两个已经排序好的子列表
将列表分成子列表，需要logN步；合并2个有序列表，时间复杂度是O(N)。则该算法的时间复杂度是O(NlogN)

def merge(left,right):   #合并两个已排序列表
    merged=[]
    i,j=0,0
    left_len,right_len=len(left),len(right)
    while i<left_len and j<right_len:
        if left[i]<=right[j]:
            merged.append(left[i])
            i += 1
        else:
            merged.append(right[j])
            j += 1
    merged.extend(left[i:])
    merged.extend(right[j:])
    return merged
    
def mergeSort(a):
    if len(a)<=1:
        return a
    mid=len(a)//2
    left=mergeSort(a[:mid])   #归并左子列表
    right=mergeSort(a[mid:])   #归并右子列表
    return merge(left,right)
#test:
amS=[59,12,77,64,72,69,46,89,31,9]
print mergeSort(amS)
#Output:[9, 12, 31, 46, 59, 64, 69, 72, 77, 89]

快速排序

定义指向待排序列表首尾的下标变量i,j，列表首元素作为基准key，
从列表尾向前搜索，出现第一个小于key的值A[j]，将A[j]与A[i]交换
从列表首向后搜索，出现第一个大于key的值A[i]，将A[i]与A[j]交换
一趟排序，使基准key 左侧的数据都不比key大，右侧的数据都不比key小
每次划分选的基准是当前无序列表里最小或最大元素时，时间复杂度O(N^2)
平均情况时间复杂度O(NlogN)

def quick_sort(L):
    return q_sort(L, 0, len(L) - 1)

def q_sort(L, left, right):
    if left < right:
        pivot = Partition(L, left, right)

        q_sort(L, left, pivot - 1)
        q_sort(L, pivot + 1, right)
    return L

def Partition(L, left, right):
    pivotkey = L[left]

    while left < right:
        while left < right and L[right] >= pivotkey:
            right -= 1
        L[left] = L[right]
        while left < right and L[left] <= pivotkey:
            left += 1
        L[right] = L[left]

    L[left] = pivotkey
    return left

L = [5, 9, 1, 11, 6, 7, 2, 4]

print quick_sort(L)