八大排序算法

def bubbleSort(myList):  # 冒泡算法的反向递减
    length = len(myList)
    for i in range(length - 1, 0, -1):  # 冒泡是从最底下往上冒,越往后比的越少
        tag = False  # 打个标记False,判断有没有哪一次不需要交换值
        for j in range(i):
            if myList[j] > myList[j+1]:
                myList[j], myList[j+1] = myList[j+1], myList[j]
                tag = True  # 如果交换了值,就将标记打为True
        if not tag:  # 如果存在一次不用交换位置,后面就不用循环了,肯定是有序的
            break


test_list = [8,9, 0, 1, 2, 3, 4]
bubbleSort(test_list)
print(test_list)
冒泡排序
def insertSort(myList):
    for i in range(len(myList)):
        currentValue = myList[i]  # 将要排序的值取出来,留个空位
        pointer = i  # 指针指向该空位

        while pointer > 0 and myList[pointer - 1] > currentValue:  #当前值与指正前的位置比较
            myList[pointer] = myList[pointer - 1]  # 大的值右移,腾出空格
            pointer = pointer - 1  # 指针指向空格

        myList[pointer] = currentValue  # 将插入值放到指针的位置


test_list = [8, 7, 9, 5, 4, 3, 8, 2, 6, 1, 0]
insertSort(test_list)
print(test_list)
插入排序
def mergeSort(myList):
    if len(myList) == 1:  # 递归的终止条件,长度为1,不可再分
        return myList

    mid = len(myList) // 2

    left = mergeSort(myList[:mid])  # 左半部分
    right = mergeSort(myList[mid:])  # 右半部分,奇数情况时,右多一个

    # 接下来是merge的主要部分(合并)
    sortList = []  # 开辟一个新的内存地址
    while left and right:
        if left[0] < right[0]:
            sortList.append(left.pop(0))  # 列表的扩充,不可以直接赋值,必须使用append或者extend
        else:
            sortList.append(right.pop(0))  # 列表的扩充,不可以直接赋值,必须使用append或者extend
        '''
        sortList[count] = ss  # 列表的扩充,不可以直接赋值,必须使用append或者extend
        count += 1
        '''

    sortList.extend(left if left else right)
    return sortList


test_list = [8, 7, 9, 5, 4, 3, 2, 6, 1, 0]
a = mergeSort(test_list)
print(a)
归并排序
# 快速排序   递归加找中值

def quickSort(myList):
    helpSort(myList, 0, len(myList) - 1)  # 传列表和起始位置的下标


def helpSort(myList, first, last):
    if first < last:
        mid = partition(myList, first, last)
        helpSort(myList, first, mid - 1)
        helpSort(myList, mid + 1, last)


def partition(myList, left, right):  # 划分函数
    midValue = myList[left]
    leftPointer = left + 1  # 这里加1 是因为将第一个元素设置为中值。
    rightPointer = right
    tag = False
    while not tag:
        while leftPointer <= rightPointer and myList[leftPointer] <= midValue:  # 左指针的操作
            leftPointer += 1
        while leftPointer <= rightPointer and myList[rightPointer] >= midValue:  # 右指正的操作
            rightPointer -= 1
        if leftPointer > rightPointer:  # 终止条件一定是左指针在右指针的右边
            tag = True
        else:
            myList[leftPointer], myList[rightPointer] = myList[rightPointer], myList[leftPointer]  # 交换左右的值
    # 此时,左指正在右指针的右边
    myList[left], myList[rightPointer] = myList[rightPointer], myList[left]
    return rightPointer  # 这里是右指针的位置(下标)


test_list = [8, 7, 9, 5, 4, 3, 8, 8, 2, 6, 1, 0]
quickSort(test_list)
print(test_list)
快速排序
def selectSort(myList):
    for i in range(len(myList) - 1, 0, -1):
        maxpointer = 0
        for j in range(i):
            if myList[j] > myList[maxpointer]:
                maxpointer = j

        myList[i], myList[maxpointer] = myList[maxpointer], myList[i]  # 每次只做一次调换


test_list = [8, 9, 0, 1, 2, 3, 4]
selectSort(test_list)
print(test_list)
选择排序
def shellSort(myList):  # 希尔排序是基于插入排序衍生的
    length = len(myList)
    step = length // 2
    while step:
        for i in range(step):  # 步长是几,就会产生几个子列表,这里是在循环子列表
            insertSort(myList, i, step, length)  # 调用排序算法
        step = step // 2


def insertSort(myList, start, step, length):
    for j in range(start + step, length, step):  # 起步是子列表的第2个数,(start是第一个数)
        currentValue = myList[j]
        position = j  # position是定位最小值的

        while position >0 and currentValue < myList[position - step]:  # 移动position指针位置的条件
            myList[position] = myList[position - step]
            position = position - step
        myList[position] = currentValue


test_list = [8,7,9,5,4,3,2,6,1,0]
shellSort(test_list)
print(test_list)
希尔排序

 

posted @ 2020-04-03 01:15  HEU葉孤城  阅读(132)  评论(0编辑  收藏  举报