精华内容
下载资源
问答
  • 2020-12-19 09:36:17

    归并排序

    问题描述:

    归并排序是创建在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。
    分治法:

    1. 分割:递归地把当前序列平均分割成两半。
    2. 集成:在保持元素顺序的同时将上一步得到的子序列集成到一起(归并)。
    def mergersort(arr):
        """
        归并排序是创建在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。
        分治法:
        分割:递归地把当前序列平均分割成两半。
        集成:在保持元素顺序的同时将上一步得到的子序列集成到一起(归并)。
        :param arr:
        :return:
        """
        n = len(arr) // 2
        if n == 0:
            return arr
    
    
        left = bubblesort(arr[:n])
        right = bubblesort(arr[n:])
    
    
        i, j = 0, 0
        new_array = list()
    
    
        while i < len(left) and j < len(right):
            if left[i] >= right[j]:
                new_array.append(right[j])
                j += 1
            else:
                new_array.append(left[i])
                i += 1
    
    
        new_array = new_array + left[i:]
        new_array = new_array + right[j:]
    
    
        return new_array
    
    更多相关内容
  • 归并排序Python

    2022-05-18 16:44:51
    归并排序算法python

    归并排序

    归并排序采用的是分治法的思想来进行排序的。

    基本思想:分治法

    分:先递归分解数组,将数组分解成最小的一个个元素

    治:分解后的数组依次进行排序,最后合并数组。

    最后得到了排好序的数组。

    此处借鉴一张网上的图

    在这里插入图片描述

    时间复杂度:O(nlogn)

    注意:归并排序是稳定的排序

    代码:

    def merge(left_arr, right_arr):
        """合并操作:将两个有序数组合并为一个有序数组"""
    
        left_index, right_index = 0, 0  # left_index, right_index 分别表示左边列表和右边列表的索引号
        result = []
    
        # 当左边列表或者右边列表走到头了,循环结束
        while left_index < len(left_arr) and right_index < len(right_arr):
            if left_arr[left_index] < right_arr[right_index]:
                result.append(left_arr[left_index])
                left_index += 1
            else:
                result.append(right_arr[right_index])
                right_index += 1
        result += (left_arr[left_index:])   # 把多余一边的元素给加到 result 列表中
        result += (right_arr[right_index:])
        return result
    
    # 归并排序
    def merge_sort(arr):
        if len(arr) <= 1:
            return arr
        mid = len(arr) // 2
        left_arr = merge_sort(arr[:mid])
        right_arr = merge_sort(arr[mid:])
        merge_arr = merge(left_arr, right_arr)
        return merge_arr
    
    

    调用归并排序:

    nums = [1,3,2,4,7,5,6,8,10,9]
    print(merge_sort(nums))
    

    输出结果:

    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    
    展开全文
  • 归并排序 python

    2020-06-02 09:18:11
    然后对最小序列进行排序排序之后返回上一层,合并排序之后的两个子序列。 直至返回到合并成原序列大小位置,此时排序完成 ''' def divide(list): if len(list) > 2: return list[:len(list) // 2], list[len...
    '''
    将序列分成左右两份,然后对每一份再进行该操作,直至分为长度为2或者一为止
    然后对最小序列进行排序,排序之后返回上一层,合并排序之后的两个子序列。
    直至返回到合并成原序列大小位置,此时排序完成
    '''
    def divide(list):
        if len(list) > 2:
            return list[:len(list) // 2], list[len(list) // 2:]
        else:
            return list
    
    
    def panduan(list_left, list_right):
        list_final = []
        while len(list_left) > 0 and len(list_right) > 0:
            if list_left[0] <= list_right[0]:
                list_final.append(list_left[0])
                list_left.pop(0)
            else:
                list_final.append(list_right[0])
                list_right.pop(0)
        if len(list_right) != 0:
            list_final.extend(list_right)
        if len(list_left) != 0:
            list_final.extend(list_left)
        return list_final
    
    
    def mergeSort(list):
        list_divided = divide(list)
        list_origin = []
        for ele in list_divided:
            if len(ele) > 2:
                ele = mergeSort(ele)
            elif len(ele) != 1:
                ele = panduan(ele[:len(ele)//2], ele[len(ele)//2:])
            list_origin.extend(ele)
        return panduan(list_origin[:(len(list)//2)], list_origin[(len(list)//2):])
    
    
    a = [12, 34, 15, 2, 45, 48, 231, 5, 13]
    list_final = mergeSort(a)
    print(list_final)
    
    
    展开全文
  • 主要给大家介绍了关于python基本算法之实现归并排序(Merge sort)的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 选择排序,冒泡排序,插入排序,归并排序Python代码
  • 归并排序python实现

    2022-01-03 13:38:06
    归并排序(英语:Merge sort,或mergesort),是创建在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。 分治法: 分割:递归地把当前序列平均分割成两半。 集成...

    归并排序(英语:Merge sort,或mergesort),是创建在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。

    分治法:

    • 分割:递归地把当前序列平均分割成两半。
    • 集成:在保持元素顺序的同时将上一步得到的子序列集成到一起(归并)。

    一.方法思想

    归并排序(MergeSort)的基本思想是:将待排序文件看成为n个长度为1的有序子文件,把这些子文件两两归并,使得到「n/2」个长度为2的有序子文件;然后再把这「n/2」个有序文件的子文件两两归并,如此反复,直到最后得到一个长度为n的有序文件为止,这种排序方法成为二路归并排序。例如,有初始关键字序列:72,18,53,36,48,31,36,其二路归并排序过程如下所示。

    二.时间复杂度

    归并排序时间复杂度为O(nlogn),平均时间复杂度O(nlogn)最好和最坏时间复杂度(nlogn)。归并排序每次递归需要用到一个辅助表,长度与待排序的表相等,虽然递归次数是O(logn),但每次递归都会释放掉所占的辅助空间,所以下次递归的栈空间和辅助空间与这部分释放的空间就不相关了,因而空间复杂度还是O(n)

    三.代码实现

    要判断递归的终止条件

    def merge(li,low,mid,high):
        i = low 
        j = mid + 1
        ltmp =[]
        while i <= mid and j <= high:
            if li[i] < li[j]:
                ltmp.append(li[i])
                i += 1
            else:
                ltmp.append(li[j])
                j += 1
        #当while执行完毕时,肯定有一部分没有数了
        while i <= mid:
            ltmp.append(li[i])
            i += 1
        while j <= high:
            ltmp.append(li[j])
            j += 1
        li[low:high+1] = ltmp
            
    def merge_sort(li,low,high):
        if low < high:           #确保至少有二个元素,这样才能递归
            mid = (low + high)//2
            merge_sort(li,low,mid)
            merge_sort(li,mid+1,high)
            merge(li,low,mid,high)
        #递归终止的条件是当low = high 时,此时只有一个元素,递归终止
        return li

    我们创建一个列表并利用merge_sort函数实现归并排序。

    import random
    li = list(range(100))
    random.shuffle(li)
    print(merge_sort(li,0,len(li)-1))

    输出结果:

     以上就是归并排序的全部内容了。

    展开全文
  • 归并排序python版本

    2020-06-22 16:59:52
    1、问题描述:排序算法中归并排序是于1945年由冯·诺伊曼首次提出,可以通过递归实现和非递归实现,本次采用递归实现。递归实现的归并排序是算法设计中分治策略的典型应用。 2、性能分析: 最差时间复杂度为:O...
  • 排序算法之归并排序 介绍一种新的排序算法,归并排序。 总的来说,前面介绍了两种排序算法,冒泡排序(选择排序)和插入排序(希尔排序)。冒泡排序是依次两两对比,选取较大的进行比较,时间复杂度均为O(n2);插入...
  • 二路归并排序Python实现-III 归并排序 是一种 效率比较高并且稳定的算法。时间复杂度 O(NLog(N)),空间复杂度 O(N). 归并排序(Merge Sort)是建立在归并操作上的一种有效,稳定的排序算法,该算法是采用分治法...
  • 归并排序Python实现

    2020-06-11 12:11:47
    MergeSort in Python def mergeSort(array): if len(array) > 1: r=len(array)//2 l=array[:r] m=array[r:] mergeSort(l) mergeSort(m) i=j=k=0 while i(l)and j(m): if l[i][j]: array[k]=l[i] i+=1 else: array[k]...
  • 数组的二路归并排序 python实现
  • 归并排序(Python代码)

    2022-03-01 19:39:09
    归并排序用的是分治法,把一个大问题化解为k个中问题,每个中问题再化解为k个小问题,直至问题化为最小可解的问题。对这些问题求解,再不断地合并结果,直至合并完毕。 如下图: 注意: 合并方法,一个一个对比两...
  • @des : 归并排序:先将序列进行划分,一直划分到每个最小的单元是一个数为止,然后合并最小的单元,在合并两个单元时, 依次比较当前两个单元中的值进行排序,最终形成一个有序的新单元 每一个排序后的有序序列...
  • 归并排序 归并排序的思想就是先递归分解数组,再合并数组。 归并排序是采用分治法的一个非常经典的应用。 其基本思路是: 假设:有一个数组:list = [2,5,4,3],对其进行排序。 第一步:将数组以分治法划分。 ...
  • 文件归并排序 命令行说明: sort.py -i <input_filename> -o <output_filename> [-d ] [-c ] [-s ] [-t ] -i 输入源文件名 -o 输出目标文件名,如果未指定,则结果覆盖到源文件 -d 可选项,文件文本行的列分隔符,...
  • 归并排序:就是将列表里面每个元素看成一个列表,这样单个元素就是有序的,然后将相邻两个列表归并。 归并:归并就是将两个有序的序列变成一个列表 第一步:定义归并 我们可以举一个例子,将列表分为两段有序...
  • Python实现归并排序

    2021-07-20 22:45:08
    归并排序是采用分治法的一个非常典型的应用。归并排序的思想就是先递归分解数组,再合并数组。 将数组分解最小之后,然后合并两个有序数组,基本思路是比较两个数组的最前面的数,谁小就先取谁,取了后相应的指针就...
  • 归并排序 python实现

    2020-07-29 13:44:29
    归并排序(Merge Sort)是建立在归并操作上的一种有效,稳定的排序算法,是先使每个子序列有序, 再使子序列段间有序。若将两个有序表合并成一个有序表,称为二路归并。 通俗来讲,就是先将序列,拆分为若干有序的子...
  • 归并排序python代码

    2020-07-30 14:37:55
    def Merge(left, right): temp = [] i...nums = [6, 4, 8, 9, 2, 3, 1] print('排序之前:', input_nums) input_nums = MergeSort(input_nums) print('排序之后:', input_nums) 时间复杂度:O(nlogn) 空间复杂度:O(n)
  • 归并排序 """ from math import floor merge_list = [11, 6743, 4656, 2321, 12, 54, 876, 232] # 合并两个数据,产生一个已经排序好的新的数组 def merge(left, right): # 设定临时数组 result = [] # 设定...
  • # 归并排序,本质上是递归,先左边有序,右边有序,然后merge一下 def merge_sort(self, arr): if arr == None or len(arr) < 2: return self.process(arr, 0, len(arr)-1) def process(self, arr, l, r):...
  • 归并排序(Python)

    2021-11-08 21:23:03
    归并排序 稳定排序,时间复杂度O(nlogn) 归并排序算法会把序列分成长度相同的两个子序列(如果序列长度为奇数,则一个序列比另一个序列多一个元素),当无法继续往下分时(也就是每个子序列中只有一个数据时),就...
  • 二路归并排序Python实现

    千次阅读 2017-10-16 16:33:42
    看了网上一些写法,总感觉 有点复杂,所以我参考之前写的程序,用Python 改写了一个 二路归并排序 算法 。二路归并排序主要运用了“分治算法”,分治算法就是将一个大的问题划分为n个规模较小而结构相似的子问题。 ...
  • python 归并排序(详解)

    2021-12-22 15:23:57
    一、归并排序 归并排序(MERGE-SORT)是建立在归并操作上的一种有效的排序算法,该算法采用经典的分治(divide-and-conquer)策略(分治法将问题分(divide)成一些小的问题然后递归求解,而治(conquer)的阶段则将分的...
  • 归并排序Python版本

    2020-04-30 16:04:01
    文章目录归并排序介绍算法步骤代码演示算法分析 归并排序介绍 首先介绍归并排序思想:将数组分解最小之后,然后合并两个有序数组,基本思路是比较两个数组的最前面的数,谁小就先取谁,取了后相应的指针就往后移一位...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,151
精华内容 6,460
关键字:

归并排序python