最全排序算法汇总(Python)

# import time
#
# 1、冒泡排序
# def BubbleSort(arr):
# 	for i in range(1,len(arr)):
# 		for j in range(0,len(arr)-i):
# 			if arr[j]>arr[j+1]:
# 				arr[j],arr[j+1]=arr[j+1],arr[j]
# 	return arr

# 1.1、冒泡排序优化1
# def bubbleSort_improveV1(arr):
#     for i in range(1,len(arr)):
#         flag = True
#         for j in range(0,len(arr)-i):
#             if arr[j]>arr[j+1]:
#                 arr[j],arr[j+1]=arr[j+1],arr[j]
#                 flag=False
#         if flag:
#             break
#     return arr

# 1.2、冒泡排序优化2
# def bubbleSort_improveV2(arr):
#     last_change_index=0 #记录最后一次交换的位置
#     # 无序数列的边界，每次只需要比较到此处就可以了，因为之后都是有序数据
#     sort_border=len(arr)-1
#     for i in range(0,len(arr)):
#         flag=True
#         for j in range(0,sort_border):
#             if arr[j]>arr[j+1]:
#                 arr[j],arr[j+1]=arr[j+1],arr[j]
#                 flag=False
#                 last_change_index=j
#         sort_border=last_change_index
#         if flag:
#             break
#     return arr

# 1.3、鸡尾酒排序，也是属于冒泡排序的一种改进方法
# def cock_tail_sort(arr=[]):
#     for i in range(len(arr)//2):
#         # 有序标记，初始为True
#         flag=True
#         # 奇数轮，从左向右比较和交换
#         for j in range(i,len(arr)-1-i):
#             if arr[j]>arr[j+1]:
#                 arr[j+1],arr[j]=arr[j],arr[j+1]
#                 flag=False
#         if flag:
#             break
#         # 偶数轮开始之前，要重新标记为True
#         flag=True
#         # 偶数轮
#         for k in range(len(arr)-i-1,i,-1):
#             if arr[k]<arr[k-1]:
#                 arr[k],arr[k-1]=arr[k-1],arr[k]
#                 flag=False
#         if flag:
#             break
#     return arr


# 2、选择排序
# def SelectionSort(arr):
#     for i in range(len(arr)-1): #最后一个数据不用再参与循环，因为只剩它一个，它肯定就是未排序序列中最小的
#         minIndex=i
#         for j in range(i+1,len(arr)):
#             if arr[minIndex] > arr[j]:
#                 minIndex=j
#         if i!=minIndex:
#             arr[i],arr[minIndex]=arr[minIndex],arr[i]
#     return arr


# 3、插入排序
# def InsertionSort(arr):
#     for i in range(len(arr)):
#         perIndex=i-1
#         current=arr[i]
#         while perIndex>=0 and arr[perIndex]>current:
#             arr[perIndex+1]=arr[perIndex]
#             perIndex -= 1
#         arr[perIndex+1]=current
#     return arr


# 4、希尔排序
# def shellSort(arr):
#     import math
#     gap=1
#     while(gap<len(arr)/3):  # 初始化一个gap
#         gap=gap*3+1
#
#     while gap>0:
#         for i in range(gap,len(arr)):
#             temp=arr[i]
#             j=i-gap
#             while j>=0 and arr[j]>temp:
#                 arr[j+gap]=arr[j]
#                 j -= gap
#             arr[j+gap]=temp
#         gap=math.floor(gap/3)
#     return arr


# 5、归并排序
# def mergeSort(arr):
#     import math
#     if(len(arr)<2):
#         return arr
#     middle=math.floor(len(arr)/2) #math.floor()返回数字的下舍整数,如3.2，返回3
#     left,right=arr[0:middle],arr[middle:] #切片是一个左闭右开的区间，不包括右边的下标
#     return merge(mergeSort(left),mergeSort(right))
#
# def merge(left,right):
#     result=[]
#     while left and right:
#         if left[0] < right[0]:
#             result.append(left.pop(0))
#         else:
#             result.append(right.pop(0))
#     while left:
#         result.append(left.pop(0))
#     while right:
#         result.append(right.pop(0))
#     return result


# 6、快速排序
# def quickSort(arr=[],left=None,right=None):
#     left=0 if not isinstance(left,(int,float)) else left
#     right=len(arr)-1 if not isinstance(right,(int,float)) else right
#     if left>=right:
#         return
#     pivot_index=partition_V3(arr,left,right)
#     quickSort(arr,left,pivot_index-1)
#     quickSort(arr,pivot_index+1,right)
# 快排分割方法1
# def partition_V1(arr,star_index,end_index):
#     pivot=arr[star_index]
#     left=star_index
#     right=end_index
#     while left<right:
#         while(left<right and arr[right]>pivot):
#             right-=1
#         if left<right:
#             arr[left]=arr[right]
#             left += 1
#         while(left<right and arr[left]<=pivot):
#             left+=1
#         if left<right:
#             arr[right]=arr[left]
#             right-=1
#     arr[left]=pivot
#     return left
# 快排分割方法2
# def partition_V2(arr, star_index, end_index):
#     pivot = arr[star_index]
#     left = star_index
#     right = end_index
#     while left != right:
#         while left < right and arr[right] > pivot:
#             right -= 1
#         while left < right and arr[left] <= pivot:
#             left += 1
#         if left < right:
#             arr[left], arr[right] = arr[right], arr[left]
#     arr[star_index] = arr[left]
#     arr[left] = pivot
#     return left
# 快排分割方法3
# def partition_V3(arr,star_index,end_index):
#     pivot=arr[star_index]
#     mark=star_index
#     for i in range(star_index+1,end_index+1):
#         if arr[i]<pivot:
#             mark += 1
#             arr[i],arr[mark]=arr[mark],arr[i]
#     arr[star_index]=arr[mark]
#     arr[mark]=pivot
#     return mark


