MergeSort

Background

In computer science, merge sort refers to a sorting algorithm which splits an array of data into continuously smaller halves until the arrays reach a size of 1, after which the elements are continuously compared and merged into a sorted array. For more information on how this process works, visit this page. If you took CSE 247, this algorithm should look extremely familiar to you.

Visualization

If you've never seen mergesort before, it may be helpful to take a look at this page which gives a visual demonstration of the algorithm in practice.

Where to Start

Navigate to the sort.studio.merge package and look at the MergeSort.java class. The sort.core.merg packagecontains some useful building block classes we created for you. Take a look at the MergeableData interface as you will need to use its methods to assist you in this studio.

MergeSort Studio

You will need to implement merge sort sequentially and in parallel, but you will need to do both implementations recursively. The kernel method should call itself using recursion, but the mergesort method should only call the kernel once. We do this in order to manipulate where we can place our async/finish blocks. When completing this studio, think carefully about where to put your async/finish calls.

Sequential Implementation

The only thing you will need to edit is the kernel method. As this is a sequential implementation, there is no need to call an async or finish. Using the description of merge sort provided to you in the background, try to consider what the base case would be. Then, further consider how to call the method recursively. When the array reaches the base case, you will need to complete the “merging” aspect of merge sort. As mentioned above, there is a method in the utils class that should help with this.

Hint: Follow the Wikipedia links and look at the pseudocode for help.

Parallel Implementation

This should look exactly like the sequential implementation, but it should also include async/finish calls. Think carefully about where to place them to maximize concurrency.