I need help writing a semaphore for the following code: Mergesort.java: public c
ID: 3663070 • Letter: I
Question
I need help writing a semaphore for the following code:
Mergesort.java:
public class MergeSort {
// The mergeSort method returns a sorted copy of the
// String objects contained in the String array data.
/**
* Sorts the String objects using the merge sort algorithm.
*
* @param data the String objects to be sorted
* @return the String objects sorted in ascending order
*/
public static String[] mergeSort(String[] data) {
if (data.length > 1) {
String[] left = new String[data.length / 2];
String[] right = new String[data.length - left.length];
System.arraycopy(data, 0, left, 0, left.length);
System.arraycopy(data, left.length, right, 0, right.length);
left = mergeSort(left);
right = mergeSort(right);
return merge(left, right);
}
else {
return data;
}
}
/**
* The merge method accepts two String arrays that are assumed
* to be sorted in ascending order. The method will return a
* sorted array of String objects containing all String objects
* from the two input collections.
*
* @param left a sorted collection of String objects
* @param right a sorted collection of String objects
* @return a sorted collection of String objects
*/
public static String[] merge(String[] left, String[] right) {
String[] data = new String[left.length + right.length];
int lIndex = 0;
int rIndex = 0;
for (int i=0; i<data.length; i++) {
if (lIndex == left.length) {
data[i] = right[rIndex];
rIndex++;
}
else if (rIndex == right.length) {
data[i] = left[lIndex];
lIndex++;
}
else if (left[lIndex].compareTo(right[rIndex]) < 0) {
data[i] = left[lIndex];
lIndex++;
}
else {
data[i] = right[rIndex];
rIndex++;
}
}
return data;
}
}
Sort.java:
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.ArrayList;
public class Sort {
/*Thread pool is created by using the newFixedThreadPool method. The int associated to this thread allows for performance measure
for thread vs. non-thread*/
private static final ExecutorService executorService = Executors.newFixedThreadPool(2);
/**
* You are to implement this method. The method should invoke one or more
* threads to read and sort the data from the collection of Files. The
* method should return a sorted list of all of the String data contained in
* the files.
*
* @param files
* @return
* @throws IOException
*/
public static String[] threadedSort(File[] files) throws IOException {
//This will run each file using a pooled thread
for (final File file : files) {
executorService.execute(new SortThread(file));
}
//This will shutdown only after the thread has completed
executorService.shutdown();
while(!executorService.isTerminated()){
}
return SortThread.sortedData;
}
/**
* Given an array of files, this method will return a sorted list of the
* String data contained in each of the files.
*
* @param files
* the files to be read
* @return the sorted data
* @throws IOException
* thrown if any errors occur reading the file
*/
public static String[] sort(File[] files) throws IOException {
String[] sortedData = new String[0];
for (File file : files) {
String[] data = getData(file);
data = MergeSort.mergeSort(data);
sortedData = MergeSort.merge(sortedData, data);
}
return sortedData;
}
/**
* This method will read in the string data from the specified file and
* return the data as an array of String objects.
*
* @param file
* the file containing the String data
* @return String array containing the String data
* @throws IOException
* thrown if any errors occur reading the file
*/
static String[] getData(File file) throws IOException {
ArrayList<String> data = new ArrayList<String>();
BufferedReader in = new BufferedReader(new FileReader(file));
// Read the data from the file until the end of file is reached
while (true) {
String line = in.readLine();
if (line == null) {
// the end of file was reached
break;
} else {
data.add(line);
}
}
// Close the input stream and return the data
in.close();
return data.toArray(new String[0]);
}
static String[] SortThread(File[] files) {
throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
}
}
SortTest.java:
import java.io.File;
import java.io.IOException;
/**
* The class SortTest is used to test the threaded and non-threaded
* sort methods. This program will call each method to sort the data
* contained in the four test files. This program will then test the
* results to ensure that the results are sorted in ascending order.
*
* Simply run this program to verify that you have correctly implemented
* the threaded sort method. The program will not verify if your sort
* uses threads, but will verify if your implementation correctly
* sorted the data contained in the four files.
*
* There should be no reason to make modifications to this class.
*/
public class SortTest {
public static void main(String[] args) throws IOException {
File[] files = {new File("enable1.txt"), new File("enable2k.txt"), new File("lower.txt"), new File("mixed.txt")};
// Run Sort.sort on the files
long startTime = System.nanoTime();
String[] sortedData = null;
sortedData = Sort.sort(files);
long stopTime = System.nanoTime();
double elapsedTime = (stopTime - startTime) / 1000000000.0;
// Test to ensure the data is sorted
for (int i=0; i<sortedData.length-1; i++) {
if (sortedData[i].compareTo(sortedData[i+1]) > 0) {
System.out.println("The data returned by Sort.sort is not sorted.");
throw new java.lang.IllegalStateException("The data returned by Sort.sort is not sorted");
}
}
System.out.println("The data returned by Sort.sort is sorted.");
System.out.println("Sort.sort took " + elapsedTime + " seconds to read and sort the data.");
// Run Sort.threadedSort on the files and test to ensure the data is sorted
startTime = System.nanoTime();
String[] threadSortedData = Sort.threadedSort(files);
stopTime = System.nanoTime();
double threadedElapsedTime = (stopTime - startTime)/ 1000000000.0;
// Test to ensure the data is sorted
if (sortedData.length != threadSortedData.length) {
System.out.println("The data return by Sort.threadedSort is missing data");
throw new java.lang.IllegalStateException("The data returned by Sort.threadedSort is not sorted");
}
for (int i=0; i<threadSortedData.length-1; i++) {
if (threadSortedData[i].compareTo(threadSortedData[i+1]) > 0) {
System.out.println("The data return by Sort.threadedSort is not sorted");
throw new java.lang.IllegalStateException("The data returned by Sort.threadedSort is not sorted");
}
}
System.out.println("The data returned by Sort.threadedSort is sorted.");
System.out.println("Sort.threadedSort took " + threadedElapsedTime + " seconds to read and sort the data.");
}
}
SortThread.java:
import java.io.File;
import java.io.IOException;
/**
* The class SortTest is used to test the threaded and non-threaded
* sort methods. This program will call each method to sort the data
* contained in the four test files. This program will then test the
* results to ensure that the results are sorted in ascending order.
*
* Simply run this program to verify that you have correctly implemented
* the threaded sort method. The program will not verify if your sort
* uses threads, but will verify if your implementation correctly
* sorted the data contained in the four files.
*
* There should be no reason to make modifications to this class.
*/
public class SortTest {
public static void main(String[] args) throws IOException {
File[] files = {new File("enable1.txt"), new File("enable2k.txt"), new File("lower.txt"), new File("mixed.txt")};
// Run Sort.sort on the files
long startTime = System.nanoTime();
String[] sortedData = null;
sortedData = Sort.sort(files);
long stopTime = System.nanoTime();
double elapsedTime = (stopTime - startTime) / 1000000000.0;
// Test to ensure the data is sorted
for (int i=0; i<sortedData.length-1; i++) {
if (sortedData[i].compareTo(sortedData[i+1]) > 0) {
System.out.println("The data returned by Sort.sort is not sorted.");
throw new java.lang.IllegalStateException("The data returned by Sort.sort is not sorted");
}
}
System.out.println("The data returned by Sort.sort is sorted.");
System.out.println("Sort.sort took " + elapsedTime + " seconds to read and sort the data.");
// Run Sort.threadedSort on the files and test to ensure the data is sorted
startTime = System.nanoTime();
String[] threadSortedData = Sort.threadedSort(files);
stopTime = System.nanoTime();
double threadedElapsedTime = (stopTime - startTime)/ 1000000000.0;
// Test to ensure the data is sorted
if (sortedData.length != threadSortedData.length) {
System.out.println("The data return by Sort.threadedSort is missing data");
throw new java.lang.IllegalStateException("The data returned by Sort.threadedSort is not sorted");
}
for (int i=0; i<threadSortedData.length-1; i++) {
if (threadSortedData[i].compareTo(threadSortedData[i+1]) > 0) {
System.out.println("The data return by Sort.threadedSort is not sorted");
throw new java.lang.IllegalStateException("The data returned by Sort.threadedSort is not sorted");
}
}
System.out.println("The data returned by Sort.threadedSort is sorted.");
System.out.println("Sort.threadedSort took " + threadedElapsedTime + " seconds to read and sort the data.");
}
}
I have the and sort of understand the concept, but I just get a bunch of error when I try to create the class for the semaphore. Please help me!!!!!1
Explanation / Answer
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Iterator;
public class MergeSort {
private int[] array;
private int[] tempMergArr;
private int length;
public static void main(String a[]){
int[] inputArr = {45,23,11,89,77,98,4,28,65,43};
MergeSort mms = new MergeSort();
mms.sort(inputArr);
for(int i:inputArr){
System.out.print(i);
System.out.print(" ");
}
}
public void sort(int inputArr[]) {
this.array = inputArr;
this.length = inputArr.length;
this.tempMergArr = new int[length];
doMergeSort(0, length - 1);
}
private void doMergeSort(int lowerIndex, int higherIndex) {
if (lowerIndex < higherIndex) {
int middle = lowerIndex + (higherIndex - lowerIndex) / 2;
// Below step sorts the left side of the array
doMergeSort(lowerIndex, middle);
// Below step sorts the right side of the array
doMergeSort(middle + 1, higherIndex);
// Now merge both sides
mergeParts(lowerIndex, middle, higherIndex);
}
}
private void mergeParts(int lowerIndex, int middle, int higherIndex) {
for (int i = lowerIndex; i <= higherIndex; i++)
{
tempMergArr[i] = array[i];
}
int i = lowerIndex;
int j = middle + 1;
int k = lowerIndex;
while (i <= middle && j <= higherIndex) {
if (tempMergArr[i] <= tempMergArr[j]) {
array[k] = tempMergArr[i];
i++;
}
else
{
array[k] = tempMergArr[j];
j++;
}
k++;
}
while (i <= middle) {
array[k] = tempMergArr[i];
k++;
i++;
}
}
}