Added Sorting algorithms

Author: rohan2266

.idea/.gitignore

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/resources" type="java-resource" />
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/misc.xml

@@ -0,0 +1,66 @@
+package sortvisualiser;
+
+import sortvisualiser.screens.MainMenuScreen;
+import sortvisualiser.screens.Screen;
+import java.util.ArrayList;
+import javax.swing.JFrame;
+import javax.swing.SwingUtilities;
+
+public class MainApp {
+    private final JFrame window;
+
+    public static final int WIN_WIDTH = 1280;
+    public static final int WIN_HEIGHT = 720;
+
+    private final ArrayList<Screen> screens;
+
+    public MainApp() {
+        screens = new ArrayList<>();
+        window = new JFrame ("Sort visualiser");
+        window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        window.setVisible(true);
+    }
+
+    public Screen getCurrentScreen() {
+        return screens.get(screens.size() - 1);
+    }
+
+    public void pushScreen(Screen screen) {
+        if (!screens.isEmpty()) {
+            window.remove(getCurrentScreen());
+        }
+        screens.add(screen);
+        window.setContentPane(screen);
+        window.validate();
+        screen.onOpen();
+    }
+
+    public void popScreen() {
+        if (!screens.isEmpty()) {
+            Screen prev = getCurrentScreen();
+            screens.remove(prev);
+            window.remove(prev);
+            if (!screens.isEmpty()) {
+                Screen current = getCurrentScreen();
+                window.setContentPane(current);
+                window.validate();
+                current.onOpen();
+            }
+            else {
+                window.dispose();
+            }
+        }
+    }
+
+    public void start() {
+        pushScreen(new MainMenuScreen(this));
+        window.pack();
+    }
+
+    public static void main(String... args) {
+        System.setProperty("sun.java2d.opengl", "true");
+        SwingUtilities.invokeLater(() -> {
+            new MainApp().start();
+        });
+    }
+}

.idea/modules.xml

