标签：递归调用   位置   子列   计数排序   sel   sele   列表切片   ble   基础算法   

前言：

冒泡，选择：使用了普通双指针法

插入，快速，归并：使用了二分法，递归

冒泡排序

原理：不断比较相邻两个数得大小，把较大的数交换到靠后的位置

def bubbleSort(iList):
    ‘‘‘冒泡排序 ‘‘‘
    if len(iList) <= 1:
        return iList
    for i in range(1, len(iList)):
        for j in range(0, len(iList)-i): 
            # 原理：不断比较相邻两个数得大小，把较大的数交换到靠后的位置
            if iList[j] >= iList[j+1]: #比较相邻两数的大小
                iList[j], iList[j+1] = iList[j+1], iList[j] #将大数交换到靠后的位置
        # print("第 %d 轮排序结果:" %i, end="")
        # print(iList)
    return iList

选择排序

原理

 # 借助了min函数和列表切片
 # 不断从列表中选出最大或者最小的数，放到合适的位置
 # 然后再抛出这个数的子数列中找最大(最小)的数，并放到合适的位置（采用覆盖列表值<==这个经常再排序中用到）
 # 直到子数列为空

代码

def selectionSort(iList):
    if len(iList) <= 1:
        return iList
    for i in range(0, len(iList)-1):
        # 借助了min函数和列表切片
        # 不断从列表中选出最大或者最小的数，放到合适的位置
        # 然后再抛出这个数的子数列中找最大(最小)的数，并放到合适的位置（采用覆盖列表值<==这个经常再排序中用到）
        # 直到子数列为空
        if iList[i] != min(iList[i:]): #使用min函数找到剩余数列中最小的那个数
            minIndex = iList.index(min(iList[i:])) #minIndex是最小数的序号(下标)
            iList[i], iList[minIndex] = iList[minIndex], iList[i]
        # print("第 %d 轮排序结果:" %(i+1), end="")
        # print(iList)
    return iList

插入排序

# 原理：将数列分成两部分，第一个时left部分，其余的数为right部分
        # 将right部分逐一取出，插入left部分中合适的位置
        # 当left部分为空时，left部分就成了一个有序数列

代码

def insertionSort(iList):
    if len(iList) <= 1:
        return iList
    for right in range(1, len(iList)):
        # 原理：将数列分成两部分，第一个时left部分，其余的数为right部分
        # 将right部分逐一取出，插入left部分中合适的位置
        # 当left部分为空时，left部分就成了一个有序数列
        target = iList[right]
        for left in range(0, right):
            if target <= iList[left]:
                # 下面这句为什么往后移一位没弄懂
                iList[left+1:right+1] = iList[left:right] # 比target大的left部分整体后移一位
                iList[left] = target  # 使用Python的切片赋值
                break
        # print("第 %d 轮排序结果:" %(right), end="")
        # print(iList)
    return iList

归并排序

原理

原理：无限的的把左右序列变成两个子数列，然后将左右两个子数列排序完毕后(这里的子数列分成了1个单位)
    # 在合并到一起就完成了一个有序序列

代码

def mergeSort(iList):
    # 原理：无限的的把左右序列变成两个子数列，然后将左右两个子数列排序完毕后(这里的子数列分成了1个单位)
    # 在合并到一起就完成了一个有序序列
    if len(iList) <= 1:
        return iList
    # 列表指数为基数时拆分列表
    middle = len(iList)//2
    left, right = iList[0:middle], iList[middle:]
    return mergeList(mergeSort(left), mergeSort(right))

def mergeList(left, right):
    mList = []
    while left and right:
        if left[0] >= right[0]:
            mList.append(right.pop(0))
        else:
            mList.append(left.pop(0))
    # 下面没搞懂 删除的话  就是错误排序      
    # 下面的left,right为真,取出该数列中的第一个元素
    while left:
        mList.append(left.pop(0))
    while right:
        mList.append(right.pop(0))
    return mList

快速排序

原理

原理:以列表中的任意一个数为基准，将列表分成左右两个字列表
        # 左列表的数要比基数小
        # 右列表的数要比基数大
        # 然后继续把左子列表，右子列表按同样的方式分解，比较，直到分无可分为止
        # 一般的话基数为索引第一个

代码

def quickSort(iList):
    if len(iList) <= 1:
        return iList
    left = []
    right = []
    for i in iList[1:]: # 这里不设置0的话,iList的要为多少呢[],难道说只要比基准数大1；不设置0的话，设置1就会比0少一半得出的数据；
        # 原理:以列表中的任意一个数为基准，将列表分成左右两个字列表
        # 左列表的数要比基数小
        # 右列表的数要比基数大
        # 然后继续把左子列表，右子列表按同样的方式分解，比较，直到分无可分为止
        # 一般的话基数为索引第一个
        if i <= iList[0]:
            left.append(i)
        else:
            right.append(i)
    return quickSort(left) + [iList[0]] + quickSort(right) # 这里递归

计数排序

原理

原理：在一个相同的索引i下，求出有多少个数比i小，然后再把该i索引的值写入多少个数对应的索引值

代码

def countingSort(iList):
    if len(iList) <= 1:
        return iList
    iLen = len(iList)
    rList = [None]*iLen
    for i in range(iLen): # 好经典
        small = 0 #比基数小的
        same = 0 #与基数相等的
        for j in range(iLen):
            if iList[j] < iList[i]: # 这个是判断出有多少个数比身为i索引时小
                small += 1 # 但这个数字加不会越来越多么，在一个循环中
            elif iList[j] == iList[i]: #相同的数
                same += 1
        for k in range(small, small+same): # 这个就是怎么把对应的数插在对应索引下么
            # 原理：在一个相同的索引i下，求出有多少个数比i小，然后再把该i索引的值写入多少个数对应的索引值
            rList[k] = iList[i] # 这个i有点狠，还在i的循环里
    return rList

没搞懂的地方：

插入排序

 iList[left+1:right+1] = iList[left:right] # 比target大的left部分整体后移一位

归并排序

# 下面没搞懂 删除的话  就是错误排序      
    # 下面的left,right为真,取出该数列中的第一个元素
    while left:
        mList.append(left.pop(0))
    while right:
        mList.append(right.pop(0))
    return mList

知识点：

 # 列表指数为奇数时拆分列表
    middle = len(iList)//2
    left, right = iList[0:middle], iList[middle:]

# 创建双指针
for i in range(1, len(iList)):
        for j in range(0, len(iList)-i): 

# 递归调用本身函数
def mergeSort(iList):
    # 原理：无限的的把左右序列变成两个子数列，然后将左右两个子数列排序完毕后(这里的子数列分成了1个单位)
    # 在合并到一起就完成了一个有序序列
    if len(iList) <= 1:
        return iList
    # 列表指数为奇数时拆分列表
    middle = len(iList)//2
    left, right = iList[0:middle], iList[middle:]
    return mergeList(mergeSort(left), mergeSort(right))

基础算法之排序

标签：递归调用   位置   子列   计数排序   sel   sele   列表切片   ble   基础算法   

原文地址：https://www.cnblogs.com/wkhzwmr/p/15017547.html