排序算法（冒泡-选择-插入-希尔-快速-归并）

转载

mob60475703f08d 2021-08-24 23:29:00

文章标签 时间复杂度插入排序代码实现快速排序希尔排序 文章分类 数据结构与算法人工智能

冒泡排序

工作原理：
- 比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
- 针对所有的元素重复以上的步骤，除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
分析：
- 对于n个元素的序列，需要进行n-1次冒泡过程
- 冒泡过程每增加1次，该次冒泡过程中需要两两比较元素的次数就减少1次

代码实现：

def bubble_sort(alist):
    '''冒泡排序'''
    l = len(alist)
    for j in range(l-1):
        for i in range(l-1-j):
            if alist[i] > alist[i+1]:
                alist[i],alist[i+1] = alist[i+1],alist[i]
    return alist

时间复杂度
- 最优时间复杂度：O(n)
- 最坏时间复杂度：O(n²)
- 稳定性：稳定

选择排序

工作原理：
- 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
- 然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
- 以此类推，直到所有元素均排序完毕。

代码实现：

def select_sort(alist):
    '''选择排序'''
    l = len(alist)
    # 需要进行l-1轮选择操作
    for j in range(l-1):
        #记录最小元素下标
        min_index = j
        #从j位置开始，筛选出最小元素，然后放置到j位置
        for i in range(j+1,l):
            if alist[i] < alist[min_index]:
                min_index = i
        #如果数据不在正确位置，则进行交换
        if j != min_index:
            alist[j],alist[min_index] = alist[min_index],alist[j]
    return alist

时间复杂度
- 最优时间复杂度：O(n²)
- 最坏时间复杂度：O(n²)
- 稳定性：不稳定（比如5,5,2,第一遍选择选出2,然后2和5进行交互，则两个5的相对顺序会发生改变）

插入排序

工作原理：
- 通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
思路：
- 需要将原始序列分成两部分：有序部分和无序部分
- 初始情况下，有序部分为乱序序列的第一个元素，无序部分为剩下的n-1个元素
- 将无序部分的元素，逐一插入到有序部分的对应位置上

代码实现

def insert_sort(alist):
    '''插入排序'''
    #从下标为1的元素开始，逐个向前插入
    for i in range(1,len(alist)):
        # 从第i个元素开始与前面进行比较，比前面数小，则交换位置
        while i>0:
            if alist[i] < alist[i-1]:
                alist[i],alist[i-1] = alist[i-1],alist[i]
                i -= 1
            else:
                break
    return alist

希尔排序

希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。
工作原理：
- 将整个待排元素序列按照下标的指定增量进行分组，对每组使用直接插入排序算法排序；
- 随着增量逐渐减少，每组包含的元素越来越多，当增量减至1时，整个序列恰被分成一组，算法便终止。
思路：
- 首先要理解插入排序就是增量为1的希尔排序
- 实现插入排序的代码，将增量1改为gap（初始值len(alist) // 2）
- 循环执行插入排序的代码，每循环1次，增量gap减小为gap // 2
- 当增量减至1时，循环最后一次执行

代码实现：

def shell_sort(alist):
    '''希尔排序'''
    #初始增量
    gap = len(alist) // 2
    while gap >= 1:
        #按照指定增量进行插入排序
        for i in range(gap,len(alist)):
            while i > 0:
                if alist[i] < alist[i-gap]:
                    alist[i],alist[i-gap] = alist[i-gap],alist[i]
                    i -= gap
                else:
                    break
        #缩减增量
        gap //= 2
    return alist

时间复杂度
- 最坏时间复杂度：O(n²)
- 稳定性：不稳定（同插入排序）

快速排序

工作原理：
- 将序列中的第一个元素设为基准，赋值给mid变量
- 然后将序列中所有比基准小的元素移动到基准左侧，比基准大的元素移动到右侧
- 再按此方法对基准两侧的序列分别进行快速排序
- 整个排序过程可以递归进行，以此达到整个序列变成有序序列。
思路：
- 定义两个指针：low指向序列起始元素，high指向序列末位元素
- 将序列中的起始元素定为基准元素
- 首先移动右侧指针，当指针指向的元素比基准小时停止移动，将该元素移动到左指针位置上，然后开始移动左侧指针，否则继续移动，直到左右两个指针重合
- 移动左侧指针时，当指针指向的元素大于基准时停止移动，将该元素移动到右指针位置上，然后开始移动右侧指针，否则继续移动，直到左右两个指针重合
- 两指针位置重合时，将基准元素放置在该重合位置上，基准左侧的元素均小于它，右侧的元素均大于它
- 然后分别让基准左右两侧的序列递归执行上述过程

代码实现

# coding:utf-8

def quick_sort(alist,left,right):
    '''快速排序'''
    #递归退出条件
    if right <= left:
        return
    mid = alist[left] #序列起始元素为基准
    low = left #左指针
    high = right #右指针
    #左右指针未重合时，循环执行
    while low < high:
        #先移动右侧指针
        while low < high:
            if alist[high] >= mid:
                high -= 1
            else:
                alist[low] = alist[high]
                break
        #再移动左侧指针
        while low < high:
            if alist[low] <= mid:
                low += 1
            else:
                alist[high] = alist[low]
                break
    alist[low] = mid #左右指针重合，将基准放置到重合位置上
    quick_sort(alist,left,low-1) #基准左侧序列进行快速排序
    quick_sort(alist,high+1,right) #基准右侧序列进行快速排序

if __name__ == '__main__':
    alist = [4,2,7,6,8,1,9,3,5,0]
    quick_sort(alist,0,len(alist)-1)
    print(alist)

时间复杂度
- 最优时间复杂度：O(nlogn)
- 最坏时间复杂度：O(n²)
- 稳定性：不稳定

归并排序

归并排序是采用分治法的一个非常典型的应用，归并排序的思想就是先递归分解序列，再合并序列。
思路：
- 将序列从中间位置分解成两个数列
- 再将这两个子序列按照第一步继续二分下去
- 直到所有子序列的长度都为1时，再两两合并成一个有序序列
  - 基本思路：比较两个序列的最前面的数，谁小就先取谁，取了后相应的指针就往后移一位。
  - 然后再比较，直至一个序列为空，最后把另一个序列的剩余部分复制过来即可。

代码实现

def merge_sort(alist):
    n = len(alist)
    #结束递归的条件
    if n <= 1:
        return alist
    #中间索引
    mid = n//2

    left_li = merge_sort(alist[:mid])
    right_li = merge_sort(alist[mid:])

    #指向左右表中第一个元素的指针
    left_pointer,right_pointer = 0,0
    #合并数据对应的列表：该表中存储的为排序后的数据
    result = []
    while left_pointer < len(left_li) and right_pointer < len(right_li):
        #比较最小集合中的元素，将最小元素添加到result列表中
        if left_li[left_pointer] < right_li[right_pointer]:
            result.append(left_li[left_pointer])
            left_pointer += 1
        else:
            result.append(right_li[right_pointer])
            right_pointer += 1
    #当左右表的某一个表的指针偏移到末尾的时候，比较大小结束，将另一张表中的数据（有序）添加到result中
    result += left_li[left_pointer:]
    result += right_li[right_pointer:]
    return result