From 435a9ef718bc2856eace755c38f6ee7a4b5d3bd2 Mon Sep 17 00:00:00 2001
From: eugenefischer <66030419+eugenefischer@users.noreply.github.com>
Date: Thu, 11 Jun 2020 14:03:27 -0500
Subject: [PATCH] Revert "Stream test"

---
 Sorting/AlgorithmTester.java        | 18 +++++++--------
 Sorting/BubbleSorter.java           |  4 ++--
 Sorting/CountingSorter.java         |  4 ++--
 Sorting/InsertionSorter.java        |  4 ++--
 Sorting/MergeSorter.java            | 27 ++++++++++++++---------
 Sorting/QuickSorter.java            |  8 +++----
 Sorting/QuickSorterThreeWay.java    |  4 ++--
 Sorting/RandomNumberFileMaker.java  | 34 ++++-------------------------
 Sorting/RandomNumberFileReader.java | 14 +-----------
 Sorting/SelectionSorter.java        |  4 ++--
 Sorting/SortResult.java             | 10 ---------
 Sorting/Sorter.java                 |  4 ++--
 12 files changed, 47 insertions(+), 88 deletions(-)

diff --git a/Sorting/AlgorithmTester.java b/Sorting/AlgorithmTester.java
index 07b6e6f..07e4102 100644
--- a/Sorting/AlgorithmTester.java
+++ b/Sorting/AlgorithmTester.java
@@ -138,33 +138,33 @@ public class AlgorithmTester{
         boolean quickTWP=sortingAlgoChoices[5];
         boolean merge=sortingAlgoChoices[6];
         ArrayList<SortResult> results = new ArrayList<SortResult>();
-        RandomNumberFileReader reader = new RandomNumberFileReader(filename);
+        
         if(bubble){
-            BubbleSorter bubSorter = new BubbleSorter(reader);
+            BubbleSorter bubSorter = new BubbleSorter(filename);
             results.add(bubSorter.measuredSort());
         }
         if(selection){
-            SelectionSorter selSorter = new SelectionSorter(reader);
+            SelectionSorter selSorter = new SelectionSorter(filename);
             results.add(selSorter.measuredSort());
         }
         if(insertion){
-            InsertionSorter inSorter = new InsertionSorter(reader);
+            InsertionSorter inSorter = new InsertionSorter(filename);
             results.add(inSorter.measuredSort());
         }
         if(counting){
-            CountingSorter countSorter = new CountingSorter(reader);
+            CountingSorter countSorter = new CountingSorter(filename);
             results.add(countSorter.measuredSort());
         }
         if(quick){
-            QuickSorter qSorter = new QuickSorter(reader);
+            QuickSorter qSorter = new QuickSorter(filename);
             results.add(qSorter.measuredSort());
         }
         if(quickTWP){
-            QuickSorterThreeWay qTWPSorter = new QuickSorterThreeWay(reader);
+            QuickSorterThreeWay qTWPSorter = new QuickSorterThreeWay(filename);
             results.add(qTWPSorter.measuredSort());
         }
         if(merge){
-            MergeSorter mSorter = new MergeSorter(reader);
+            MergeSorter mSorter = new MergeSorter(filename);
             results.add(mSorter.measuredSort());
         }
         for(SortResult e: results){
@@ -174,7 +174,7 @@ public class AlgorithmTester{
                 }
                 System.out.print("\n");
             }
-            System.out.println("\n"+e.getSortType()+" of "+e.getSortCount()+" numbers with range "+e.getMin()+" to "+e.getMax()+" took:");
+            System.out.println("\n"+e.getSortType()+" of "+e.getSortCount()+" numbers took:");
             System.out.println(e.getComparisonsUsed()+" comparisons");
             System.out.println(e.getWritesUsed()+" write operations");
             System.out.println(e.getTimeUsed()+" milliseconds");
diff --git a/Sorting/BubbleSorter.java b/Sorting/BubbleSorter.java
index e52d162..edbf0a1 100644
--- a/Sorting/BubbleSorter.java
+++ b/Sorting/BubbleSorter.java
@@ -3,8 +3,8 @@ package Sorting;
 public class BubbleSorter extends Sorter{
     //a class to sort arrays of numbers using bubble sort
 
-    public BubbleSorter(RandomNumberFileReader reader){
-        super("bubble sort", reader);
+    public BubbleSorter(String filename){
+        super("bubble sort", filename);
     }
 
     void sort(){
diff --git a/Sorting/CountingSorter.java b/Sorting/CountingSorter.java
index 2d2a31b..c5e2a79 100644
--- a/Sorting/CountingSorter.java
+++ b/Sorting/CountingSorter.java
@@ -4,8 +4,8 @@ import java.util.Arrays;
 
 public class CountingSorter extends Sorter{
 
-    public CountingSorter(RandomNumberFileReader reader){
-        super("counting sort", reader);
+    public CountingSorter(String filename){
+        super("counting sort", filename);
     }
 
     void sort(){
diff --git a/Sorting/InsertionSorter.java b/Sorting/InsertionSorter.java
index 1d61453..aa781c3 100644
--- a/Sorting/InsertionSorter.java
+++ b/Sorting/InsertionSorter.java
@@ -5,8 +5,8 @@ package Sorting;
 
 public class InsertionSorter extends Sorter{
     
-    public InsertionSorter(RandomNumberFileReader reader){
-        super("insertion sort", reader);
+    public InsertionSorter(String filename){
+        super("insertion sort", filename);
     }
 
     void sort(){
diff --git a/Sorting/MergeSorter.java b/Sorting/MergeSorter.java
index 045c993..4dbb5f7 100644
--- a/Sorting/MergeSorter.java
+++ b/Sorting/MergeSorter.java
@@ -2,8 +2,8 @@ package Sorting;
 
 public class MergeSorter extends Sorter{
     
-    public MergeSorter(RandomNumberFileReader reader){
-        super("merge sort",reader);
+    public MergeSorter(String filename){
+        super("merge sort",filename);
     }
 
     void sort(){
@@ -28,34 +28,41 @@ public class MergeSorter extends Sorter{
     void merge(int leftIndex, int middleIndex, int rightIndex){
         int sizeLeft=middleIndex-leftIndex+1;//add 1 to include both endpoints
         int sizeRight=rightIndex-middleIndex;//both endpoints already included, as middleIndex is part of left array
-        Integer[] left=new Integer[sizeLeft];
-        Integer[] right=new Integer[sizeRight];
+        int[] left=new int[sizeLeft];
+        int[] right=new int[sizeRight];
         for(int i=0;i<sizeLeft;i++){
-            writeToArray(left, i, numbers[leftIndex+i]);
+            left[i]=numbers[leftIndex+i];
+            writesUsed++;
         }
         for(int i=0;i<sizeRight;i++){
-            writeToArray(right, i, numbers[middleIndex+1+i]);
+            right[i]=numbers[middleIndex+1+i];
+            writesUsed++;
         }
         int i=0, j=0;//indices of left and right array
         int k=leftIndex;//index of numbers array
         while(i<sizeLeft&&j<sizeRight){
             if(compare(left[i],right[j])<1){
-                writeToArray(numbers, k, left[i]);
+                numbers[k]=left[i];
+                writesUsed++;
+
                 i++;
             }
             else{
-                writeToArray(numbers, k, right[j]);
+                numbers[k]=right[j];
+                writesUsed++;
                 j++;
             }
             k++;
         }
         while(i<sizeLeft){
-            writeToArray(numbers, k, left[i]);
+            numbers[k]=left[i];
+            writesUsed++;
             i++;
             k++;
         }
         while(j<sizeRight){
-            writeToArray(numbers, k, right[j]);
+            numbers[k]=right[j];
+            writesUsed++;
             j++;
             k++;
         }
diff --git a/Sorting/QuickSorter.java b/Sorting/QuickSorter.java
index 8d31a66..ced6b42 100644
--- a/Sorting/QuickSorter.java
+++ b/Sorting/QuickSorter.java
@@ -2,12 +2,12 @@ package Sorting;
 
 public class QuickSorter extends Sorter{
     
-    public QuickSorter(RandomNumberFileReader reader){
-        super("quick sort", reader);
+    public QuickSorter(String filename){
+        super("quick sort", filename);
     }
 
-    public QuickSorter(String qsortVariant, RandomNumberFileReader reader){
-        super(qsortVariant, reader);
+    public QuickSorter(String qsortVariant, String filename){
+        super(qsortVariant, filename);
     }
 
     void sort(){
diff --git a/Sorting/QuickSorterThreeWay.java b/Sorting/QuickSorterThreeWay.java
index a0069f9..6d7fa1c 100644
--- a/Sorting/QuickSorterThreeWay.java
+++ b/Sorting/QuickSorterThreeWay.java
@@ -6,8 +6,8 @@ package Sorting;
 
 public class QuickSorterThreeWay extends QuickSorter{
 
-    public QuickSorterThreeWay(RandomNumberFileReader reader){
-        super("quick sort (3-way partition)", reader);
+    public QuickSorterThreeWay(String filename){
+        super("quick sort (3-way partition)", filename);
     }
     /*
     void sort(){
diff --git a/Sorting/RandomNumberFileMaker.java b/Sorting/RandomNumberFileMaker.java
index d79c143..ab13f64 100644
--- a/Sorting/RandomNumberFileMaker.java
+++ b/Sorting/RandomNumberFileMaker.java
@@ -1,14 +1,9 @@
 package Sorting;
 
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.StandardOpenOption;
-import java.io.BufferedWriter;
-import java.util.Random;
+import java.io.File;
 import java.io.IOException;
-//import java.io.File;
-//import java.io.FileWriter;
-//import java.lang.Math;
+import java.io.FileWriter;
+import java.lang.Math;
 
 /**
  * This class will allow the user to make a file of random integers.
@@ -29,27 +24,6 @@ public class RandomNumberFileMaker {
        max=M+1;
     }
 
-    //new version using streams and a try-with-resouces block
-    public void writeFile(){
-        try(BufferedWriter writer = Files.newBufferedWriter(Path.of(filename), StandardOpenOption.CREATE_NEW)){
-            Random random = new Random();
-            random.ints(count, min, max+1)
-                .forEach(num -> 
-                    {
-                        try{
-                            writer.write(Integer.toString(num)); writer.newLine();
-                        }catch (IOException ex){
-                            System.out.println("An error occurred.");
-                        }  
-                    });
-        }catch (IOException ex){
-            System.out.println("Could not make new file named "+filename);
-        }
-    }
-
-
-    //previous version retained for reference.
-    /*
     public void writeFile(){
         try{
             File randomNumbers = new File(filename);
@@ -68,6 +42,6 @@ public class RandomNumberFileMaker {
         }catch (IOException ex){
             System.err.println(ex);
         }
-    }*/
+    }
 
 }
\ No newline at end of file
diff --git a/Sorting/RandomNumberFileReader.java b/Sorting/RandomNumberFileReader.java
index 5040bc7..cf33277 100644
--- a/Sorting/RandomNumberFileReader.java
+++ b/Sorting/RandomNumberFileReader.java
@@ -12,17 +12,6 @@ class RandomNumberFileReader{
 	private ArrayList<Integer> numbers = new ArrayList<Integer>();
 
 	public RandomNumberFileReader(String file){
-		//reads text from file of integers, one on each line
-		//uses try-with-resources loop to automatically close BufferedReader
-		//uses Stream operations instead of while loop
-		try(BufferedReader reader = Files.newBufferedReader(Path.of(file));){
-			reader.lines().mapToInt(Integer::parseInt).forEach(num -> numbers.add(num));
-		}catch (IOException ex){
-			System.err.println(ex);
-		}
-		
-		/*
-		//previous version retained for reference
 		//Reads in from a text file of integers, one on each line
 		try{
 			BufferedReader reader = Files.newBufferedReader(Path.of(file));
@@ -34,9 +23,8 @@ class RandomNumberFileReader{
 		} catch (IOException ex){
 			System.err.println(ex);
 		}
-		*/
 	}
-
+	
 	public ArrayList<Integer> getNumbers(){
 		return numbers;
 	}
diff --git a/Sorting/SelectionSorter.java b/Sorting/SelectionSorter.java
index d545fdd..1add6fa 100644
--- a/Sorting/SelectionSorter.java
+++ b/Sorting/SelectionSorter.java
@@ -2,8 +2,8 @@ package Sorting;
 
 public class SelectionSorter extends Sorter {
     //a class to sort an array of numbers using selection sort
-    public SelectionSorter(RandomNumberFileReader reader){
-        super("selection sort", reader);
+    public SelectionSorter(String filename){
+        super("selection sort", filename);
     }
 
     void sort(){
diff --git a/Sorting/SortResult.java b/Sorting/SortResult.java
index e339c7b..1dc09a1 100644
--- a/Sorting/SortResult.java
+++ b/Sorting/SortResult.java
@@ -75,14 +75,4 @@ public class SortResult {
         return nf.format(sortedArray.length);
     }
 
-    public String getMin(){
-        NumberFormat nf = NumberFormat.getInstance(Locale.US);
-        return nf.format(sortedArray[0]);
-    }
-
-    public String getMax(){
-        NumberFormat nf = NumberFormat.getInstance(Locale.US);
-        return nf.format(sortedArray[sortedArray.length-1]);
-    }
-
 }
\ No newline at end of file
diff --git a/Sorting/Sorter.java b/Sorting/Sorter.java
index dd0e9ab..bdb152d 100644
--- a/Sorting/Sorter.java
+++ b/Sorting/Sorter.java
@@ -15,9 +15,9 @@ abstract class Sorter {
     protected long comparisonsUsed = 0;
     protected long writesUsed=0;
 
-    public Sorter(String st, RandomNumberFileReader reader){
+    public Sorter(String st, String filename){
         sortType=st;
-        //RandomNumberFileReader reader = new RandomNumberFileReader(filename);
+        RandomNumberFileReader reader = new RandomNumberFileReader(filename);
         numbers = new Integer[reader.getNumbers().size()];
         reader.getNumbers().toArray(numbers);
     }