ECE592 Project 1 iterative mergesort

import numpy as np

# function to merge sorted subarrays in place
def mergesort(X):

    global a

    N = len(X)
    mergesize = 1 #*2
    while(mergesize <=  N-1):
        left = 0
        while(left < N - 1):
            r = min(left + 2*mergesize - 1, N - 1)
            q = min(left + mergesize - 1, N - 1)
            p = left
            if (r-p) <= 1:
                if X[p] > X[r]:
                    tmp = X[p]
                    X[p] = X[r]
                    X[r] = tmp
            elif (r-p) == 2:
                if X[p+1] > X[p+2]:
                    tmp = X[p+1]
                    X[p+1] = X[p+2]
                    X[p+2] = tmp
                if X[p] > X[p+2]:
                    tmp = X[p]
                    X[p] = X[p+2]
                    X[p+2] = tmp
                if X[p] > X[p+1]:
                    tmp = X[p]
                    X[p] = X[p+1]
                    X[p+1] = tmp
            elif (r-p) == 3:
                if X[p] > X[p+1]:
                    tmp = X[p]
                    X[p] = X[p+1]
                    X[p+1] = tmp
                if X[p+2] > X[p+3]:
                    tmp = X[p+2]
                    X[p+2] = X[p+3]
                    X[p+3] = tmp
                if X[p] > X[p+2]:
                    tmp = X[p]
                    X[p] = X[p+2]
                    X[p+2] = tmp
                if X[p+1] > X[p+3]:
                    tmp = X[p+1]
                    X[p+1] = X[p+3]
                    X[p+3] = tmp
                if X[p+1] > X[p+2]:
                    tmp = X[p+1]
                    X[p+1] = X[p+2]
                    X[p+2] = tmp
            else:
                N1 = q - p + 1
                N2 = r - q
                currN = N1 + N2
                ind1 = 0
                ind2 = 0
                indX = p
                leftX = [0] * N1
                rightX = [0] * N2
                leftX[0:N1] = X[p:p+N1]
                rightX[0:N2] = X[q+1:q+N2+1]
                if((q+1)<N and X[q]<=X[q+1]):
                    N1 = 0
                    N2 = 0

                while ind1 < N1 and ind2 < N2:
                    if leftX[ind1] > rightX[ind2]:
                        X[indX] = rightX[ind2]
                        ind2 += 1
                    else:
                        X[indX] = leftX[ind1]
                        ind1 += 1
                    indX += 1

                while ind1 < N1:
                    X[indX] = leftX[ind1]
                    ind1 += 1
                    indX += 1

                while ind2 < N2:
                    X[indX] = rightX[ind2]
                    ind2 += 1
                    indX += 1
            left += 2*mergesize
        mergesize *= 2

    a = X

# driver code
a = np.random.randint(10000, size=1000000)
mergesort(a)
print(a)