使用合并排序功能时获取列表索引超出范围错误

Question

I am getting List index out of range error. I have also used GeeksforGeeks program as a reference but still got that error. I get no error when I run this without using it inside Merge_Sort() function.

def Merge(arr, p, q, r):
    n1 = q-p+1
    n2 = r-q
    L = [0]*n1
    M = [0]*n2

    for i in range(0, n1):
        L[i] = arr[p+i-1]
    for j in range(0, n2):
        M[j] = arr[q+j]
    i = 0
    j = 0
    for k in range(r-1):
        if L[i] <= M[j]:
            arr[k] = L[i]
            i = i+1
        else:
            arr[k] = M[j]
        j = j+1

def Merge_Sort(arr, p, r):
    if p < r:
        q = int((p+r)/2)
        Merge_Sort(arr, p, q)
        Merge_Sort(arr, q+1, r)
        Merge(arr, p, q, r)

ar = [5, 3, 6, 1, 2, 9, 7, 8]
n = len(ar)
Merge_Sort(ar, 1, n)
print(ar)

Error:
 line 14, in Merge
    if L[i]<=M[j]:

IndexError: list index out of range

Answer 1

The code is incorrect: the is some confusion about index values and slice boundaries, and other mistakes too:

• array indices start at 0 in python, so you should call Merge_sort(ar, 0, n)

• the slice length n1 is off by one, it should be n1 = q - p

• the test for recursion should compute the slice length and only recurse for slices with at least 2 elements.

• the merge loop is incorrect: you should test if i and j are both inside the slices. An efficient way to do this is to replace the comparison with this test:

   if i < n1 and (j == n2 or L[i] <= M[j]): 

• the merge loop should iterate for k from p to r excluded, not from 0 to r excluded

• the increment code for j is misaligned, it should be indented one more step

It is much simpler to consider the first index to be included and the second to be excluded. There are far too many tutorials in the net in various languages that insist on other conventions, invariably causing confusion for newbie programmers.

Here is a corrected and simplified version:

def Merge(arr, p, q, r):
    n1 = q - p
    n2 = r - q
    L = arr[p : q]
    M = arr[q : r]
    i = 0
    j = 0
    for k in range(p, r):
        if i < n1 and (j == n2 or L[i] <= M[j]):
            arr[k] = L[i]
            i = i + 1
        else:
            arr[k] = M[j]
            j = j + 1

def Merge_Sort(arr, p, r):
    if r - p >= 2:
        q = (p + r) // 2
        Merge_Sort(arr, p, q)
        Merge_Sort(arr, q, r)
        Merge(arr, p, q, r)

ar = [5, 3, 6, 1, 2, 9, 7, 8]
Merge_Sort(ar, 0, len(ar))
print(ar)

Note that you can further simplify the MergeSort function with a single temporary array if you ensure that the left slice is always at least as large as the right slice:

def Merge(arr, p, q, r):
    tmp = arr[p : q]
    i = 0
    n = q - p
    while i < n:
        if q == r or tmp[i] <= arr[q]:
            arr[p] = tmp[i]
            i += 1
            p += 1
        else:
            arr[p] = arr[q]
            q += 1
            p += 1

def Merge_Sort(arr, p, r):
    if r - p >= 2:
        q = (p + r + 1) // 2
        Merge_Sort(arr, p, q)
        Merge_Sort(arr, q, r)
        Merge(arr, p, q, r)

ar = [5, 3, 6, 1, 2, 9, 7, 8]
Merge_Sort(ar, 0, len(ar))
print(ar)

Answer 2

Your code differs from the GeeksforGeeks code. I corrected the merge function to match theirs. You need three loops:

1. Take the smaller of the first elements from L or M until either L or M is empty
2. Append the elements remaining in L (if any)
3. Append the elements remaining in M (if any)

You also need a variable that tracks the current index in arr ( k in this case).

GeeksforGeeks code: https://www.geeksforgeeks.org/merge-sort/

Corrected python code:

def Merge(arr, p, q, r):
    n1 = q-p+1
    n2 = r-q
    L = [0]*n1
    M = [0]*n2

    for i in range(0,n1):
        L[i] = arr[p+i]
    for j in range(0, n2):
        M[j] = arr[q+1+j]
    i = 0
    j = 0
    # result index
    k = p

    # take smallest element until either L or M are empty
    while i < n1 and j < n2:
        if L[i]<=M[j]:
            arr[k] = L[i]
            i = i+1
        else:
            arr[k] = M[j]
            j = j+1
        k = k+1

    # write remaining elements from L
    while i < n1:
        arr[k] = L[i]
        i = i+1
        k = k+1

    # write remaining elements from M
    while j < n2:
        arr[k] = M[j]
        j = j+1
        k = k+1

def Merge_Sort(arr, p, r):
    if p < r:
        q = int((p+r)/2)
        Merge_Sort(arr, p, q)
        Merge_Sort(arr, q+1,r)
        Merge(arr, p, q, r)
ar = [5,3,6,1,2,9,7,8]
n = len(ar)
Merge_Sort(ar,0,n-1)
print(ar)

If you only want to use one loop you can combine all of the above like so (takes away from the readability though):

def Merge(arr, p, q, r):
    n1 = q-p+1
    n2 = r-q
    L = [0]*n1
    M = [0]*n2

    for i in range(0,n1):
        L[i] = arr[p+i]
    for j in range(0, n2):
        M[j] = arr[q+1+j]
    i = 0
    j = 0

    for k in range(n1+n2):
        if (i < n1 and j < n2 and L[i]<=M[j]) or j >= n2:
            arr[p+k] = L[i]
            i = i+1
        else:
            arr[p+k] = M[j]
            j = j+1

def Merge_Sort(arr, p ,r):
    if p < r:
        q = int((p+r)/2)
        Merge_Sort(arr, p, q)
        Merge_Sort(arr, q+1,r)
        Merge(arr, p, q, r)
ar = [5,3,6,1,2,9,7,8,]
n = len(ar)
Merge_Sort(ar,0,n-1)
print(ar)