Question

Consider a variation of Merge sort called 4-way Merge sort. Instead of splitting the array into two parts like Merge sort, 4-way Merge sort splits the array into four parts. 4-way Merge divides the input array into fourths, calls itself for each fourth and then merges the four sorted fourths.
a)Implement 4-way Merge sort from Problem 4 to sort an array/vector of integers and name it merge4. Implement the algorithm in the same language you used for the sorting algorithms in HW 1. Your program should be able to read inputs from a file called “data.txt” where the first value of each line is the number of integers that need to be sorted, followed by the integers (like in HW 1). The output will be written to a file called “merge4.txt”.

b) Modify code- Now that you have verified that your code runs correctly using the data.txt input file, you can modify the code to collect running time data. Instead of reading arrays from the file data.txt and sorting, you will now generate arrays of size n containing random integer values from 0 to 10,000 to sort. Use the system clock to record the running times of each algorithm for ten different values of n for example: n = 5000, 10000, 15000, 20,000, …, 50,000. You may need CS 325 - Homework Assignment 2 to modify the values of n if an algorithm runs too fast or too slow to collect the running time data (do not collect times over a minute). Output the array size n and time to the terminal. Name the new program merge4Time.

c) Collect running times - Collect your timing data on the engineering server. You will need at least eight values of t (time) greater than 0. If there is variability in the times between runs of the same algorithm you may want to take the average time of several runs for each value of n. Create a table of running times.

d) Plot data and fit a curve - Plot the data you collected on an individual graph with n on the x-axis and time on the y-axis. You may use Excel, Matlab, R or any other software. What type of curve best fits each data set? Give the equation of the curves that best “fits” the data and draw that curves on the graphs.

e) Combine - Also plot the data from 4-way Merge sort together on a combined graph with your results for merge and insertion sort from HW1.

Answer 1

Pseudocode for 4-way Merge sort

B) there are total of 2*n-3 comparison where n is the size of your array

so for comparison complexity will be O(n).

mergeSort function devides this problem in 4 subproblems in size of (n/4) so recurrence relation will be

According to masters Theorem complexity of this algorithm is

c) Implementation in Python

def merge(A, l,m2,m1, m3, h):
    n1 = m2 - l + 1#calculating length of subarrays
    n2 = m1- m2
    n3 = m3-m1
    n4 = h-m3
    Ln = m1-l+1
    Rn = h-m1  
    # creating temporary arrays
    a = [0] * (n1)
    b = [0] * (n2)
    c = [0] * (n3)
    d = [0] * (n4)
    L = [0] * (Ln)
    R = [0] * (Rn)
    # Copy data to temp arrays L[] and R[]
    for i in range(0 , n1):
        a[i] = A[l + i]
    for i in range(0 , n2):
        b[i] = A[m2+1 + i]
    for i in range(0 , n3):
        c[i] = A[m1+1 + i]
    for i in range(0 , n4):
        d[i] = A[m3+1 + i]
    i1=0
    i2=0
    k=0
    while i1 < n1 and i2 < n2 :#merging first two part
        if a[i1] <= b[i2]:
            L[k] = a[i1]
            i1 += 1
        else:
            L[k] = b[i2]
            i2 += 1
        k += 1
    while i1 < n1:
        L[k] = a[i1]
        i1 += 1
        k += 1

    while i2 < n2:
        L[k] = b[i2]
        i2 += 1
        k += 1
    i1=0
    i2=0
    k=0
    while i1 < n3 and i2 < n4 :
        if c[i1] <= d[i2]:
            R[k] = c[i1]
            i1 += 1
        else:
            R[k] = d[i2]
            i2 += 1
        k += 1
    while i1 < n3:
        R[k] = c[i1]
        i1 += 1
        k += 1

    # Copy the remaining elements of R[], if there
    # are any
    while i2 < n4:
        R[k] = d[i2]
        i2 += 1
        k += 1

    i=0
    j=0
    k=l
    while i < Ln and j < Rn :
        if L[i] <= R[j]:
            A[k] = L[i]
            i += 1
        else:
            A[k] = R[j]
            j += 1
        k += 1
    while i < Ln:
        A[k] = L[i]
        i += 1
        k += 1

    # Copy the remaining elements of R[], if there
    # are any
    while j < Rn:
        A[k] = R[j]
        j += 1
        k += 1

def mergeSort(A,low,high):
    if low < high:
        m1 = int((low+(high))/2)
        m2 = int((low+m1)/2)
        m3 = int(((m1+1)+high)/2)
        mergeSort(A, low, m2)
        mergeSort(A, m2+1, m1)
        mergeSort(A, m1+1, m3)
        mergeSort(A, m3+1, high)
        merge(A, low,m2, m1,m3, high)

print ("Enetr array size")
arr_size = int(input())
print ("Enetr array element")
A = [int(x) for x in input().split()]
mergeSort(A,0,arr_size-1)
print (" Your array after Sorting is")
for i in range(arr_size):
    print ("%d" %A[i]),

Screenshot of my editor

The Screenshot of Output Screen