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))