python 排序算法详解

冒泡排序

1. 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
3. 针对所有的元素重复以上的步骤，除了最后一个；
4. 重复步骤1~3，直到排序完成。

def bubble_sort(list1):
    for i in range(len(list1)):
        for j in range(len(list1)-1-i):
            if list1[j]>list1[j+1]:
                list1[j],list1[j+1]=list1[j+1],list1[j]
    print(list1)

#从后往前排 ，先排最大的，时间复杂度：O(n²) 

选择排序

选择排序就是要首先选定一个元素认为为最小的，之后比较其他，如果小于之前的，换更换列表所在位置。时间复杂度：O(n²)

 

def selection_sort(list1):
    for i in range(len(list1)):
        x=i               #首先假定list[i]为最小，与之后的比较
        for j in range(i,len(list1)):
            if list1[j]<list1[x]:
                x=j   #小于之前list[i]就交换位置
        list1[i],list1[x]=list1[x],list1[i]
    print(list1)

插入排序

插入排序：选定元素，分别与列表中的元素比较，小的在左边，大的在右边

1. 从第一个元素开始，该元素可以认为已经被排序；
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描；
3. 如果该元素（已排序）大于新元素，将该元素移到下一位置；
4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
5. 将新元素插入到该位置后；
6. 重复步骤2~5。

def insertion_sort(list1):
    for i in range(len(list1)):
        for j in range(i):
            if list1[j]>list1[i]:
                list1[i],list1[j]=list1[j],list1[i]
    print(list1)

希尔排序

希尔排序将元素先平分，gap=len(list1)//2,按照gap去比较，一次//2,直到gap为1，
例如：gap=4,0-4,1-5,2-6，3-7,4-8,5-9去比较大小，若小于前面的,则交换位置。 时间复杂度：O(n) 

def Shell_sort(list1):
    gap=len(list1)
    while gap>1:
        gap=gap//2  #若len(list1)=9,gap=4,3,2,1
        for i in range(gap,len(list1)):
            for j in range(i%gap,i,gap):
                if list1[i]<list1[j]:
                    list1[j],list1[i]=list1[i],list1[j]
    print(list1)

快速排序

快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists），从数列中挑出一个元素，称为 “基准”（pivot）；
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置
时间复杂度O(nlog₂n)

ef quick_sort(list1):
    left=[]
    right=[]
    same=[]
    if len(list1)<=1:
        return list1
    else:
        base=list1[0]
        for i in list1:
            if i<base:
                left.append(i)
            elif i>base:
                right.append(i)
            else:
                same.append(i)
        left=quick_sort(left)
        right=quick_sort(right)#对right数列和left数列继续进行排序
        return left+same+right#函数里面调用直到满足return条件停止调用，类似于函数循环

归并排序

归并排序：采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并
时间复杂度：O(nlog₂n)

归并排序也就是将列表中的元素分成两个长度为n/2的子序列，进行比较，之后合在一起

def merge_sort(list1):#merge_sort是按照len(list1)//2分开，知道分成两两比较大小
    if len(list1)<=1:
        return list1
    mid=len(list1)//2
    left=merge_sort(list1[:mid])
    right=merge_sort(list1[mid:])
    return merge(left,right)
def merge(left,right):#mere函数主要是左右两边每次取一个数进行比较，小的加入到result中
    result=[]
    while len(left)and len(right):
        if left[0]<right[0]:
            result.append(left.pop(0))
        else:
            result.append(right.pop(0))
    if len(left)!=0:
        result+=left
    elif len(right)!=0:
        result+=right
    return result

堆排序

堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。

二叉树相关知识http://www.cnblogs.com/polly333/p/4740355.html

大顶堆：arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2]  父节点i的左子节点在位置(2*i+1); 父节点i的右子节点在位置(2*i+2)

小顶堆：arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2]

堆排序：

1. 将无序列表构建最大堆，根节点为最大元素
2. 将堆顶元素与末尾元素进行交换，使末尾元素最大。然后继续调整堆，再将堆顶元素与末尾元素交换，得到第二大元素。如此反复进行交换、重建、交换。

def heap_sort(hlist):
    def heap_adjust(parent):
        child = 2 * parent + 1  # left child
        while child < len(heap):
            if child + 1 < len(heap):
                if heap[child + 1] > heap[child]:
                    child += 1  # right child,比较左右结点的大小，选出最大的元素
            if heap[parent] >= heap[child]:
                break
            heap[parent], heap[child] = heap[child], heap[parent]#把最大的结点与父节点交换
            parent, child = child, 2 * child + 1#往二叉树下面走，继续去比较，选出最大放到根节点，知道所有元素比较完退出
 
    heap, hlist = copy.copy(hlist), []
    for i in range((len(heap)-2)// 2, -1, -1):#(len(heap)-2)// 2为二叉树层数，k=3,i=3,2,1,0
        heap_adjust(i)
    while len(heap) != 0:
        heap[0], heap[-1] = heap[-1], heap[0]
        hlist.insert(0, heap.pop())#第一个替换成heap最后一个
        heap_adjust(0)
    return hlist

时间复杂度O(nlog₂n)，不稳定

可以参考https://www.cnblogs.com/chengxiao/p/6129630.html

上面图片摘自博客：https://www.cnblogs.com/onepixel/articles/7674659.html

python代码参考：https://blog.csdn.net/mxz19901102/article/details/80087596、http://python.jobbole.com/86119/