排序算法Python实现

1. 冒泡排序

#基于小泡往上冒
def BubbleSort_up(arr):
    if not arr:
        return []
    size = len(arr)
    for i in range(size-1):
        #基于小泡往上冒
        for j in range(size-1,i,-1):
            if arr[j]<arr[j-1]:
                arr[j],arr[j-1]=arr[j-1],arr[j]
    print(arr)

#基于大泡往下沉
def BubbleSort_down(arr):
    if not arr:
        return []
    size = len(arr)
    for i in range(size-1,-1,-1):
        #最后面的i个元素已经是排好序了
        for j in range(i):
            if arr[j]>arr[j+1]:
                arr[j],arr[j+1]=arr[j+1],arr[j]
    print(arr)

#优化版冒泡排序
#冒泡排序可能在冒泡过程中顺便后面已经排完序了，不需要规规矩矩一步一步走到最后
#通过定义一个交换标志，如果当前遍历后没有发生交换，就是已经都排好序了
def BubbleSorr_O(arr):
    Swap=True
    size=len(arr)
    for i in range(size-1):
        if Swap==False:
            break
        Swap=False
        for j in range(size-1,i,-1):
            if arr[j]<arr[j-1]:
                arr[j],arr[j-1]=arr[j-1],arr[j]
                Swap=True
    print(arr)

2. 选择排序

def SelectSort(arr):
    if not arr:
        return []
    size=len(arr)
    for i in range(size-1):
        minnum=arr[i]
        idx=i
        #对当前元素arr[i]，从后面的元素arr[i+1:]中选择一个最小的和它交换
        for j in range(i+1,size):
            if arr[j]<minnum:
                minnum=arr[j]
                idx=j
        arr[i],arr[idx]=arr[idx],arr[i]
    print(arr)

3. 堆排序

#选择排序中，在后面选最小元素比较过程中，有一堆有用的信息被浪费
#所以考虑在选最小元素的比较过程中，让小的元素也尽量靠前——小顶堆
def HeapSort(arr):
    #堆操作每次都是从最后一个非叶子节点开始往上进行
    start=len(arr)//2-1
    #初始堆，把最小元素放到对顶
    for i in range(start,-1,-1):
        HeapAdjust(arr,i,len(arr)-1)  #对arr进行调整，把从i以后到len(arr)-1的节点调整好
    #堆排序，把堆顶元素放到最后,后i个是排序好的
    for i in range(len(arr)-1,0,-1):
        arr[i],arr[0]=arr[0],arr[i]
        #交换后又要继续调整
        HeapAdjust(arr,0,i-1)
    print(arr)

def HeapAdjust(arr,start,end):
    root=start
    maxchild=2*root+1   #选大的孩子跟根节点比较
    while maxchild<=end:   #左孩子是存在的
        #右孩子是存在的，则左右孩子相比取其大
        if maxchild+1<=end and arr[maxchild]<arr[maxchild+1]:
            maxchild+=1
        #把大的节点往上放，等到交换的时候就会在下面了
        if arr[root]<arr[maxchild]:
            arr[root],arr[maxchild]=arr[maxchild],arr[root]
            root=maxchild   #原来根的那个数放在了maxchild的位置
            maxchild=2*root+1
        else:
            break

4. 插入排序

def InsertSort(arr):
    if not arr:
        return []
    size=len(arr)
    for i in range(1,size):
        cur=arr[i]
        #对当前元素arr[i]在前面已经排好序的列表arr[:i]中找一个合适的位置插入
        for j in range(i-1,-2,-1):
            if arr[j]<=cur:
                break
            else:
                arr[j+1]=arr[j]
        arr[j+1]=cur
    print(arr)

5. 希尔排序

#插入排序在原始数据基本有序的情况下效率高
#希尔排序针对这一点对直接插入排序进行改进
#通过变增量的比较和交换，让数据的有序性升高
#增量是逐渐减小的
def ShellSort(arr):
    incre=len(arr)
    while incre>1:
        incre=incre//3+1   #初始增量的选择
        for i in range(incre,len(arr)):
            if arr[i]<arr[i-incre]:
                cur=arr[i]
                #如果小于相邻的前一个增量，还要接着往前对比
                #找到一个合适的位置插入（跟基本插入一样的操作)
                for j in range(i-incre,-2,-incre):
                    if arr[j]<=cur:
                        break
                    else:
                        arr[j+incre]=arr[j]
                arr[j+incre]=cur
    print(arr)

6. 归并排序
   归并排序递归实现时间复杂度O(nlogn),空间复杂度O(n+logn),非递归实现空间复杂度O(n)，并且在时间性能上有一定实现，是稳定算法。

# 递归实现
def MergeSort(arr):
    if len(arr)<=1:
        return arr
    mid=len(arr)//2
    return Merge(MergeSort(arr[:mid]),MergeSort(arr[mid:]))
    
def Merge(L,R):
    res=[]
    while L and R:
        res.append(L.pop(0) if L[0]<=R[0] else R.pop(0))
    return res+L+R 

# 迭代实现
def merge(arr,low,mid,height):
	left=arr[low:mid]
	right=arr[mid:height]
	res=[]
	while left and right:
		if left[0]<=right[0]:
			res.append(left.pop(0))
		else:
			res.append(right.pop(0))

	arr[low:height]=res+left+right

def mergesort(arr):
	i=1
	while i<len(arr):
		low=0
		while low<len(arr):
			mid=low+i
			height=min(low+2*i,len(arr))
			if mid<height:
				merge(arr,low,mid,height)
			low+=2*i
		i*=2
	return arr

7. 快速排序

#快速排序
def QuickSort(arr):
    if len(arr)<=1:
        return arr
    cur=arr[0]
    l=0
    r=len(arr)-1
    while l<r:
        while arr[r]>=cur and r>l:
            r-=1
        arr[l]=arr[r]
        while arr[l]<=cur and l<r:
            l+=1
        arr[r]=arr[l]
    arr[l]=cur
    return QuickSort(arr[:l])+[arr[l]]+QuickSort(arr[l+1:])

————————————————
积跬步，以至千里