@@ -0,0 +1,264 @@
+package sortvisualiser;
+
+import java.awt.AlphaComposite;
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Font;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.RenderingHints;
+import java.awt.image.BufferedImage;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Random;
+
+import javax.swing.JPanel;
+import javax.swing.JSpinner;
+import javax.swing.SpinnerNumberModel;
+
+import sortvisualiser.algorithms.ISortAlgorithm;
+
+/**
+ * The array that can be sorted
+ *
+ * @author mhops
+ */
+public class SortArray extends JPanel {
+    public static final int DEFAULT_WIN_WIDTH = 1280;
+    public static final int DEFAULT_WIN_HEIGHT = 720;
+    private static final int DEFAULT_BAR_WIDTH = 5;
+    /**
+     * This is the percent of the panel the bars will consume.
+     * Based on the original 256 bars each being 2x their height
+     * and 720px window height, or 512/720
+     */
+    private static final double BAR_HEIGHT_PERCENT = 512.0/720.0;
+    private static final int NUM_BARS = DEFAULT_WIN_WIDTH / DEFAULT_BAR_WIDTH;
+
+    private final int[] array;
+    private final int[] barColours;
+    private String algorithmName = "";
+
+    private String tandComplexity = " ";
+    private ISortAlgorithm algorithm;
+    private long algorithmDelay = 0;
+
+//    private final MidiSoundPlayer player;
+    private final JSpinner spinner;
+//    private final boolean playSounds;
+
+    private int arrayChanges = 0; // Number of changes to the array the current algorithm has taken so far
+
+    public SortArray() {
+        setBackground(Color.DARK_GRAY);
+        array = new int[NUM_BARS];
+        barColours = new int[NUM_BARS];
+        for (int i = 0; i < NUM_BARS; i++) {
+            array[i] = i;
+            barColours[i] = 0;
+        }
+//        player = new MidiSoundPlayer(NUM_BARS);
+//        this.playSounds = playSounds;
+        spinner = new JSpinner(new SpinnerNumberModel(1, 1, 1000, 1));
+        spinner.addChangeListener((event) -> {
+            algorithmDelay = (Integer) spinner.getValue();
+            algorithm.setDelay(algorithmDelay);
+        });
+        add(spinner,BorderLayout.LINE_START);
+    }
+
+    public int arraySize() {
+        return array.length;
+    }
+
+    public int getValue(int index) {
+        return array[index];
+    }
+
+    /**
+     * Gets the max value of the array or Integer.MIN_VALUE if there isn't one.
+     * @return the max value or Integer.MIN_VALUE.
+     */
+    public int getMaxValue() {
+        return Arrays.stream(array).max().orElse(Integer.MIN_VALUE);
+    }
+
+    private void finaliseUpdate(int value,  long millisecondDelay, boolean isStep) {
+        repaint();
+        try {
+            Thread.sleep(millisecondDelay);
+        } catch (InterruptedException ex) {
+            Thread.currentThread().interrupt();
+        }
+//        if (playSounds) {
+//            player.makeSound(value);
+//        }
+        if (isStep)
+            arrayChanges++;
+    }
+
+    public void swap(int firstIndex, int secondIndex, long millisecondDelay, boolean isStep) {
+        int temp = array[firstIndex];
+        array[firstIndex] = array[secondIndex];
+        array[secondIndex] = temp;
+
+        barColours[firstIndex] = 100;
+        barColours[secondIndex] = 100;
+
+        finaliseUpdate((array[firstIndex] + array[secondIndex]) / 2, millisecondDelay, isStep);
+    }
+
+    public void updateSingle(int index, int value, long millisecondDelay, boolean isStep) {
+        array[index] = value;
+        barColours[index] = 100;
+
+
+        finaliseUpdate(value, millisecondDelay, isStep);
+        repaint();
+    }
+
+    public void shuffle() {
+        arrayChanges = 0;
+        Random rng = new Random();
+        for (int i = 0; i < arraySize(); i++) {
+            int swapWithIndex = rng.nextInt(arraySize() - 1);
+            swap(i, swapWithIndex, 5, false);
+        }
+        arrayChanges = 0;
+    }
+
+    public void highlightArray() {
+        for (int i = 0; i < arraySize(); i++) {
+            updateSingle(i, getValue(i), 5, false);
+        }
+    }
+
+    /**
+     * Gets the canvas size
+     *
+     * @return size
+     */
+    @Override
+    public Dimension getPreferredSize() {
+        return new Dimension(DEFAULT_WIN_WIDTH, DEFAULT_WIN_HEIGHT);
+    }
+
+    public void resetColours() {
+        for (int i = 0; i < NUM_BARS; i++) {
+            barColours[i] = 0;
+        }
+        repaint();
+    }
+
+    @Override
+    public void paintComponent(Graphics g) {
+        super.paintComponent(g);
+        Graphics2D panelGraphics = (Graphics2D) g.create();
+
+        try
+        {
+            Map<RenderingHints.Key, Object> renderingHints = new HashMap<>();
+            renderingHints.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+            panelGraphics.addRenderingHints(renderingHints);
+            panelGraphics.setColor(Color.WHITE);
+            panelGraphics.setFont(new Font("Monospaced", Font.BOLD, 20));
+            panelGraphics.drawString(" Current algorithm: " + algorithmName, 10, 30);
+            panelGraphics.drawString(" Time Complexity & Space Complexity: " + tandComplexity, 10, 55);
+            panelGraphics.drawString("Current step delay: " + algorithmDelay + "ms", 10, 80);
+//            panelGraphics.drawString("     Array Changes: " + arrayChanges, 10, 105);
+
+            drawBars(panelGraphics);
+        } finally {
+            panelGraphics.dispose();
+        }
+    }
+
+    private void drawBars(Graphics2D panelGraphics)
+    {
+        int barWidth = getWidth() / NUM_BARS;
+        int bufferedImageWidth = barWidth * NUM_BARS;
+        int bufferedImageHeight = getHeight();
+
+        if(bufferedImageHeight > 0 && bufferedImageWidth > 0) {
+            if(bufferedImageWidth < 256) {
+                bufferedImageWidth = 256;
+            }
+
+            double maxValue = getMaxValue();
+
+            BufferedImage bufferedImage = new BufferedImage(bufferedImageWidth, bufferedImageHeight, BufferedImage.TYPE_INT_ARGB);
+            makeBufferedImageTransparent(bufferedImage);
+            Graphics2D bufferedGraphics = null;
+            try
+            {
+                bufferedGraphics = bufferedImage.createGraphics();
+
+                for (int x = 0; x < NUM_BARS; x++) {
+                    double currentValue = getValue(x);
+                    double percentOfMax = currentValue / maxValue;
+                    double heightPercentOfPanel = percentOfMax * BAR_HEIGHT_PERCENT;
+                    int height = (int) (heightPercentOfPanel * (double) getHeight());
+                    int xBegin = x + (barWidth - 1) * x;
+                    int yBegin = getHeight() - height;
+
+                    int val = barColours[x] * 2;
+                    if (val > 190) {
+                        bufferedGraphics.setColor(new Color(255 - val, 255, 255 - val));
+                    }
+                    else {
+                        bufferedGraphics.setColor(new Color(255, 255 - val, 255 - val));
+                    }
+                    bufferedGraphics.fillRect(xBegin, yBegin, barWidth, height);
+                    if (barColours[x] > 0) {
+                        barColours[x] -= 5;
+                    }
+                }
+            }
+            finally
+            {
+                if(bufferedGraphics != null)
+                {
+                    bufferedGraphics.dispose();
+                }
+            }
+
+            panelGraphics.drawImage(bufferedImage, 0, 0, getWidth(), getHeight(), 0, 0, bufferedImage.getWidth(), bufferedImage.getHeight(), null);
+        }
+    }
+
+    private void makeBufferedImageTransparent(BufferedImage image)
+    {
+        Graphics2D bufferedGraphics = null;
+        try
+        {
+            bufferedGraphics = image.createGraphics();
+
+            bufferedGraphics.setComposite(AlphaComposite.getInstance(AlphaComposite.CLEAR));
+            bufferedGraphics.fillRect(0, 0, image.getWidth(), image.getHeight());
+            bufferedGraphics.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER));
+        }
+        finally
+        {
+            if(bufferedGraphics != null)
+            {
+                bufferedGraphics.dispose();
+            }
+        }
+    }
+
+    @Override
+    public void setName(String algorithmName) {
+        this.algorithmName = algorithmName;
+    }
+    public void setComplexity(String tandCcomplexity){
+        this.tandComplexity = tandCcomplexity;
+    }
+
+    public void setAlgorithm(ISortAlgorithm algorithm) {
+        this.algorithm = algorithm;
+        algorithmDelay = algorithm.getDelay();
+        spinner.setValue((int) algorithm.getDelay());
+    }
+}

