python十大排序代码整理待续...

冒泡排序 ：

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

选择排序 ：

def selectSort(list1):
    for i in range(len(list1)-1):
        min = i    #已排序好的序列的最后一个元素的下标i
        for j in range(i+1,len(list1)):
            if list1[min] > list1[j]:  #找出未排序的序列中最小的元素的下标min
                min = j
        if min != i:   # 对应的元素值交换
            list1[i], list1[min] = list1[min], list1[i]

插入排序： 

def insertSort(list1):
    for i in range(1,len(list1)):
        if list1[i] < list1[i-1]:  #当前要排序的元素比前面的小
            index = i              #保存当前元素的下标，这个变量是用来记录排序元素需要插入的位置
            temp = list1[i]        #保存当前元素的值
            while index > 0 and list1[index-1] > temp:   #找到正确的排序位置
                list1[index] = list1[index-1]   #如果前面的比当前元素值大，就往后移动一位
                index -= 1
            if index != i:
                list1[index] = temp

希尔排序：

def shellSort(list1): # 希尔排序
    # 设定步长
    step = len(list1)//2
    while step > 0:
        for i in range(step, len(list1)):
            # 类似插入排序, 当前值与指定步长之前的值比较, 符合条件则交换位置
            while i >= step and list1[i-step] > list1[i]:
                list1[i], list1[i-step] = list1[i-step], list1[i]
                i -= step
        step = step//2   #步长值改为之前的二分之一

快速排序：

def parttion(list1,left,right): # 找到中间那个数
    key = list1[left] #以第一个数组元素作为关键数据
    while left < right:
        # 由后开始向前搜索(right--)，找到第一个小于key的值A[right]，将A[left]和A[right]互换
        while left < right and list1[right] >= key:
            right -= 1
        list1[left] = list1[right]
        # 由前开始向后搜索(left++)，找到第一个大于key的A[left]，将A[right]和A[left]互换；
        while left < right and list1[left] <= key:
            left += 1
        list1[right] = list1[left]
        list1[left] = key
    return left

def quickSort1(list1,left,right):
    if left < right:
        # 先对序列排序，并找到一个元素A，这个元素的特点是：左边的所有元素<=A,右边的所有元素>=A
        p = parttion(list1,left,right)
        quickSort(list1,left,p)  #对A的左边进行递归，重复过程parttion()
        quickSort(list1,p+1,right) #对A的右边进行递归，重复过程parttion()
quickSort1(list1,0,len(list1)-1)


def quickSort2(list1):
    stack = []
    stack.append(0)
    stack.append(len(list1)-1)
    while stack:
        high = right = stack.pop()
        low = left = stack.pop()
        if low == high:
            continue
        key = list1[left]
        while left < right:
            while left < right and list1[right] >= key:
                right -= 1
            list1[left] = list1[right]
            while left < right and list1[left] <= key:
                left += 1
            list1[right] = list1[left]
            list1[left] = key

        if left - 1 > low:
            stack.append(low)
            stack.append(left-1)
        if left +1 < high:
            stack.append(left+1)
            stack.append(high)

归并排序：

def merge(left,right ):
    # 从两个有顺序的列表里边依次取数据比较后放入result
    # 每次我们分别拿出两个列表中最小的数比较，把较小的放入result
    result = []
    while len(left)>0 and len(right)>0 :
        #为了保持稳定性，当遇到相等的时候优先把左侧的数放进结果列表，因为left本来也是大数列中比较靠左的
        if left[0] <= right[0]:
            result.append( left.pop(0) )
        else:
            result.append( right.pop(0) )
    #while循环出来之后 说明其中一个数组没有数据了，我们把另一个数组添加到结果数组后面
    result += left
    result += right
    return result
def mergeSort( li ):
    #不断递归调用自己一直到拆分成成单个元素的时候就返回这个元素，不再拆分了
    if len(li) == 1:
        return li

    #取拆分的中间位置
    mid = len(li) // 2
    #拆分过后左右两侧子串
    left = li[:mid]
    right = li[mid:]

    #对拆分过后的左右再拆分 一直到只有一个元素为止
    #最后一次递归时候ll和lr都会接到一个元素的列表
    # 最后一次递归之前的ll和rl会接收到排好序的子序列
    ll = mergeSort( left )
    rl = mergeSort( right )

    # 我们对返回的两个拆分结果进行排序后合并再返回正确顺序的子列表
    # 这里我们调用拎一个函数帮助我们按顺序合并ll和lr
    return merge(ll , rl)

堆排序：

def heapSort(list1) :
    n = len(list1)
    first = n//2-1
    for start in range(first,-1,-1) :     #构造大根堆
        maxHeapify(list1,start,n-1)
    for end in range(n-1,0,-1):           #堆排，将大根堆转换成有序数组
        list1[end],list1[0] = list1[0],list1[end]
        maxHeapify(list1,0,end-1)

#最大堆调整：将堆的末端子节点作调整，使得子节点永远小于父节点
#start为当前需要调整最大堆的位置，end为调整边界
def maxHeapify(list1,start,end):
    root = start
    while True :
        child = root*2 +1               #调整节点的子节点
        if child > end : break
        if child+1 <= end and list1[child] < list1[child+1] :
            child = child+1             #取较大的子节点
        if list1[root] < list1[child] :     #较大的子节点成为父节点
            list1[root],list1[child] = list1[child],list1[root]     #交换
            root = child
        else :
            break

基数排序：

def radixSort(list1,d): #基数排序
    for i in range(d):#多少位数就进行几轮排序
        s = [[] for x in range(10)]  # 因为每一位数字都是0~9，故建立10个桶
        for j in list1:
            s[j//(10**i)%10].append(j)  #第一次取个位数，第二次取十位数，第三次取百位数
        list1 = [k for t in s for k in t] #遍历二维列表s中的元素，赋值给list1
    return list1

桶排序：

def bucketSort(list1): #桶排序
    maxNum = max(list1)
    minNum = min(list1)
    bucket = [0] *(maxNum-minNum+1) #创建一个桶列表，长度为要排序的列表中最大的数与最小的数的差加1
    for i in list1:
        bucket[i-minNum] += 1  #把要排序的列表中的元素放到相应下标的桶中
    list2 = []
    for i in range(len(bucket)):   #遍历桶列表，输出排序好的新列表
        if bucket[i] != 0:
            list2 += [i + minNum] * bucket[i]  #对桶列表中的元素进行计数，有几个就加几个相同的元素
    return list2