Make the timing between algorithms better

Author: Hopson97

src/main/java/sortVisualiser/SortArray.java

@@ -6,6 +6,7 @@
 import java.awt.Graphics2D;
 import java.util.Random;
 import javax.swing.JPanel;
+import static util.Sleep.microsecondsToNano;
 import static util.Sleep.sleepFor;
 
 /**
@@ -17,16 +18,17 @@ public class SortArray extends JPanel {
     public static final int WIN_HEIGHT = 720;
     private static final int BAR_WIDTH = 8;
     private static final int NUM_BARS = WIN_WIDTH / BAR_WIDTH;
+    
     private int[] array;
-    private int[] accessColourMod;
+    private int[] barColours;  
 
     public SortArray() {
         setBackground(Color.darkGray);
         array = new int[NUM_BARS];
-        accessColourMod = new int[NUM_BARS];
+        barColours = new int[NUM_BARS];
         for (int i = 0; i < NUM_BARS; i++) {
             array[i] = i;
-            accessColourMod[i] = 0;
+            barColours[i] = 0;
         }
     }
 
@@ -43,10 +45,11 @@ public void swapUpdate(int firstIndex, int secondIndex) {
         array[firstIndex] = array[secondIndex];
         array[secondIndex] = temp;
 
-        accessColourMod[firstIndex] = 100;
-        accessColourMod[secondIndex] = 100;
+        barColours[firstIndex] = 100;
+        barColours[secondIndex] = 100;
+        
         repaint();
-        sleepFor(10000);
+        sleepFor(microsecondsToNano(10000));
     }
 
     /**
@@ -60,7 +63,7 @@ public Dimension getPreferredSize() {
 
     public void resetColours() {
         for (int i = 0; i < NUM_BARS; i++) {
-            accessColourMod[i] = 0;
+            barColours[i] = 0;
         }
         repaint();
     }
@@ -80,11 +83,11 @@ public void paintComponent(Graphics g) {
             int xBegin = x + (BAR_WIDTH - 1) * x;
             int yBegin = WIN_HEIGHT - height;
 
-            int val = accessColourMod[x] * 2;
+            int val = barColours[x] * 2;
             graphics.setColor(new Color(255, 255 - val, 255 - val));
             graphics.fillRect(xBegin, yBegin, BAR_WIDTH, height);
-            if (accessColourMod[x] > 0) {
-                accessColourMod[x]-= 5;
+            if (barColours[x] > 0) {
+                barColours[x]-= 20;
             }
         }
     }

src/main/java/sortVisualiser/SortVisualiser.java

@@ -5,6 +5,7 @@
 import sortVisualiser.algorithms.BubbleSort;
 import sortVisualiser.algorithms.ISortAlgorithm;
 import sortVisualiser.algorithms.Shuffle;
+import static util.Sleep.secondsToNano;
 import static util.Sleep.sleepFor;
 
 /**
@@ -14,6 +15,7 @@
 public class SortVisualiser {
     private JFrame window;
     private SortArray sortArray;
+    private Shuffle shuffler = new Shuffle();
 
     private ArrayList<ISortAlgorithm> sortQueue;
 
@@ -30,15 +32,29 @@ public SortVisualiser() {
         window.setVisible(true);
 
         sortQueue = new ArrayList<>();
-        sortQueue.add(new Shuffle());
         sortQueue.add(new BubbleSort());
     }
 
+    private void highlightArray() {
+        for (int i = 0; i < sortArray.arraySize(); i++) {
+            sortArray.swapUpdate(i, i);
+        }
+    }
+    
+    private void shuffleAndWait() {
+        shuffler.runSort(sortArray);
+        sortArray.resetColours();
+        sleepFor(secondsToNano(2));
+    }
+    
     public void run() {
         for (ISortAlgorithm algorithm : sortQueue) {
+            sleepFor(secondsToNano(2));
+            shuffleAndWait();
             algorithm.runSort(sortArray);
             sortArray.resetColours();
-            sleepFor(2000000);
+            highlightArray();
+            sortArray.resetColours();
         }
     }
 

src/main/java/util/Sleep.java

@@ -5,12 +5,23 @@
  * @author mhops
  */
 public class Sleep {
-    public static void sleepFor(int microseconds) {
-        long nanoseconds = microseconds * 1000;
+    public static void sleepFor(long nanoseconds) {
         long timeElapsed;
         final long startTime = System.nanoTime();
         do {
             timeElapsed = System.nanoTime() - startTime;
         } while(timeElapsed < nanoseconds);
     }
+    
+    public static long secondsToNano(long time) {
+        return time * (long)Math.pow(10, 9);
+    }
+    
+    public static long millisecondsToNano(long time) {
+        return time * (long)Math.pow(10, 6); 
+    }
+    
+    public static long microsecondsToNano(long time) {
+        return time * (long)Math.pow(10, 3); 
+    }
 }