11_python_Merge Sort and Quick Sort

最新推荐文章于 2024-07-26 00:37:11 发布

菜丁儿

最新推荐文章于 2024-07-26 00:37:11 发布

阅读量168

点赞数

分类专栏： Python数据结构文章标签：排序算法数据结构

本文链接：https://blog.csdn.net/weixin_43712064/article/details/104364351

版权

Python数据结构专栏收录该内容

13 篇文章 0 订阅

订阅专栏

文章目录

归并排序
快速排序
- 代码
- 时间复杂度分析
排序算法总结

归并排序

归并排序：分治策略在排序中的应用
归并排序是递归算法，思路是将数据表持续分裂为两半，对两半分别进行归并排序
- 基本结束条件：数据表仅有1个数据项，自然是排好序的
- 缩小规模：将数据表分裂为相等的两半，规模减为原来的二分之一
- 调用自身：将两半分别调用自身排序，然后将分别排好序的两半进行归并，得到排好序的数据表

普通版代码

def mergeSort(alist):
    print("Splitting: ", 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
    print("Merging: ", alist)
    print("----------------------------------------")
    
alist = [9, 3, 0, 34, 10, 2, 1, 6, 8, 6]
mergeSort(alist)

Splitting:  [9, 3, 0, 34, 10, 2, 1, 6, 8, 6]
Splitting:  [9, 3, 0, 34, 10]
Splitting:  [9, 3]
Splitting:  [9]
Merging:  [9]
----------------------------------------
Splitting:  [3]
Merging:  [3]
----------------------------------------
Merging:  [3, 9]
----------------------------------------
Splitting:  [0, 34, 10]
Splitting:  [0]
Merging:  [0]
----------------------------------------
Splitting:  [34, 10]
Splitting:  [34]
Merging:  [34]
----------------------------------------
Splitting:  [10]
Merging:  [10]
----------------------------------------
Merging:  [10, 34]
----------------------------------------
Merging:  [0, 10, 34]
----------------------------------------
Merging:  [0, 3, 9, 10, 34]
----------------------------------------
Splitting:  [2, 1, 6, 8, 6]
Splitting:  [2, 1]
Splitting:  [2]
Merging:  [2]
----------------------------------------
Splitting:  [1]
Merging:  [1]
----------------------------------------
Merging:  [1, 2]
----------------------------------------
Splitting:  [6, 8, 6]
Splitting:  [6]
Merging:  [6]
----------------------------------------
Splitting:  [8, 6]
Splitting:  [8]
Merging:  [8]
----------------------------------------
Splitting:  [6]
Merging:  [6]
----------------------------------------
Merging:  [6, 8]
----------------------------------------
Merging:  [6, 6, 8]
----------------------------------------
Merging:  [1, 2, 6, 6, 8]
----------------------------------------
Merging:  [0, 1, 2, 3, 6, 6, 8, 9, 10, 34]
----------------------------------------

Pythonic版代码

extend()函数：用于在列表末尾一次性追加另一个序列中的多个值（用新表扩展原来的列表）
- 语法：list.extend(seq)
- 参数seq：待追加的元素列表
- 返回值：没有返回值，但会在已存在的列表中添加新的列表内容。

aList = [123, 'xyz', 'zara', 'abc', 123];
bList = [2009, 'manni'];
aList.extend(bList)

print ("Extended List : ", aList )

Extended List :  [123, 'xyz', 'zara', 'abc', 123, 2009, 'manni']

def merge_sort(lst):
    
    #基本结束条件
    if len(lst) <= 1: 
        return lst
    
    #分解问题，并递归调用
    middle = len(lst) // 2
    left = merge_sort(lst[:middle])  #左半部分排序
    right = merge_sort(lst[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

alist = [9, 3, 0, 34, 10, 2, 1, 6, 8, 6]
merge_sort(alist)

[0, 1, 2, 3, 6, 6, 8, 9, 10, 34]

时间复杂度分析

归并排序的时间复杂度为：O(nlog n)
将归并排序分为两个过程来分析：分裂和归并
- 分裂：借鉴二分查找中的分析结果，是对数复杂度，时间复杂度为：O(log n)
- 归并：相对于分裂的每个部分，其所有数据项都会被比较和放置一次，所以是线性复杂度，其时间复杂度为：O(n)
- 综合考虑，每次分裂的部分都进行一次O(n)的数据项归并，总的时间复杂度是：O(nlog n)

归并排序使用两个切片操作，为了时间复杂度分析精度，可以通过取消切片操作，改为传递两个分裂部分的起始点和终止点，也是没问题的，只是会降低算法可读性。
归并排序算法使用了额外1倍的存储空间用于归并

快速排序

快速排序的思路是依据一个‘中值’数据项把数据表分为两半：小于中值的一半和大于中值的一半，然后每部分分别进行快速排序（递归）。
- 基本结束条件：数据表仅有1个数据项，自然是排好序的
- 缩小规模：根据中值，将数据表分为两半，最好情况是相等规模的两半
- 调用自身：将两半分别调用自身进行排序（排序基本操作在分裂过程中）

中值取值：如果希望这两半拥有相等数量的数据项，则应该找到数据表的中位数，但是找中位数需要计算开销！要想没有开销，只能随意找一个数来充当中值（一般找列表中的第一个数据项）。
分裂数据表的目标：找到‘中值’的位置
手段：
- 设置左右标，左标向右移动，右标向左移动
  - 左标一直向右移动，碰到比中值大的就停止
  - 右标一直向左移动，碰到比中值小的就停止
  - 然后把左右标所指的数据项交换
- 继续移动，直到左标移动到右标的右侧，停止移动
- 此时，右标所指位置就是‘中值’应处的位置，将中值和这个位置的数据项交换
- 分裂完成，左半部分比中值小，右半部分比中值大

代码

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

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 rightmark >= leftmark and alist[rightmark] >= pivotvalue:  #向左移动右标
            rightmark = rightmark - 1
        
        if rightmark < leftmark: #两标相错就结束移动
            done = True
        else:
            alist[leftmark],alist[rightmark] = alist[rightmark],alist[leftmark]   #左右标的值交换
    
    alist[first],alist[rightmark] = alist[rightmark],alist[first]  #中值就位
    
    return rightmark  #中值点，即分裂点
        
alist = [54, 26, 93, 17, 77, 31, 44, 55, 20]
quickSort(alist)
print(alist)

[17, 20, 26, 31, 44, 54, 55, 77, 93]

时间复杂度分析

快速排序的时间复杂度为：O(nlog n)
快速排序过程分为两部分：分裂和移动
- 分裂：如果分裂总能把数据表分为相等的两部分，那么就是O(log n)的复杂度
- 移动：移动需要将每项都与中值进行比对，还是O(n)

优点：算法运行过程中不需要额外的存储空间
缺点：如果中值所在的分裂点过于偏离中部，造成左右两部分数量不平衡。极端情况下，有一部分始终没有数据，这样时间复杂度退化为O(n^2)。还需要加上递归调用的开销（比冒泡排序还糟糕）。

改进中值的选取方法，让中值更有代表性
- 三点取样：从数据表的头、尾、中间选出中值。=>会产生额外计算开销，仍然不能排除极端情况

排序算法总结

算法总结参考网址
在这里插入图片描述

排序算法有时候并不存在绝对的优劣，尤其是时间复杂度相同的算法们。
要在特定的应用场合取得最高排序性能的话，还需要对数据本身进行分析，针对数据的特性来选择相应排序算法。
有时空间复杂度也是需要考虑的关键因素。或许还要考虑包括运行环境要求、处理数据对象的特性等各方面的因素。

菜丁儿

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
11_python_Merge Sort and Quick Sort

文章目录归并排序普通版代码Pythonic版代码时间复杂度分析快速排序代码时间复杂度分析排序算法总结归并排序归并排序：分治策略在排序中的应用归并排序是递归算法，思路是将数据表持续分裂为两半，对两半分别进行归并排序基本结束条件：数据表仅有1个数据项，自然是排好序的缩小规模：将数据表分裂为相等的两半，规模减为原来的二分之一调用自身：将两半分别调用自身排序，然后将分别排好序的两半进行归并...
复制链接

扫一扫

专栏目录