【Python实现归并排序】 𴂅

原文: http://blog.gqylpy.com/gqy/347

"首先,归并排序使用了二分法,归根到底的思想还是分而治之。拿到一个长数组,将其不停的分为左边和右边两份,然后以此递归分下去。然后再将它们按照两个有序数组的样子合并起来。这样说起来可能很难理解,所以 图就来了:

归并排序将数组以中间的值进行拆分,最后分到最细之后再将其使用对两个有序数组进行排序的方法对其进行排序。

两个有序数组排序的方法则非常简单,同时对两个数组的第一个位置进行比大小,将小的放入一个空数组,然后将放入空数组的那个位置的指针往后移一个,然后继续和另外一个数组的上一个位置进行比较,以此类推。到最后任何一个数组先出栈完,就将另外一个数组里的所有元素追加到新数组后面。

递归拆分的时间复杂度是logN,进行两个有序数组排序的方法复杂度是N,所以该算法的时间复杂度是N*logN,即NlogN。

Python代码示例:

lst = [2, 5, 7, 8, 9, 1, 3, 4, 6]

def merge_sort(lst, low, high):
    # 不断递归调用自己,直至拆分成单个元素的时候返回这个元素,不再拆分
    if low < high:
        # 取拆分的中间位置
        mid = (low + high) // 2
        merge_sort(lst, low, mid)  # 左
        merge_sort(lst, mid + 1, high)  # 右
        merge(lst, low, mid, high)

def merge(lst, low, mid, high):
    i, j = low, mid + 1
    ltmp = []

    # 这个循环的作用是:
    # 从两个有顺序的列表里,按顺序从左到右依次比较值的大小,并把较小的放入ltmp中
    # 最终,会有一个列表被取完,而另一个列表没有被取完
    while i <= mid and j <= high:
        if lst[i] <= lst[j]:
            ltmp.append(lst[i])
            i += 1
        else:
            ltmp.append(lst[j])
            j += 1

    # 如果左边的列表没有被取完:
    while i <= mid:
        ltmp.append(lst[i])
        i += 1

    # 如果右边的列表没有被取完:
    while j <= high:
        ltmp.append(lst[j])
        j += 1

    lst[low:high + 1] = ltmp

merge_sort(lst, 0, len(lst) - 1)

print(lst)

"

原文: http://blog.gqylpy.com/gqy/347

原文地址:https://www.cnblogs.com/bbb001/p/11372886.html

时间: 2024-08-28 21:54:55

【Python实现归并排序】 𴂅的相关文章

利用Python实现归并排序

利用python进行归并排序,摘抄自http://blog.csdn.net/minxihou/article/details/51821052 "代码真的不是一气呵成的,而且也不是想当然写出来的.可能需要反复断点中断来查看是否有逻辑错误.在理解了问题的基础下我们需要先把大体的代码框架最好先写出来,特别是主要的逻辑判断语句.但是不需要太care我循环体或者判断里面语句怎么实现,当你把这一步做到的时候能避免很多不必要的错误发生." 1 import random 2 3 def Conf

python实现归并排序,归并排序的详细分析。

学习归并排序的过程是十分痛苦的.它并不常用,看起来时间复杂度好像是几种排序中最低的,比快排的时间复杂度还要低,但是它的执行速度不是最快的.很多朋友不理解时间复杂度低为什么运行速度不一定快,这个不清楚的伙伴可以看下我之前发表的文章http://www.cnblogs.com/Lin-Yi/p/7301535.html看完之后也许你会对时间复杂度有一个新的认识. 我谈的观点往往不是官方的定义,我希望能帮助更多基础薄弱的同学读懂思想~ 归并排序: 先分开再合并,分开成单个元素,合并的时候按照正确顺序合

python实现归并排序,归并排序的详细分析

学习归并排序的过程是十分痛苦的.它并不常用,看起来时间复杂度好像是几种排序中最低的,比快排的时间复杂度还要低,但是它的执行速度不是最快的.很多朋友不理解时间复杂度低为什么运行速度不一定快,这个不清楚的伙伴可以看下我之前发表的文章http://www.cnblogs.com/Lin-Yi/p/7301535.html看完之后也许你会对时间复杂度有一个新的认识. 我谈的观点往往不是官方的定义,我希望能帮助更多基础薄弱的同学读懂思想~ 归并排序: 先分开再合并,分开成单个元素,合并的时候按照正确顺序合

python版归并排序

1 def merge(ll, rr): 2 i = 0 3 j = 0 4 num = [] 5 while i < len(ll) and j < len(rr): 6 if ll[i] < rr[j]: 7 num.append(ll[i]) 8 i += 1 9 else: 10 num.append(rr[j]) 11 j += 1 12 if i != len(ll): 13 num += ll[i:] 14 else: 15 num += rr[j:] 16 return

python中归并排序

1 # coding=UTF-8 2 #!/usr/bin/python 3 4 import sys 5 6 def merge(nums, first, middle, last): 7 "merge" 8 #切片边界,左闭右开,从0开始 9 lnums = nums[ first:middle+1 ] 10 rnums = nums[ middle+1:last+1 ] 11 lnums.append(sys.maxint) 12 rnums.append(sys.maxint)

用python实现归并排序

def merge(lfrom, lto, low, mid, high): i, j, k = low, mid, low while i < mid and j < high: if lfrom[i] < lfrom[j]: lto[k] = lfrom[i] i += 1 else: lto[k] = lfrom[j] j += 1 k += 1 while i < mid: lto[k] = lfrom[i] i += 1 k += 1 while j < high:

python代码 归并排序 merge sort

1: def mergesort(seq): 2: if len(seq)<=1: 3: return seq 4: mid=len(seq)/2 5: left=mergesort(seq[:mid]) 6: right=mergesort(seq[mid:]) 7: return merge(left,right) 8:   9: def merge(left,right): 10: result=[] 11: i,j=0,0 12: while i<len(left) and j<

Python实现归并排序

import sys def merge(nums,first,middle,last):  lnums = nums[first:middle+1]  rnums = nums[middle+1:last+1]  lnums.append(sys.maxint)  rnums.append(sys.maxint)  l=0  r = 0 for i in range(first,last+1):  if lnums[l] <rnums[r]:    nums[i] = lnums[l]   

python 实现归并排序

import random # 我也是想了很久才想明白,递归用的太少了.画下图自己模拟一下就行了. # 先递归分成单个元素,然后排序. # 排序的函数传入的值是两个连续的数组. # 因为单个元素的时候就进行排序,所以返回的一left_half,right_half 一定是排好序的 def merge_sort(seq): if len(seq) <=1: # 只有一个元素时是递归出口 return seq else: mid = int(len(seq)/2) left_half = merge