python实现最简单的三种排序，冒泡排序、选择排序、插入排序

冒泡排序

思想：相邻元素比较，大的放右边，小的放左边，以此类推，第一趟下来，右边尾部为最大数。
实现方法：循环嵌套
最好情况：不需要交换位置，时间复杂度为O(n)
最坏情况：为列表元素全部逆序，时间复杂度为O(n^2)
稳定性：稳定

def bubble_sort(alist):
    n=len(alist)
    for i in range(n-1):
        count=0
        for j in range(0,n-1-i):
            if alist[j]>alist[j+1]:
                alist[j],alist[j+1]=alist[j+1],alist[j]
                count+=1
        if count==0:
            break
if __name__ == '__main__':
    li=[5,4,2,3,1]
    print(li)
    bubble_sort(li)
    print(li)

选择排序

思想：从第一个元素开始，默认为最小元素，以此和后面元素比较，若后面的元素小于默认元素，则默认元素更新为更小的，直到所有元素比较完成，找到了最小的元素以及下标，将其放在第一位，其他元素以此后退，直到最后一位。
实现方法：循环嵌套
最好情况：不需要交换位置，时间复杂度为O(n^2)
最坏情况：为列表元素全部逆序，时间复杂度为O(n^2)
稳定性：不稳定

def select_srot(alist):
    n=len(alist)
    for i in range(n-1):
        min=i
        for j in range(i+1,n):
            if alist[min]>alist[j]:
                min=j
        alist[i],alist[min]=alist[min],alist[i]
if __name__ == '__main__':
    li=[5,4,2,3,1]
    print(li)
    select_srot(li)
    print(li)

插入排序

思想：第一个元素与后面的每一个元素比较，后方的元素小于第一个元素，ze插入到第一个元素前方，若大则不动，后方的元素以此插入到前面排好的有序数列中。
实现方法：循环嵌套
最好情况：不需要交换位置，时间复杂度为O(n)
最坏情况：为列表元素全部逆序，时间复杂度为O(n^2)
稳定性：稳定

def inser_srot(alist):
    n=len(alist)
    for i in range(1,n):
        j=i
        while j>0:
            if alist[j]<alist[j-1]:
                alist[j],alist[j-1]=alist[j-1],alist[j]
                j-=1
            else:
                break
if __name__ == '__main__':
    li=[5,4,3,2,1]
    print(li)
    inser_srot(li)
    print(li)