数据结构与算法（python版）之排序

一、冒泡排序

1.冒泡排序

2.冒泡排序程序

def bubbleSort(alist):
    for passNum in range(len(alist)-1,0,-1):
        for i in range(0,passNum):
            if alist[i]>alist[i+1]:
                #python中交换还可以这么写
                #alist[i],alist[i+1]=alist[i+1],alist[i]
                temp=alist[i]
                alist[i]=alist[i+1]
                alist[i+1]=temp
    return alist
alist=[54,26,93,17,77,31,44,55,20]
print(bubbleSort(alist))

3.冒泡排序算法分析

4.冒泡排序性能改进

5.冒泡排序性能改进程序

def bubbleSortPro(alist):
    exchange=True
    passNum=len(alist)-1
    while passNum>0 and exchange:
        exchange=False
        for i in range(0,passNum):
            if alist[i]>alist[i+1]:
                #python中交换还可以这么写
                #alist[i],alist[i+1]=alist[i+1],alist[i]
                exchange=True
                temp=alist[i]
                alist[i]=alist[i+1]
                alist[i+1]=temp
        passNum=passNum-1
    return alist
alist=[54,26,93,17,77,31,44,55,20]
print(bubbleSortPro(alist))

二、选择排序

1.选择排序

2.选择排序程序

def selectionSort(alist):
    for passNum in range(len(alist)-1,0,-1):
        maxPos=0
        for i in range(1,passNum+1):
            if alist[i]>alist[maxPos]:
                maxPos=i
        temp=alist[maxPos]
        alist[maxPos]=alist[passNum]
        alist[passNum]=temp
    return alist

alist=[54,26,93,17,77,31,44,55,20]
print(selectionSort(alist))

三、插入排序

1.插入排序

2.插入排序的思路

3.插入排序程序

def insertionSort(alist):
    for index in range(1,len(alist)):
        currentValue=alist[index]
        position=index
        while position>0 and alist[position-1]>currentValue:
            alist[position]=alist[position-1]
            position=position-1
        alist[position]=currentValue
    return alist
alist=[54,26,93,17,77,31,44,55,20]
print(insertionSort(alist))

四、谢尔排序

1.谢尔排序

2.谢尔排序思路

3.谢尔排序程序

def shellSort(alist):
    sublistcount=len(alist)//2
    while sublistcount>0:
        for startPosition in range(sublistcount):
            gapInsertionSort(alist,startPosition,sublistcount)
        print("After increments of size",sublistcount,"The list is",alist)
        sublistcount=sublistcount//2
    return alist

def gapInsertionSort(alist,start,gap):
    for i in range(start+gap,len(alist),gap):
        currentValue=alist[i]
        position=i
        while position>=gap and alist[position-gap]>currentValue:
            alist[position]=alist[position-gap]
            position=position-gap
        alist[position]=currentValue

alist=[54,26,93,17,77,31,44,55,20]
print(shellSort(alist))

4.谢尔排序分析

五、归并排序

1.归并排序

2.归并排序的程序

def mergeSort(alist):
    if len(alist)>1:
        mid=len(alist)//2
        leftHalf=alist[:mid]
        rightHalf=alist[mid:]
        mergeSort(leftHalf)
        mergeSort(rightHalf)
        i=j=k=0
        while i<len(leftHalf) and j<len(rightHalf):
            if leftHalf[i]<rightHalf[j]:
                alist[k]=leftHalf[i]
                i=i+1
            else:
                alist[k]=rightHalf[j]
                j=j+1
            k=k+1

        while i<len(leftHalf):
            alist[k]=leftHalf[i]
            i=i+1
            k=k+1

        while j<len(rightHalf):
            alist[k]=rightHalf[j]
            j=j+1
            k=k+1
    return alist

alist=[54,26,93,17,77,31,44,55,20]
print(mergeSort(alist))

另一个更python化的代码：

3.归并算法分析

六、快速排序

1.快速排序

2.快速排序图示

2.快速排序程序

def quickSort(alist):
    quickSortHelper(alist,0,len(alist)-1)
    return alist

def quickSortHelper(alist,first,last):
    if first<last:
        splitPoint=partition(alist,first,last)
        quickSortHelper(alist,first,splitPoint-1)
        quickSortHelper(alist,splitPoint+1,last)

def partition(alist,first,last):
    pivotValue=alist[first]
    leftMark=first+1
    rightMark=last
    done=False

    while not done:
        while leftMark<=rightMark and alist[leftMark]<pivotValue:
            leftMark=leftMark+1

        while leftMark<=rightMark and alist[rightMark]>pivotValue:
            rightMark=rightMark-1

        if leftMark>rightMark:
            done=True
        else:
            temp = alist[leftMark]
            alist[leftMark] = alist[rightMark]
            alist[rightMark] = temp

    temp=alist[first]
    alist[first]=alist[rightMark]
    alist[rightMark]=temp
    return rightMark

alist=[54,26,93,17,77,31,44,55,20]
print(quickSort(alist))

3.快速排序算法分析

七、小结