十大经典排序算法（python代码）2020-09-17

冒泡排序（python）

def bubble_sort(list):
	for i in range(0,len(list)-1):
		for j in range(0,len(list)-1-i):
			if list[j]>list[j+1]:
				temp=list[j]
				list[j]=list[j+1]
				list[j+1]=temp
			else:
                continue
    print(list)
if __name__ == '__main__':
    list1=[1,3,5,7,9,0,8,6,4,2]
    print(list1)
    bubble_sort(list1)			

选择排序（python）

def selection_sort(list):
    for i in range(0,len(list)):
        minIndex=i
        for j in range(i+1,len(list)):
            if list[j]<list[minIndex]:
                minIndex=j
        temp=list[i]
        list[i]=list[minIndex]
        list[minIndex]=temp
    print('选择排序后列表:',list)
if __name__ == '__main__':
    list1=[1,3,5,7,9,0,8,6,4,2]
    print('初始列表:',list1)
    selection_sort(list1)

插入排序（python）

def insertion_sort(list):
    for i in range(1,len(list)):
        preIndex=i-1
        current=list[i]
        while (preIndex>=0 and current<list[preIndex] ):
            list[preIndex+1]=list[preIndex]
            preIndex-=1
        list[preIndex+1]=current
    print('插入排序后列表：',list)
if __name__ == '__main__':
    list1=[1,3,5,7,9,0,8,6,4,2]
    print('初始列表：',list1)
    insertion_sort(list1)

希尔排序（python）

def shellSort(list):
    k=len(list)//2
    while k>0:
        for i in range(k,len(list)):
            while i>=k and list[i-k]>list[i]:
                list[i-k],list[i]=list[i],list[i-k]
                i=i-k
        k//=2
    print(list)
if __name__ == '__main__':
    list1=[1,3,5,7,9,0,8,6,4,2]
    print(list1)
    shellSort(list1)

归并排序（python）

#递归操作
def merge_sort(arr):
    if len(arr)<2:
        return arr
    mid=len(arr)//2
    l,r=merge_sort(arr[:mid]),merge_sort(arr[mid:])
    return merge(l,r)
#合并两列表
def merge(l,r):
    result=[]
    i,j=0,0
    while i<len(l) and j<len(r):
        if l[i]<=r[j]:
            result.append(l[i])
            i+=1
        else:
            result.append(r[j])
            j+=1
    result.extend(l[i:])
    result.extend(r[j:])
    return result
if __name__ == '__main__':
    arr = [1, 3, 5, 7, 9, 0, 8, 6, 4, 2]
    result1 = merge_sort(arr)
    print(result1)

快速排序（python）

def quick_sort(a):
    if len(a)<2:
        return a
    mid=a[len(a)//2]
    l,r=[],[]
    a.remove(mid)
    for i in a:
        if i<=mid:
            l.append(i)
        else:
            r.append(i)
    return quick_sort(l)+[mid]+quick_sort(r)
if __name__ == '__main__':
    a=[1,3,5,7,9,0,8,6,4,2]
    s=quick_sort(a)
    print(s)

堆排序（python）

#建立大顶堆
def buildMaxHeap(arr):
    length=len(arr)
    for i in range((length-2)//2,-1,-1):
        heapify(arr,length,i)
#堆调整
def heapify(arr,length,root):
    left=2*root+1
    right=2*root+2
    largest=root
    if left<length and arr[left]>arr[largest]:
        largest=left
    if right<length and arr[right]>arr[largest]:
        largest=right
    if largest!=root:
        arr[root],arr[largest]=arr[largest],arr[root]
        heapify(arr,length,largest)
#建大顶堆，将每个最大值放在最后，进行堆调整
def heapSort(arr):
    buildMaxHeap(arr)
    for i in range(len(arr)-1,-1,-1):
        arr[0],arr[i]=arr[i],arr[0]
        heapify(arr,i,0)
    return arr
if __name__ == '__main__':
    arr=[1,3,5,7,9,0,8,6,4,2]
    heapSort(arr)
    print(arr)

计数排序（python）

def counting_sort(arr):
# 得到数列元素的最大值
    MAX=arr[0]
    for i in range(1,len(arr)):
        if arr[i]>MAX:
            MAX=arr[i]
            
#根据数列的最大值确定统计数组的长度
    countArray=[]
    for i in range(MAX+1):
        countArray.append(0)
        
#遍历数列，将不同数值个数统计出来
    for j in range(len(arr)):
        countArray[arr[j]]+=1
        
#遍历统计数组，输出结果
    sortArray=[]
    for i in range(len(countArray)):
        for j in range(countArray[i]):
            sortArray.append(i)
    return sortArray
#调用    
if __name__ == '__main__':
    arr = [1, 3, 5, 7, 9, 0, 8, 6, 4, 2]
    result=counting_sort(arr)
    print(result)

桶排序（python）

def bucketsort(arr):
    import math
    if len(arr)<=0:
        return arr
    bucketLength=len(arr)-1
    bucketSize=((max(arr)-min(arr))/bucketLength)
# 设置一个定量的数组当作空桶；
    buckets=[[]for i in range(bucketLength)] #二维桶
# 遍历输入数据，并且把数据一个一个放到对应的桶里去； 
    for i in range(len(arr)):
        num_location=math.ceil((arr[i]-min(arr))/bucketSize)-1
        if num_location<=0:
            num_location=0
        buckets[num_location].append(arr[i])
# 对每个不是空的桶进行排序；    
    for i in range(bucketLength):
        buckets[i].sort()
# 从不是空的桶里把排好序的数据拼接起来 
    res=[]
    for i in range(len(buckets)):
        res.extend(buckets[i])
    return res
if __name__ == '__main__':
    arr=[1,3,5,7,9,0,8,6,4,2]
    print(bucketsort(arr))

基数排序（python）

def RadixSort(arr):
    i=0                       #记录当前正在排序拿的第一位数字，最低位数为1
    max_number=max(arr)       #最大值
    j=len(str(max_number))    #得到最大值的位数
    while i<j:                #进行这么多轮排序
        bucket_list=[[]for _ in range(10)]           #构建二维空列表
        for x in arr:         #从输入列表取值
            bucket_list[int(x/(10**i))%10].append(x) #依次将列表中的值放到对应序列号的桶中
        print('第%s轮排序：'%(i+1),bucket_list)
        arr.clear()            #每轮需要清空，不然会多
        for x in bucket_list: #从每一轮排序的二维列表中将子列表取出来
            for y in x:       #从子列表中取出数值
                arr.append(y) #将数值放到原输入列表中
        i+=1                  #排序轮数加1
if __name__ == '__main__':
        arr=[13,35,57,79,90,88,66,44,22,21]
        RadixSort(arr)
        print('最终排序结果：',arr)