.idea/uiDesigner.xml

@@ -0,0 +1,52 @@
+package sortvisualiser.algorithms;
+
+import sortvisualiser.SortArray;
+
+/**
+ * Bubble sort implementation
+ *
+ * @author mhops
+ */
+public class BubbleSort implements ISortAlgorithm {
+
+    private long stepDelay = 2;
+    /**
+     * This method implements the bubble sort algorithm, see
+     * <a href="https://en.wikipedia.org/wiki/Bubble_sort">Bubble_sort</a> to understand more.
+     * Takes a SortArray object called array and sorts his elements according to the mathematical theory
+     * of the order "less than", see <a href="https://en.wikipedia.org/wiki/Order_theory">Order_theory</a> to
+     * understand more.
+     *
+     * @param array the array to be sorted
+     * @see SortArray
+     */
+    @Override
+    public void runSort(SortArray array) {
+        int len = array.arraySize();
+        for (int i = 0; i < len - 1; i++) {
+            for (int j = 0; j < len - i - 1; j++) {
+                if (array.getValue(j) > array.getValue(j + 1)) {
+                    array.swap(j, j + 1, getDelay(), true);
+                }
+            }
+        }
+    }
+
+    @Override
+    public String getName() {
+        return "Bubble Sort";
+    }
+    public String getName1() {
+        return "Time: (nlogn)\n Space: O(n)";
+    }
+
+    @Override
+    public long getDelay() {
+        return stepDelay;
+    }
+
+    @Override
+    public void setDelay(long delay) {
+        this.stepDelay = delay;
+    }
+}

.idea/vcs.xml

