常见排序算法的python实现

#冒泡排序和选择排序
def bubbleSort(alist):
    for i in range(len(alist)-1,0,-1):
        for j in range(i):
            if alist[j] > alist[j+1]:
                alist[j],alist[j+1] = alist[j +1],alist[j]
    return alist

alist = [1,8,3,5,9]
bubbleSort(alist)
print(bubbleSort(alist))

#选择排序
def selectionSort(alist):
    for i in range(len(alist)-1,0,-1):
        maxindex = 0
        for j in range(1,i+1):
            if alist[j] > alist[maxindex]:
                maxindex = j
        alist[i],alist[maxindex] = alist[maxindex],alist[i]
alist = [1,8,3,5,9,16,22,99,2,100]
selectionSort(alist)
print(alist)
#插入排序
def insertionSort(alist):
    for index in range(len(alist)):
        currentValue = alist[index]
        while index > 0 and alist[index - 1] > currentValue:
            alist[index] = alist[index - 1]
            index = index - 1
        alist[index] = currentValue
alist = [8,6,3,3,3,5]
insertionSort(alist)
print(alist)

#谢尔排序
def shell_sort(alist):
    n = len(alist)
    #初始步长
    step = n // 2
    while step > 0:
        #按步长进行插入排序
        for i in range(step,n):
            j = i
            #插入排序
            while j >= step and alist[j-step] > alist[j]:
                alist[j-step] ,alist[j] = alist[j],alist[j-step]
                j -= step
        #得到新的步长
        step = step // 2
    return alist
alist = [1,8,3,5,9,16,22,99,2,100]
print(shell_sort(alist))
#归并排序
def merge_sort(list):
    if len(list) <= 1:
        return list
    middle = len(list) // 2
    left = merge_sort(list[:middle])
    right = merge_sort(list[middle:])

    merged = []
    while left and right:
        if left[0] <= right[0]:
            merged.append(left.pop(0))
        else:
            merged.append(right.pop(0))
    merged.extend(right if right else left)
    return merged
list = [1,8,3,5,9,16,22,99,2,100]
print(merge_sort(list))

#快速排序
def quickSort(alist,first,last):
    if first < last:
        splitpoint = partition(alist,first,last)
        quickSort(alist,first,splitpoint-1)
        quickSort(alist,splitpoint+1,last)

def partition(alist,first,last):
    pivotvalue = alist[first]
    leftmark = first + 1
    rightmark = last
    done = False
    while not done:
        while rightmark >= leftmark and alist[leftmark] <= pivotvalue:
            leftmark += 1
        while rightmark >= leftmark and alist[rightmark] >= pivotvalue:
            rightmark -= 1
        if rightmark < leftmark:
            done = True
        else:
            alist[rightmark], alist[leftmark] = alist[leftmark], alist[rightmark]
    alist[first],alist[rightmark] = alist[rightmark],alist[first]
    return rightmark

list = [31,556,26,20,17,55]
quickSort(list,0,len(list)-1)
print(list)