python 的常见排序算法实现

python 的常见排序算法实现

参考以下链接：https://www.cnblogs.com/shiluoliming/p/6740585.html

算法（Algorithm）是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。如果一个算法有缺陷，或不适合于某个问题，执行这个算法将不会解决这个问题。不同的算法可能用不同的时间、空间或效率来完成同样的任务。一个算法的优劣可以用空间复杂度与时间复杂度来衡量。

一个算法应该具有以下七个重要的特征：

①有穷性（Finiteness）：算法的有穷性是指算法必须能在执行有限个步骤之后终止；

②确切性(Definiteness)：算法的每一步骤必须有确切的定义；

③输入项(Input)：一个算法有0个或多个输入，以刻画运算对象的初始情况，所谓0个输入是指算法本身定出了初始条件；

④输出项(Output)：一个算法有一个或多个输出，以反映对输入数据加工后的结果。没有输出的算法是毫无意义的；

⑤可行性(Effectiveness)：算法中执行的任何计算步骤都是可以被分解为基本的可执行的操作步，即每个计算步都可以在有限时间内完成（也称之为有效性）；

⑥高效性(High efficiency)：执行速度快，占用资源少；

⑦健壮性(Robustness)：对数据响应正确

import random
#冒泡排序
def bubbleSort(L):
    assert (type(L)==type(['']))
    length=len(L)
    if length<=1:
        return L

    for i in range(length-1):
        for j in range(length-1-i):
            if L[j]<L[j+1]:
                L[j],L[j+1]=L[j+1],L[j]

    return L
#选择排序
def selectSort(L):
    assert (type(L)==type(['']))
    length=len(L)
    if length<=1:
        return L

    def _max(s):
        largest=s
        for i in range(s,length):
            if L[i]>L[largest]:
                largest=i
        return largest

    for i in range(length):
        largest=_max(i)
        if i!=largest:
            L[i],L[largest]=L[largest],L[i]

    return L

#插入排序
def insertSort(L):
    assert (type(L) == type(['']))
    length = len(L)
    if length <= 1:
        return L

    for i in range(1,length):
        value=L[i]
        j=i-1
        while j>=0 and L[j]<value:
            L[j+1]=L[j]
            j-=1
        L[j+1]=value
    return L
#归并排序法
def mergeSort(l):
    length = len(l)
    if length <= 1:
        return l

    num=int(length/2)
    left=mergeSort(l[:num])
    right=mergeSort(l[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

#快速排序
def quickSort(l,s,e):
    if s<e:
        m=partition(l,s,e)
        quickSort(l,s,m-1)
        quickSort(l,m+1,e)
    return l

def partition(l,start,end):
    pivot=l[start]
    leftmark=start+1
    rightmark=end
    while True:
        while l[leftmark]<=pivot:
            if leftmark==rightmark:
                break
            leftmark+=1
        while l[rightmark]>pivot:
            rightmark-=1
        if leftmark<rightmark:
            l[leftmark],l[rightmark]=l[rightmark],l[leftmark]
        else:
            break
    l[start],l[rightmark]=l[rightmark],l[start]
    return rightmark

lst=[random.randint(1,10) for x in range(10) ]
print ('before sort:',lst)
print ('after quickSort:',quickSort(lst,0,len(lst)-1))
print ('after mergeSort:',mergeSort(lst))
print ('after insertSort:',insertSort(lst))
print ('after selectSort:',selectSort(lst))
print ('after bubbleSort:',bubbleSort(lst))

python 的常见排序算法实现

猜你喜欢