@@ -0,0 +1,19 @@
+package sortvisualiser.algorithms;
+import sortvisualiser.SortArray;
+
+/**
+ * Base interface for the sort algorithms
+ *
+ * @author Matt Hopson
+ */
+public interface ISortAlgorithm {
+    String getName();
+
+    long getDelay();
+
+    void setDelay(long delay);
+
+    void runSort(SortArray array);
+
+    String getName1();
+}

Data Structures Algorithm visualizer.iml

@@ -0,0 +1,53 @@
+package sortvisualiser.algorithms;
+
+import sortvisualiser.SortArray;
+
+/**
+ * Insertion sort implementation
+ *
+ * @author Matthew Hopson
+ */
+public class InsertionSort implements ISortAlgorithm {
+
+    private long stepDelay = 1;
+    /**
+     * This method implements the insertion sort algorithm, see
+     * <a href="https://en.wikipedia.org/wiki/Insertion_sort">Insertion_sort</a> to understand more.
+     * Takes a SortArray object called array and sorts his elements according to the mathematical theory
+     * of the order "less than", see <a href="https://en.wikipedia.org/wiki/Order_theory">Order_theory</a> to
+     * understand more.
+     *
+     * @param array the array to be sorted
+     * @see SortArray
+     */
+    @Override
+    public void runSort(SortArray array) {
+        for (int i = 0; i < array.arraySize(); i++) {
+            int key = array.getValue(i);
+            int j = i - 1;
+            while (j >= 0 && array.getValue(j) > key) {
+                array.updateSingle(j + 1, array.getValue(j), 5, true);
+                j--;
+            }
+            array.updateSingle(j + 1, key, getDelay(), true);
+        }
+    }
+
+    @Override
+    public String getName() {
+        return "Insertion Sort";
+    }
+    public String getName1() {
+        return "Time: (nlogn)\n Space: O(n)";
+    }
+
+    @Override
+    public long getDelay() {
+        return stepDelay;
+    }
+
+    @Override
+    public void setDelay(long delay) {
+        this.stepDelay = delay;
+    }
+}

out/production/Data Structures Algorithm visualizer/logo.png

@@ -0,0 +1,133 @@
+package sortvisualiser.algorithms;
+
+import sortvisualiser.SortArray;
+
+/**
+ * Merge sort implementation
+ *
+ * @author Matthew Hopson
+ */
+public class MergeSort implements ISortAlgorithm {
+
+    private long stepDelay = 20;
+    /**
+     * Returns a subsequence of the array take from input. The original array is cut starting
+     * from begin position indicated by the homonymous parameter up to (begin + size) position.
+     *
+     * @param array this is the array tu cut
+     * @param begin it represents the start position of the subsequence
+     * @param size  is the length of the subsequence
+     * @return the subsequence of the array
+     * @see SortArray
+     */
+    private int[] getSubArray(SortArray array, int begin, int size) {
+        int arr[] = new int[size];
+        for (int i = 0; i < size; i++) {
+            arr[i] = array.getValue(begin + i);
+        }
+        return arr;
+    }
+
+    /**
+     * This is the core of the algorithm merge sort,
+     * take the array from input and do the cut and merge things.
+     *
+     * @param array  this is the array to cut and merge
+     * @param left   the left index of the array
+     * @param middle the middle index of the array
+     * @param right  the right index of the array
+     * @see SortArray
+     */
+    private void merge(SortArray array, int left, int middle, int right) {
+        int leftSize = middle - left + 1;
+        int rightSize = right - middle;
+
+        int leftArray[] = getSubArray(array, left, leftSize);
+        int rightArray[] = getSubArray(array, middle + 1, rightSize);
+
+        int i = 0, j = 0, k = left;
+        while (i < leftSize && j < rightSize) {
+            if (leftArray[i] <= rightArray[j]) {
+                array.updateSingle(k, leftArray[i], getDelay(), true);
+                i++;
+            } else {
+                array.updateSingle(k, rightArray[j], getDelay(), true);
+                j++;
+            }
+            k++;
+        }
+
+        while (i < leftSize) {
+            array.updateSingle(k, leftArray[i], getDelay(), true);
+            i++;
+            k++;
+        }
+
+        while (j < rightSize) {
+            array.updateSingle(k, rightArray[j], getDelay(), true);
+            j++;
+            k++;
+        }
+    }
+
+    /**
+     * Merge sort is a "divide and conquer" algorithm, it works by splitting the array into tiny sections
+     * sorting them indivually, and then finally merges it back together, see
+     * <a href="https://en.wikipedia.org/wiki/Merge_sort">Merge_sort</a> to understand more.
+     * The method takes a SortArray object called array and sorts his elements according to the mathematical theory
+     * of the order "less than", see <a href="https://en.wikipedia.org/wiki/Order_theory">Order_theory</a> to
+     * understand more.
+     * Recursion was adopted for simplicity
+     *
+     * @param array the array to be sorted
+     * @param left  the left index of the array
+     * @param right the right index of the array
+     * @see SortArray
+     */
+    private void mergeSort(SortArray array, int left, int right) {
+        if (left < right) {
+            int middleIndex = (left + right) / 2;
+
+            mergeSort(array, left, middleIndex);
+            mergeSort(array, middleIndex + 1, right);
+            merge(array, left, middleIndex, right);
+        }
+    }
+
+    /**
+     * This is the method that call the first instance of mergeSort.
+     * Merge sort is a "divide and conquer" algorithm, it works by splitting the array into tiny sections
+     * sorting them indivually, and then finally merges it back together, see
+     * <a href="https://en.wikipedia.org/wiki/Merge_sort">Merge_sort</a> to understand more.
+     * The method takes a SortArray object called array and sorts his elements according to the mathematical theory
+     * of the order "less than", see <a href="https://en.wikipedia.org/wiki/Order_theory">Order_theory</a> to
+     * understand more.
+     *
+     * @param array the array to be sorted
+     * @see SortArray
+     */
+    @Override
+    public void runSort(SortArray array) {
+        int left = 0;
+        int right = array.arraySize() - 1;
+        mergeSort(array, left, right);
+    }
+
+    @Override
+    public String getName() {
+        return "Merge Sort";
+    }
+    public String getName1() {
+        return "Time: (nlogn)\n Space: O(n)";
+    }
+
+    @Override
+    public long getDelay() {
+        return stepDelay;
+    }
+
+    @Override
+    public void setDelay(long delay) {
+        this.stepDelay = delay;
+    }
+}

