MergeSort递归实现

Question

I just learned Python today, and am trying to recursively implement Mergesort... I absolutely cannot figure out what I am doing wrong. Can someone help?

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

Answer 1

It is nothing to do with Python, but rather with the logic.

Change while expression to

while k < len(sort):

and if expression to

if (j >= len(Rsort)) or (i < len(Lsort) and Lsort[i] < Rsort[j]):

Answer 2

Your merge function is the problem, should be something more like:

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

In general, you don't need to allocate space for sort just append to an empty list as you go. For the while logic you need to make sure you don't exceed the bounds of the Lsort and Rsort arrays. Make sure your indices are less the array length.

When either array is exhausted you may concatenate the remaining array items to your sorted list.

Answer 3

Here is the Python version provided by http://interactivepython.org/runestone/static/pythonds/SortSearch/TheMergeSort.html

(note below I pasted an image of the flow of an application on a sample list that I made to help me understand the recursive flow (as I am a nube)).