MergeSort递归实现

时间:2016-04-18 00:58:20

标签: python list recursion merge mergesort

我今天刚刚学习了Python,并试图以递归方式实现Mergesort ...我绝对无法弄清楚我做错了什么。有人可以帮忙吗?

def mergesort(A):

    if len(A) < 2:
        return A
    middle = len(A) // 2
    L = mergesort(A[:middle])
    R = mergesort(A[middle:])
    return merge(L, R)

# Merge - combine part of mergesort

def merge(Lsort, Rsort):


sort = [None] * (len(Lsort + Rsort))


i = 0
j = 0
k = 0 
while (len(Lsort) <= len(sort)) or (len(Rsort) <= len(sort)):
    if Lsort[i] < Rsort[j]:
        sort[k] = Lsort[i]
        i += 1
    else:
        sort[k] = Rsort[j]
        j += 1
    k += 1
return sort

3 个答案:

答案 0 :(得分:0)

它与Python无关,而是与逻辑无关。

MapDefaultTypeNames表达式更改为

var settings = new ConnectionSettings(connectionPool)
    .DefaultIndex(testIndexName)
    .MapDefaultTypeNames(d => d
        .Add(typeof(TestType), "test_type")
    );

while表达到

while k < len(sort):

答案 1 :(得分:0)

您的合并功能是问题,应该更像是:

def merge(Lsort, Rsort):                                                                                                                                                                                    
    sort = []                                                                                                                                                                                               

    i = 0                                                                                                                                                                                                   
    j = 0                                                                                                                                                                                                   
    while (len(Lsort) > i) & (len(Rsort) > j):                                                                                                                                                              
        if Lsort[i] < Rsort[j]:                                                                                                                                                                             
            sort.append(Lsort[i])                                                                                                                                                                           
            i += 1                                                                                                                                                                                          
        else:                                                                                                                                                                                               
            sort.append(Rsort[j])                                                                                                                                                                           
            j += 1                                                                                                                                                                                          

    if len(Lsort) > 0:                                                                                                                                                                                      
        sort += Lsort[i:]                                                                                                                                                                                   

    if len(Rsort) > 0:                                                                                                                                                                                      
        sort += Rsort[j:]                                                                                                                                                                                   

    return sort

一般情况下,您不需要为排序分配空间,只需追加到空列表即可。对于while逻辑,您需要确保不超过Lsort和Rsort数组的范围。确保您的索引小于数组长度。

当任一阵列耗尽时,您可以将剩余的数组项连接到排序列表。

答案 2 :(得分:0)

以下是http://interactivepython.org/runestone/static/pythonds/SortSearch/TheMergeSort.html

提供的Python版本

(请注意下面我在示例列表上粘贴了一个应用程序流的图像,以帮助我了解递归流程(因为我是一个nube))。

MergeSortPython code

example MergeSort flow