out/production/Data Structures Algorithm visualizer/sortvisualiser/MainApp.class

@@ -0,0 +1,52 @@
+package sortvisualiser.algorithms;
+
+import sortvisualiser.SortArray;
+
+public class QuickSort implements ISortAlgorithm {
+
+    private long stepDelay = 30;
+    private int findPivotPoint(SortArray array, int lowIndex, int highIndex) {
+        int pivotValue = array.getValue(highIndex);
+        int i = lowIndex - 1;
+        for (int j = lowIndex; j <= highIndex - 1; j++) {
+            if (array.getValue(j) <= pivotValue) {
+                i++;
+                array.swap(i, j, getDelay(), true);
+            }
+        }
+        array.swap(i + 1, highIndex, getDelay(), true);
+        return i + 1;
+    }
+
+    private void quickSort(SortArray array, int lowIndex, int highIndex) {
+        if (lowIndex < highIndex) {
+            int pivotPoint = findPivotPoint(array, lowIndex, highIndex);
+            quickSort(array, lowIndex, pivotPoint - 1);
+            quickSort(array, pivotPoint + 1, highIndex);
+        }
+    }
+
+    @Override
+    public void runSort(SortArray array) {
+        quickSort(array, 0, array.arraySize() - 1);
+    }
+
+    @Override
+    public String getName() {
+        return "Quick Sort";
+    }
+    public String getName1() {
+        return "Time: (nlogn)\n Space: O(n)";
+    }
+
+    @Override
+    public long getDelay() {
+        return stepDelay;
+    }
+
+    @Override
+    public void setDelay(long delay) {
+        this.stepDelay = delay;
+    }
+
+}

out/production/Data Structures Algorithm visualizer/sortvisualiser/SortArray.class

