python中的算法

python中经典的几大算法：冒泡、选择、插入、快速、希尔、归并排序
1、冒泡排序（升序）

俩俩（两个相邻的元素）进行比较，根据条件，交换位置，每一次都会选出一个最大（最小）的元素

如果小–大：每一次都会找到最大

如果大–小：每一次都会找到最小

li=[23,-8,26,-2,-6,-18,33]
def sortbubble(li):
    n=len(li)
    for i in range(n-1):
        for j in range(n-1-i):
            if li[j+1]<li[j]:
                li[j+1],li[j]=li[j],li[j+1]
    return li
print(sortbubble(li))

改写冒泡排序，实现时间复杂度为o(n)

li=[23,-8,26,-2,-6,-18,33]
def sortbubble(li):
    n=len(li)
    tag = True
    for i in range(n-1):
        for j in range(n-1-i):
            if li[j+1]<li[j]:
                li[j+1],li[j]=li[j],li[j+1]
                tag=False
        if tag==True:
            return li
    return li
print(sortbubble(li))

2、选择排序(升序)

每次选择一个最小（最大）的元素， 放在前面排好序。

每次定义一个min_index =0，跟其他元素相比较 ，找到真正的最小值的索引 min_index=真正的最小值索引

li[假的最小值位置] li[真的最小值]交换位置。

li=[23,-8,26,-2,-6,-18,33]
def sortchoose(li):
    n=len(li)
    for i in range(n-1):
        min=i
        for j in range(i+1,n):
            if li[j]<li[min]:
                min=j
        li[min],li[i]=li[i],li[min]
    return li
print(sortchoose(li))

3、插入排序（升序）

从第二个元素开始，插入现有列表中（已经排好队的列表），

每个元素保证插入之后，列表都是有序的

li=[23,-8,26,-2,-6,-18,33]
def sortinsert(li):
    n=len(li)
    for i in range(1,n):
        temp=li[i]
        j=i-1
        while temp<li[j] and j>=0:
            li[j+1]=li[j]
            j-=1
        li[j+1]=temp
    return li
print(sortinsert(li))

4、希尔排序(升序)

最小增量排序，升级版的插入排序

使得原来的列表内部先进行分组排序

增量不定：没有规则

增量：间隔多少 i i+increnment i+2*increnment

规则：从大小 10 8 6 4 1

li=[23,-8,26,-2,-6,-18,33]
increment = [3, 2, 1]
def sortshell(li,increment):
    n=len(li)
    for inc in increment:
        for j in range(inc):
            for i in range(inc+j,n,inc):
                temp=li[i]
                k=i-inc
                while temp<li[k] and k>=0:
                    li[k+inc]=li[k]
                    k-=inc
                li[k+inc]=temp
    return li
print(sortshell(li,increment))

5、快速排序（升序）

1）用到了append

从列表中选取一个中心点，使得中心点左侧的元素都小于该元素，中心点右侧的元素都大于该元素。

递归

li=[23,-8,26,-2,-6,-18,33]
def quick(li):
    n=len(li)
    if len(li)<=1:
         return li
    else:
        mid=0
        small=[]
        bigger=[]
        for i in range(1,n):
            if li[mid]>li[i]:
                small.append(li[i])
            else:
                bigger.append(li[i])
    return quick(small) + [li[mid]]  +quick(bigger)
print(quick(li))

6、使用c语言实现快速排序（升序）

从列表中选出一个中心点pivot，将比中心点小的元素，全部移动到中心点的左侧
将比中心点大的元素，全部移动到中心点的右侧

def quick(li,left ,right):
    if left<right:
        _pivot=partition(li,left,right)
        quick(li,left,_pivot-1)
        quick(li,_pivot+1,right)
 
def partition(li,left,right):
    pivot=li[left]
    while left <right:
        while left<right and pivot<li[right]:
            right-=1
        li[left]=li[right]
        while left<right and pivot>li[left]:
            left+=1
        li[right]=li[left]
    li[left]=pivot
    return left
li=[3,-2,5,10,-9,11,7,-1]
quick(li,0,len(li)-1)
print(li)

图解

7、归并排序(升序)

def merge(li,low ,high):
    if low<high:
        mid=(low+high)//2
        merge(li,low,mid)
        merge(li,mid+1,high)
        merger_sort(li,low,mid,high)
 
def merger_sort(li,low,mid,high):
    #i是左半部分区域的指针
    #j是右半部分区域的指针
    i=low
    j=mid+1
    temp=[]
    while i<=mid and j<=high:
        if li[i]<=li[j]:
            temp.append(li[i])
            i+=1
        else:
            temp.append(li[j])
            j+=1
    while i<=mid:
        temp.append(li[i])
        i+=1
    while j<=high:
        temp.append(li[j])
        j+=1
    li[low:high+1]=temp
li=[2,-1,22,45,-5,3]
merge(li,0,len(li)-1)
print(li)

原文：https://blog.csdn.net/u014486460/article/details/83038653?utm_source=copy