# 7、堆排序
# def heapSort(arr=[]):
#     build_heap(arr)
#     for i in range(len(arr)-1,0,-1):
#         arr[i],arr[0]=arr[0],arr[i]
#         down_adjust(0,i,arr)
#     return arr
#
# def build_heap(arr):
#     '''
#     把无序数据构建为一个最大堆
#     '''
#     for i in range((len(arr)-2)//2,-1,-1):
#         down_adjust(i,len(arr),arr)
#
# def down_adjust(parent_index,length,arr=[]):
#     temp=arr[parent_index]
#     child_index=parent_index*2+1
#     while child_index<length:
#         if child_index+1<length and arr[child_index]<arr[child_index+1]:
#             child_index += 1
#         if temp>=arr[child_index]:
#             break
#         arr[parent_index]=arr[child_index]
#         parent_index=child_index
#         child_index=2*parent_index+1
#     arr[parent_index]=temp

# 8、计数排序
# def countSort(arr=[]):
#     max_value=max(arr) # 获取列表最大值
#     # 根据最大值确定数组的长度,如果最大值是8，则数组的长度要为9，即[0,8]
#     count_array=[0]*(max_value+1)
#     for i in range(0,len(arr)):
#         count_array[arr[i]] += 1 # 遍历数列，填充数组
#     # 遍历数组，输出结果
#     sorted_array=[] # 存放已经排好序的数列
#     for i in range(0,len(count_array)):
#         for j in range(0,count_array[i]):
#             sorted_array.append(i)
#     return sorted_array

# 8.1、计数排序优化
# def countSort_improve(arr=[]):
#     max_value=max(arr)
#     min_value=min(arr)
#     countarray_Length=max_value-min_value+1
#     # 当列表中的元素不是按顺序append进列表，而是根据下标赋值时，必须要对列表进行初始化
#     count_array=[0]*countarray_Length
#     for i in range(len(arr)):
#         count_array[arr[i]-min_value] += 1
#     for i in range(1,len(count_array)):
#         count_array[i]=count_array[i]+count_array[i-1]
#     sorted_array=[0]*len(arr)
#     for i in range(len(arr)-1,-1,-1):
#         sorted_array[count_array[arr[i]-min_value]-1]=arr[i]
#         count_array[arr[i]-min_value] -= 1
#     return sorted_array


# 9、桶排序
# def bucketSort(arr=[]):
#     max_value=max(arr)
#     min_value=min(arr)
#     d=max_value-min_value
#     bucket_num=len(arr)
#     # 区间跨度=(最大值-最小值)/(桶的数量-1)
#     bucket_range=d/(bucket_num-1)
#
#     # 初始化桶
#     # 创建的是一个列表的列表，所有桶都存放在bucket_list中，每个桶都是一个列表
#     # bucket_list=[[]]*bucket_num # 这样写不对，应用如下方法初始化桶
#     bucket_list=[]
#     for i in range(0,bucket_num):
#         bucket_list.append([])
#
#     # 遍历原始数组，将每个元素放入桶中
#     for i in range(0,len(arr)):
#         bucket_id=int((arr[i]-min_value)/bucket_range) # 求出当前元素应该放入哪个桶中
#         bucket=bucket_list[bucket_id]
#         bucket.append(arr[i]) # 把当前元素存入对应的桶中
#     for i in range(0,len(bucket_list)):
#         bucket_list[i].sort() # 对每一个桶中的元素进行排序,在这里直接调用了sort()
#
#     sorted_array=[]
#     for sub_list in bucket_list:
#         for element in sub_list:
#             sorted_array.append(element)
#     return sorted_array


# 10、基数排序
def RadixSort(arr=[]):
    i=0
    n=1
    max_value=max(arr)
    # 得到最大位数
    while max_value>10**n:
        n+=1
    while i<n: # 最大数有多少位就进行多少次循环
        bucket={} # 用字典构建桶
        for x in range(10):
            bucket.setdefault(x,[]) # setdefault()函数,如果键不存在于字典中,将会添加键并将值设为默认值。
        for x in arr: # 对每一位数进行排序
            radix=int((x/(10**i))%10) # 得到每位数的基数
            bucket[radix].append(x)
        # 把桶中的数据从第一个桶开始依次放入原始列表中
        j=0 # 原始列表计数变量
        for k in range(10):
            if len(bucket[k])!=0:
                for y in bucket[k]:
                    arr[j]=y
                    j += 1
        i+=1
    return arr

if __name__=='__main__':
    array = [3, 44, 38, 5, 15, 36, 46, 2, 48, 19]
    print(RadixSort(array))