@@ -0,0 +1,95 @@
+package sortvisualiser.algorithms;
+import java.util.Arrays;
+import sortvisualiser.SortArray;
+
+/**
+ * Radix sort implementation
+ *
+ * @author Randy Bushman
+ */
+public class RadixSort implements ISortAlgorithm {
+
+    private long stepDelay = 5;
+    private int radix;
+    private int[] countingArr;
+
+    /**
+     * @param radix The number system that you wish to work in. Must be greater than zero.
+     */
+    public RadixSort(int radix)
+    {
+        this.radix = radix;
+        countingArr = new int[radix];
+    }
+
+    /**
+     * Sets Radix to 10 by default.
+     */
+    public RadixSort()
+    {
+        this(10);
+    }
+
+    /**
+     * This is the method that call the first instance of Radix Sort.
+     * Radix Sort is a non comparison based algorithm that uses counting sort as a subroutine.
+     * It works by sorting by the least significant digit from smallest to largest. It then
+     * sorts the next least significant digit and so on. We are not limited to the decimal number
+     * system however. We can sort in Hex, Binary, etc; hence the name Radix Sort.
+     *
+     * @param array the array to be sorted
+     * @see SortArray
+     */
+    @Override
+    public void runSort(SortArray array)
+    {
+        int largest = array.getMaxValue();
+        int[] result = new int[array.arraySize()];
+
+        for(int exp = 1; largest/exp > 0; exp *= radix)		//in real life if Radix was 2, then we would bit shift.
+        {
+            countingArr = countingSort(array, exp);
+
+            for(int i = 0; i < result.length; ++i)
+                array.updateSingle(i, result[i] = array.getValue(i), getDelay(), false);
+
+            for(int i = 1; i < radix; ++i)
+                countingArr[i] += countingArr[i-1];
+
+            for(int i = array.arraySize() - 1; i > -1 ; --i)
+                array.updateSingle(--countingArr[(result[i]/exp)%radix], result[i], getDelay(), true);
+        }
+    }
+
+    /**
+     * Performs a Counting Sort subroutine
+     * @param arr The array being sorted
+     * @param exp The current exponent
+     * @return A counting array that gives new indices to all values
+     */
+    private int[] countingSort(SortArray arr, int exp)
+    {
+        Arrays.fill(countingArr, 0);
+        for(int i = 0; i < arr.arraySize(); ++i)
+            countingArr[(arr.getValue(i)/exp)%radix]++;
+        return countingArr;
+    }
+
+    @Override
+    public String getName() {
+        return "Radix Sort (Base " + radix + ")";
+    }
+    public String getName1() {
+        return "Time: (nlogn)\n Space: O(n)";
+    }
+
+    @Override
+    public long getDelay() {
+        return stepDelay;
+    }
+
+    @Override
+    public void setDelay(long delay) {
+        this.stepDelay = delay;
+    }
+}

out/production/Data Structures Algorithm visualizer/sortvisualiser/algorithms/BubbleSort.class

@@ -0,0 +1,54 @@
+package sortvisualiser.algorithms;
+
+import sortvisualiser.SortArray;
+
+/**
+ * Selection sort implementation
+ *
+ * @author Matt Hopson
+ */
+public class SelectionSort implements ISortAlgorithm {
+
+    private long stepDelay = 120;
+    /**
+     * This method implements the Selection sort algorithm, see
+     * <a href="https://en.wikipedia.org/wiki/Selection_sort">Selection_sort</a> to understand more.
+     * Takes a SortArray object called array and sorts his elements according to the mathematical theory
+     * of the order "less than", see <a href="https://en.wikipedia.org/wiki/Order_theory">Order_theory</a> to
+     * understand more.
+     *
+     * @param array the array to be sorted
+     * @see SortArray
+     */
+    @Override
+    public void runSort(SortArray array) {
+        int len = array.arraySize();
+        for (int i = 0; i < len - 1; i++) {
+            int minIndex = i;
+            for (int j = i + 1; j < len; j++) {
+                if (array.getValue(j) < array.getValue(minIndex)) {
+                    minIndex = j;
+                }
+            }
+            array.swap(i, minIndex, getDelay(), true);
+        }
+    }
+
+    @Override
+    public String getName() {
+        return "Selection Sort";
+    }
+    public String getName1() {
+        return "Time: (nlogn)\n Space: O(n)";
+    }
+
+    @Override
+    public long getDelay() {
+        return stepDelay;
+    }
+
+    @Override
+    public void setDelay(long delay) {
+        this.stepDelay = delay;
+    }
+}

