精华内容
下载资源
问答
  • 数组的二路归并排序 python实现

    数组的二路归并排序

    今天突然想重新写一下 python 排序归并代码,今天重新整理了一下,命名相对以前更加清晰了,给出了完整的测试用例。

    对二路归并的排序之前写的文章,感觉实现不是特别好。
    二路归并排序Python实现

    from typing import List
    
    import random
    
    
    class Solution:
        def sort(self, array: List, left: int, right: int):
    
            if left < right:
                mid = left + (right - left) // 2
    
                self.sort(array, left, mid)
                self.sort(array, mid + 1, right)
    
                self._merge(array, left, mid, right)
    
    
        def _merge(self, array, left, mid, right):
            """
            在区间 [left,right]  进行merge 操作
            :param array:
            :param left:
            :param mid:
            :param right:
            :return:
            """
    
            temp = [None] * (right - left + 1)
    
            i = left
            j = mid + 1
    
            k = 0
    
            while i <= mid and j <= right:
                if array[i] < array[j]:
                    temp[k] = array[i]
                    k += 1
                    i += 1
                else:
                    temp[k] = array[j]
                    k += 1
                    j += 1
    
            while i <= mid:
                temp[k] = array[i]
                k += 1
                i += 1
    
            while j <= right:
                temp[k] = array[j]
                k += 1
                j += 1
    
            array[left:right + 1] = temp
    
    
    
    if __name__ == '__main__':
        cout = 0
    
        array = list(range(1000))
        expected = array.copy()
        while cout < 1000:
            random.shuffle(array)
            r = Solution().sort(array, 0, len(array) - 1)
    
            assert array == expected
    
            cout += 1
            print(f"curent count={cout}")
     
    
    分享快乐,留住感动. '2020-12-24 13:54:18' --frank
    展开全文
  • 归并排序python

    2020-12-19 09:36:17
    归并排序 问题描述: 归并排序是创建在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。 分治法: 分割:递归地把当前序列平均分割成两半。 集成:在保持元素顺序...

    归并排序

    问题描述:

    归并排序是创建在归并操作上的一种有效的排序算法。该算法是采用分治法(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实现

    千次阅读 2019-03-27 16:24:03
    文章目录归并排序python实现归并排序完整算法时间复杂度 归并排序python实现 归并排序 归并排序在于把序列拆分再合并起来,使用分治法来实现,这就意味这要构造递归算法 首先是一个例子 原序先通过一半一半的拆分,...

    归并排序python实现

    归并排序

    归并排序在于把序列拆分再合并起来,使用分治法来实现,这就意味这要构造递归算法

    首先是一个例子

    在这里插入图片描述

    原序先通过一半一半的拆分,然后:

    在这里插入图片描述

    然后再一步一步的向上合并,在合并的过程中完成了排序,合并排序算法如下:

    
    def merge(s1,s2,s):
        """将两个列表是s1,s2按顺序融合为一个列表s,s为原列表"""
        # j和i就相当于两个指向的位置,i指s1,j指s2
        i = j = 0
        while i+j<len(s):
            # j==len(s2)时说明s2走完了,或者s1没走完并且s1中该位置是最小的
            if j==len(s2) or (i<len(s1) and s1[i]<s2[j]):
                s[i+j] = s1[i]
                i += 1
            else:
                s[i+j] = s2[j]
                j += 1
    

    这是以列表为例,道理其实很简单,因为两个序列是排好序的,所以都从左往右,互相比较选择较小的那个数放入最后的序列,s是原序列,所以在一开始会有与len(s)的比较

    完整算法

    算法中通过递归并调用merge函数完成排序

    
    def merge(s1,s2,s):
        """将两个列表是s1,s2按顺序融合为一个列表s,s为原列表"""
        # j和i就相当于两个指向的位置,i指s1,j指s2
        i = j = 0
        while i+j<len(s):
            # j==len(s2)时说明s2走完了,或者s1没走完并且s1中该位置是最小的
            if j==len(s2) or (i<len(s1) and s1[i]<s2[j]):
                s[i+j] = s1[i]
                i += 1
            else:
                s[i+j] = s2[j]
                j += 1
    
    def merge_sort(s):
        """归并排序"""
        n = len(s)
        # 剩一个或没有直接返回,不用排序
        if n < 2:
            return
        # 拆分
        mid = n // 2
        s1 = s[0:mid]
        s2 = s[mid:n]
        # 子序列递归调用排序
        merge_sort(s1)
        merge_sort(s2)
        # 合并
        merge(s1,s2,s)
    
    
    if __name__ == '__main__':
        s = [1,7,3,5,4]
        merge_sort(s)
        print(s)
    

    时间复杂度

    还拿这个图说

    在这里插入图片描述

    这个图显然是二叉树的形式,所以若集合有n个元素,那高度就为log(n)

    但其实在每一层做比较的时候,都是一个一个的向序列中放小的元素,每一层都是要放n次

    所以时间复杂度为nlog(n)

    展开全文
  • 二路归并排序Python实现-III 归并排序 是一种 效率比较高并且稳定的算法。时间复杂度 O(NLog(N)),空间复杂度 O(N). 归并排序(Merge Sort)是建立在归并操作上的一种有效,稳定的排序算法,该算法是采用分治法...

    二路归并排序Python实现-III

    归并排序 是一种 效率比较高并且稳定的算法。时间复杂度 O(NLog(N)),空间复杂度 O(N).

    归并排序(Merge Sort)是建立在归并操作上的一种有效,稳定的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为二路归并

    归并排序 有两个步骤,第一个 '归' 其实就是不断划分数组的长度, 把排序问题转为更小的子问题,直到 问题非常简单的时候, 在进行'并' 操作。 就是把两个有序的数组, 进行合并到一个新的有序数组中。最终所有的数组都完成的时候, 就完成了排序。

    算法思想

    第一步: 先找到一个数组的中点 划分数组, 把一个数组arr[left,right] 划分为两个部分 arr [left,mid]arr[mid+1,right] 这里其实就是分治 的思想,把一个大的数组, 变成了一个size 为一半的两个小的数组。

    第二步: 对前面的部分 arr [left,mid] 进行排序, 对后面的部分进行排序arr[mid+1,right]

    第三步: 也是 操作, 合并两个有序的数组. 这里需要一个辅助数组复制原数组一份。然后定义两个指针 i,j 分别指向 两部分数组的开始位置 i --> left , j --> mid+1 所以理论上来说 i 的取值范围 [left,mid] 是合法的范围, j 的取值范围 [mid+1,right] 是合法范围。 如果 i, j 超出了自己的合法范围,说明有一部分 已经完全merge完了,只需要把另外一部分 直接copy 到 后面的数组中即可。

    下面一张图 完全展示了这个过程,红色部分 是 , 绿色部分是 .

    img01

    原图地址 https://pic.leetcode-cn.com/1614274007-nBQbZZ-Picture1.png

    代码实现

    
    import random
    from typing import List, Any
    
    # pip install useful-decoration
    from useful_decoration import code_timer
    
    
    class MergeSort:
    
        def sort(self, array: List[int]) -> None:
            """
            归并排序
            time complexity: O(N * logN)
            space complexity: O(N)
    
            稳定性: 稳定的算法
            :param array:
            :return:
            """
            length = len(array)
            left, right = 0, length - 1
            # 临时数组,辅助空间
            temp = [0] * length
            self._merge_sort(array, left, right, temp)
    
        def _merge_sort(self, arr: List[int], left: int, right: int, temp: List):
            """
            [left,right] 闭区间开始归并排序
            :param arr:
            :param left:
            :param right:
            :return:
            """
            # terminator, 只有一个值的时候
            if left >= right:
                return
    
            mid = left + (right - left) // 2
            self._merge_sort(arr, left, mid, temp)
            self._merge_sort(arr, mid + 1, right, temp)
    
            self._merge(arr, left, mid, right, temp)
    
        def _merge(self, arr: List[int], left: int, mid: int, right: int, temp: List):
            # print(f"begin:arr[{left}:{right + 1}]:{arr[left:right + 1]}")
            # 把数据copy到临时数组中, 辅助数组中
            for i in range(left, right + 1):
                temp[i] = arr[i]
    
            i = left
            j = mid + 1
            for index in range(left, right + 1, 1):
                if i == mid + 1:
                    # 前面的元素【left,mid】 已经merge完毕,需要把后面的一部分copy 到 array里面
                    arr[index] = temp[j]
                    j += 1
                elif j == right + 1:
                    # 前面的元素【mid+1,right】 已经merge完毕,需要把后面的一部分copy 到 array里面
                    arr[index] = temp[i]
                    i += 1
                elif temp[i] <= temp[j]:
                    arr[index] = temp[i]
                    i += 1
                else:
                    arr[index] = temp[j]
                    j += 1
    
    

    测试脚本

    
    def check_sort_result(cls: Any, size=500):
        array = list(range(size))
        array2 = array.copy()
        array2.sort()
        random.shuffle(array)
    
        with code_timer(name='MergeSort'):
            cls().sort(array)
        assert array2 == array, "arr2 != arr"
        return "true"
    
    
    if __name__ == '__main__':
        pass
        for i in range(100):
            r = check_sort_result(size=1000, cls=MergeSort)
            print(f"i={i},r={r}")
    

    之前也写过一些归并python的实现,突然看到别人写的代码,再次引用,学习一下,就当记录一下笔记。二路归并排序Python实现-II 这个实现 每次都要重新生成 一个数组,有点浪费空间,还不如直接生成好 好数组一样大小的空间,公用这个数组。 这样可以省点空间,但是 空间复杂度依然是O(N) .

    二路归并排序Python实现-II
    二路归并排序Python实现

    分享快乐,留住感动. '2021-03-14 10:43:27' --frank
    展开全文
  • 主要给大家介绍了关于python基本算法之实现归并排序(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]...
  • @des : 归并排序:先将序列进行划分,一直划分到每个最小的单元是一个数为止,然后合并最小的单元,在合并两个单元时, 依次比较当前两个单元中的值进行排序,最终形成一个有序的新单元 每一个排序后的有序序列...
  • 二路归并排序Python实现

    千次阅读 2017-10-16 16:33:42
    看了网上一些写法,总感觉 有点复杂,所以我参考之前写的程序,用Python 改写了一个 二路归并排序 算法 。二路归并排序主要运用了“分治算法”,分治算法就是将一个大的问题划分为n个规模较小而结构相似的子问题。 ...
  • 归并排序 归并排序的思想就是先递归分解数组,再合并数组。 归并排序是采用分治法的一个非常经典的应用。 其基本思路是: 假设:有一个数组:list = [2,5,4,3],对其进行排序。 第一步:将数组以分治法划分。 ...
  • 文件归并排序 命令行说明: sort.py -i <input_filename> -o <output_filename> [-d ] [-c ] [-s ] [-t ] -i 输入源文件名 -o 输出目标文件名,如果未指定,则结果覆盖到源文件 -d 可选项,文件文本行的列分隔符,...
  • 排序算法之归并排序 介绍一种新的排序算法,归并排序。 总的来说,前面介绍了两种排序算法,冒泡排序(选择排序)和插入排序(希尔排序)。冒泡排序是依次两两对比,选取较大的进行比较,时间复杂度均为O(n2);插入...
  • 归并排序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 = [] # 设定...
  • 归并排序 python

    2020-06-02 09:18:11
    然后对最小序列进行排序排序之后返回上一层,合并排序之后的两个子序列。 直至返回到合并成原序列大小位置,此时排序完成 ''' def divide(list): if len(list) > 2: return list[:len(list) // 2], list[len...
  • 归并排序 python实现

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

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

    2018-09-14 20:16:54
    python3: 思想: 1.分而治之 2.采用递归的方法 def merge_sort (lists) : if len(lists) 1 : return lists num = int(len(lists)/ 2 ) left = merge_sort(lists[:num]) right = merge_sort...
  • Python实现归并排序

    千次阅读 2020-07-14 23:10:27
    Python实现归并排序
  • 归并排序python实现)

    千次阅读 2019-05-02 21:44:43
    """归并排序""" if len(seq) return seq mid = len(seq) / 2 # 将列表分成更小的两个列表 # 分别对左右两个列表进行处理,分别返回两个排序好的列表 left = mergesort(seq[:mid]) right = mergesort(seq[mid...
  • 归并排序Python代码

    2018-11-18 14:21:02
    归并排序是面试最常考内容, 让你描述算法, 让你写算法, 让你分析时间复杂度   归并排序merge sort思路: 归并排序中间劈一刀,数组分两半,两边排好序,最后把左右两个合并。就是先局部有序,再整体有序。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,559
精华内容 5,423
关键字:

归并排序python

python 订阅