out/production/Data Structures Algorithm visualizer/sortvisualiser/algorithms/ISortAlgorithm.class

@@ -0,0 +1,142 @@
+package sortvisualiser.screens;
+
+import java.awt.CheckboxGroup;
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Dimension;
+import java.awt.event.ActionEvent;
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+
+import javax.imageio.ImageIO;
+import javax.swing.*;
+
+import sortvisualiser.MainApp;
+import sortvisualiser.algorithms.*;
+
+
+public final class MainMenuScreen extends Screen {
+    private static final Color BACKGROUND_COLOUR = Color.BLUE;
+    private final ArrayList<AlgorithmCheckBox> checkBoxes;
+
+    public MainMenuScreen(MainApp app) {
+        super(app);
+        checkBoxes = new ArrayList<>();
+        setUpGUI();
+    }
+
+    private void addCheckBox(ISortAlgorithm algorithm, JPanel panel) {
+        JRadioButton box = new JRadioButton("", true);
+        box.setAlignmentX(Component.LEFT_ALIGNMENT);
+        box.setBackground(BACKGROUND_COLOUR);
+        box.setForeground(Color.WHITE);
+        checkBoxes.add(new AlgorithmCheckBox(algorithm, box));
+        panel.add(box);
+    }
+
+    private void initContainer(JPanel p) {
+        p.setLayout(new BoxLayout(p, BoxLayout.PAGE_AXIS));
+        p.setBackground(BACKGROUND_COLOUR);
+        //p.setBorder(BorderFactory.createLineBorder(Color.WHITE));
+    }
+
+    public void setUpGUI() {
+        JPanel sortAlgorithmContainer = new JPanel();
+        JPanel optionsContainer = new JPanel();
+        JPanel outerContainer = new JPanel();
+        initContainer(this);
+        initContainer(optionsContainer);
+        initContainer(sortAlgorithmContainer);
+
+        outerContainer.setBackground(BACKGROUND_COLOUR);
+        outerContainer.setLayout(new BoxLayout(outerContainer, BoxLayout.LINE_AXIS));
+
+        try {
+            ClassLoader loader = getClass().getClassLoader();
+            BufferedImage image = ImageIO.read(new File(loader.getResource("logo.png").getFile()));
+            JLabel label = new JLabel(new ImageIcon(image));
+            label.setAlignmentX(Component.LEFT_ALIGNMENT);
+            add(label);
+        } catch (IOException e) {
+            System.out.println("Unable to load logo");
+        }
+
+        sortAlgorithmContainer.setAlignmentX(Component.LEFT_ALIGNMENT);
+        addCheckBox(new BubbleSort(),       sortAlgorithmContainer);
+        addCheckBox(new SelectionSort(),    sortAlgorithmContainer);
+        addCheckBox(new QuickSort(),        sortAlgorithmContainer);
+        addCheckBox(new MergeSort(),        sortAlgorithmContainer);
+        addCheckBox(new InsertionSort(),    sortAlgorithmContainer);
+        addCheckBox(new RadixSort(),        sortAlgorithmContainer);
+
+//        JCheckBox soundCheckBox = new JCheckBox("Play Sounds");
+//        soundCheckBox.setAlignmentX(Component.LEFT_ALIGNMENT);
+//        soundCheckBox.setBackground(BACKGROUND_COLOUR);
+//        soundCheckBox.setForeground(Color.WHITE);
+
+//        optionsContainer.add(soundCheckBox);
+
+        JButton startButton = new JButton("Start");
+        startButton.addActionListener((ActionEvent e) -> {
+            ArrayList<ISortAlgorithm> algorithms = new ArrayList<>();
+            for (AlgorithmCheckBox cb : checkBoxes) {
+                if (cb.isSelected()) {
+                    algorithms.add(cb.getAlgorithm());
+                }
+            }
+            app.pushScreen(
+                    new SortingVisualiserScreen(
+                            algorithms,
+//                            soundCheckBox.isSelected(),
+                            app
+                    ));
+        });
+        startButton.setAlignmentX(Component.LEFT_ALIGNMENT);
+
+        outerContainer.add(optionsContainer);
+        outerContainer.add(Box.createRigidArea(new Dimension(5,0)));
+        outerContainer.add(sortAlgorithmContainer);
+
+        int gap = 15;
+        add(Box.createRigidArea(new Dimension(0, gap)));
+        add(outerContainer);
+        add(Box.createRigidArea(new Dimension(0, gap)));
+        add(startButton);
+    }
+
+    @Override
+    public void onOpen() {
+        checkBoxes.forEach((box) -> {
+            box.unselect();
+
+        });
+
+    }
+
+    private class AlgorithmCheckBox {
+        private final ISortAlgorithm algorithm;
+        private final JRadioButton box;
+
+        public AlgorithmCheckBox(ISortAlgorithm algorithm, JRadioButton box) {
+            this.algorithm = algorithm;
+            this.box = box;
+            this.box.setText(algorithm.getName());
+        }
+
+        public void unselect() {
+            box.setSelected(false);
+        }
+
+
+        public boolean isSelected() {
+            return box.isSelected();
+        }
+
+        public ISortAlgorithm getAlgorithm() {
+            return algorithm;
+        }
+    }
+
+}

out/production/Data Structures Algorithm visualizer/sortvisualiser/algorithms/InsertionSort.class

@@ -0,0 +1,25 @@
+package sortvisualiser.screens;
+
+import static sortvisualiser.MainApp.WIN_HEIGHT;
+import static sortvisualiser.MainApp.WIN_WIDTH;
+
+import java.awt.Dimension;
+
+import javax.swing.JPanel;
+
+import sortvisualiser.MainApp;
+
+public abstract class Screen extends JPanel {
+    protected MainApp app;
+
+    public Screen(MainApp app) {
+        this.app = app;
+    }
+
+    @Override
+    public Dimension getPreferredSize() {
+        return new Dimension(WIN_WIDTH, WIN_HEIGHT);
+    }
+
+    public abstract void onOpen();
+}

out/production/Data Structures Algorithm visualizer/sortvisualiser/algorithms/MergeSort.class

@@ -0,0 +1,79 @@
+package sortvisualiser.screens;
+
+import java.awt.BorderLayout;
+import java.util.ArrayList;
+import javax.swing.SwingWorker;
+import sortvisualiser.MainApp;
+import sortvisualiser.SortArray;
+import sortvisualiser.algorithms.ISortAlgorithm;
+
+/**
+ * The main class for the sort visualiser GUI
+ *
+ * @author Matt Hopson
+ */
+public final class SortingVisualiserScreen extends Screen {
+    private final SortArray sortArray;
+    private final ArrayList<ISortAlgorithm> sortQueue;
+
+    /**
+     * Creates the GUI
+     * @param algorithms List of algorithms to run for visualisation
+     * @param app The main application
+     */
+    public SortingVisualiserScreen(ArrayList<ISortAlgorithm> algorithms, MainApp app) {
+        super(app);
+        setLayout(new BorderLayout());
+        sortArray = new SortArray();
+        add(sortArray, BorderLayout.CENTER);
+        sortQueue = algorithms;
+    }
+
+    private void longSleep() {
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException ex) {
+            ex.printStackTrace();
+        }
+    }
+
+    private void shuffleAndWait() {
+        sortArray.shuffle();
+        sortArray.resetColours();
+        longSleep();
+    }
+
+    public void onOpen() {
+        SwingWorker<Void, Void> swingWorker = new SwingWorker<>() {
+            @Override
+            protected Void doInBackground() {
+                try {
+                    Thread.sleep(250);
+                } catch (InterruptedException ex) {
+                    ex.printStackTrace();
+                }
+                for (ISortAlgorithm algorithm : sortQueue) {
+                    shuffleAndWait();
+
+                    sortArray.setName(algorithm.getName());
+                    sortArray.setComplexity(algorithm.getName1());
+                    sortArray.setAlgorithm(algorithm);
+
+                    algorithm.runSort(sortArray);
+                    sortArray.resetColours();
+                    sortArray.highlightArray();
+                    sortArray.resetColours();
+                    longSleep();
+                }
+                return null;
+            }
+
+            @Override
+            public void done() {
+                app.popScreen();
+            }
+        };
+
+        swingWorker.execute();
+    }
+}