Cleaned up complexity attributes and removed redundant status' (Algor…

…ithm complete in each sort)
nathanjukes · Jun 16, 2020 · 3812e0f · 3812e0f
1 parent fb48d9b
commit 3812e0f
Show file tree

Hide file tree

Showing 53 changed files with 311 additions and 197 deletions.
diff --git a/.vs/SortingAlgorithmVisualisation/v16/.suo b/.vs/SortingAlgorithmVisualisation/v16/.suo
diff --git a/README.md b/README.md
@@ -8,8 +8,8 @@
   <a href="https://scrutinizer-ci.com/g/pH7Software/pH7-Social-Dating-CMS/build-status/master">
       <img src="https://scrutinizer-ci.com/g/pH7Software/pH7-Social-Dating-CMS/badges/build.png?b=master">
   </a>
-  <a href="https://img.shields.io/badge/version-v1.04-blue">
-    <img src="https://img.shields.io/badge/version-v1.04-blue">
+  <a href="https://img.shields.io/badge/version-v1.05-blue">
+    <img src="https://img.shields.io/badge/version-v1.05-blue">
   </a>
   <a href="https://github.com/nathanjukes/Sorting-Algorithm-Visualisation/blob/master/LICENSE.md">
     <img src="https://img.shields.io/github/license/Naereen/StrapDown.js.svg">
@@ -34,6 +34,8 @@ Or download here:
 
 ## Change Log
 
+- 1.05 - Added Cycle Sort
+
 - 1.04 - Added Odd-Even Sort
 
 - 1.03 - Added Gnome Sort, Changed GUI Sizing

diff --git a/SortingAlgorithmVisualisation/Algorithms/AlgorithmBase.cs b/SortingAlgorithmVisualisation/Algorithms/AlgorithmBase.cs
@@ -22,16 +22,59 @@ public abstract class AlgorithmBase
         public abstract int elementCount { get; set; }
         public abstract void BeginAlgorithm(int[] elements);
 
-        protected void ShowCompletedDisplay(Graphics graphics, int maxWidth, int maxHeight, int[] elements, int threadDelay)
+        public void ShowCompletedDisplay(int[] elements)
         {
-            FormattingDisplay formatDisplay = new FormattingDisplay();
+            ShowAllGreen(elements);
+        }
+
+        private void ShowAllGreen(int[] elements)
+        {
+            if (threadDelay == 200)
+            {
+                threadDelay = 80;
+            }
+            else if (threadDelay == 0)
+            {
+                threadDelay = 1;
+            }
+
+            for (int i = 0; i < elements.Length; i++)
+            {
+                graphics.FillRectangle(new SolidBrush(Color.FromArgb(83, 153, 182)), i * maxWidth, maxHeight - elements[i], maxWidth, elements[i]);
+                Thread.Sleep(threadDelay);
+            }
+        }
 
-            formatDisplay.ShowAllGreen(graphics, maxWidth, maxHeight, elements, threadDelay);
+        public void SetComplexity(int complexityRangeValue)
+        {
+            switch (complexityRangeValue)
+            {
+                case 0:
+                    timeComplexity = "O(nLog(n))";
+                    spaceComplexity = "O(1)";
+                    break;
+                case 1:
+                    timeComplexity = "O(nLog(n))";
+                    spaceComplexity = "O(Log(n))";
+                    break;
+                case 2:
+                    timeComplexity = "O(nLog(n))";
+                    spaceComplexity = "O(n)";
+                    break;
+                case 3:
+                    timeComplexity = "O(nk)";
+                    spaceComplexity = "O(n+k)";
+                    break;
+                case 4:
+                    timeComplexity = "O(n²)";
+                    spaceComplexity = "O(1)";
+                    break;
+            }
         }
 
         protected void SwapElements(int index1, int index2, int[] elements, int sortType)
         {
-            switch(sortType)
+            switch (sortType)
             {
                 case 0:
                     graphics.FillRectangle(new SolidBrush(Color.DarkRed), index1 * maxWidth, maxHeight - elements[index1], maxWidth, elements[index1]);
@@ -58,7 +101,7 @@ protected void SwapElements(int index1, int index2, int[] elements, int sortType
             elements[index1] = elements[index2];
             elements[index2] = tempValue;
 
-            switch(sortType)
+            switch (sortType)
             {
                 default:
                     graphics.FillRectangle(new SolidBrush(Color.Black), index1 * maxWidth, maxHeight - elements[index1], maxWidth, elements[index1]);
@@ -68,11 +111,11 @@ protected void SwapElements(int index1, int index2, int[] elements, int sortType
                     graphics.FillRectangle(new SolidBrush(Color.DarkRed), index1 * maxWidth, maxHeight - elements[index1], maxWidth, elements[index1]);
                     graphics.FillRectangle(new SolidBrush(Color.Black), index2 * maxWidth, maxHeight - elements[index2], maxWidth, elements[index2]);
 
-                    if(GetType().Name.Contains("Selection"))
+                    if (GetType().Name.Contains("Selection"))
                     {
                         Thread.Sleep(threadDelay);
                     }
-                    
+
                     graphics.FillRectangle(new SolidBrush(Color.Black), index1 * maxWidth, maxHeight - elements[index1], maxWidth, elements[index1]);
                     break;
                 case 2:

diff --git a/SortingAlgorithmVisualisation/Algorithms/BogoSort.cs b/SortingAlgorithmVisualisation/Algorithms/BogoSort.cs
@@ -15,8 +15,6 @@ class BogoSort : AlgorithmBase
         private int[] elementsCopy;
         public override void BeginAlgorithm(int[] elements)
         {
-            elementCount = elements.Length;
-
             elementsCopy = (int[])elements.Clone();
 
             StartBogoSort(elements);
@@ -54,7 +52,7 @@ private void StartBogoSort(int[] elements)
                 if (CheckIfSorted(elements))
                 {
                     DisplaySort.SortComplete = true;
-                    ShowCompletedDisplay(graphics, maxWidth, maxHeight, elements, threadDelay);
+                    ShowCompletedDisplay(elements);
                     break;
                 }
                 else

diff --git a/SortingAlgorithmVisualisation/Algorithms/BubbleSort.cs b/SortingAlgorithmVisualisation/Algorithms/BubbleSort.cs
@@ -15,14 +15,10 @@ class BubbleSort : AlgorithmBase
 
         public override void BeginAlgorithm(int[] elements)
         {
-            elementCount = elements.Length;
-
-            Sort(elements, graphics, maxWidth, maxHeight);
-
-            DisplaySort.SortComplete = true;
+            StartBubbleSort(elements);
         }
 
-        private void Sort(int[] elements, Graphics graphics, int maxWidth, int maxHeight)
+        private void StartBubbleSort(int[] elements)
         {
             for (int i = 0; i < elementCount; i++)
             {
@@ -34,8 +30,6 @@ private void Sort(int[] elements, Graphics graphics, int maxWidth, int maxHeight
                     }
                 }
             }
-
-            ShowCompletedDisplay(graphics, maxWidth, maxHeight, elements, threadDelay);
         }
     }
 }
diff --git a/SortingAlgorithmVisualisation/Algorithms/CocktailSort.cs b/SortingAlgorithmVisualisation/Algorithms/CocktailSort.cs
@@ -15,13 +15,7 @@ class CocktailSort : AlgorithmBase
 
         public override void BeginAlgorithm(int[] elements)
         {
-            elementCount = elements.Length;
-
             StartCocktailSort(elements);
-
-            DisplaySort.SortComplete = true;
-
-            ShowCompletedDisplay(graphics, maxWidth, maxHeight, elements, threadDelay);
         }
 
         private void StartCocktailSort(int[] elements)

diff --git a/SortingAlgorithmVisualisation/Algorithms/CombSort.cs b/SortingAlgorithmVisualisation/Algorithms/CombSort.cs
@@ -13,13 +13,7 @@ class CombSort : AlgorithmBase
 
         public override void BeginAlgorithm(int[] elements)
         {
-            elementCount = elements.Length;
-
             StartCombSort(elements);
-
-            DisplaySort.SortComplete = true;
-
-            ShowCompletedDisplay(graphics, maxWidth, maxHeight, elements, threadDelay);
         }
 
         private void StartCombSort(int[] elements)

diff --git a/SortingAlgorithmVisualisation/Algorithms/CycleSort.cs b/SortingAlgorithmVisualisation/Algorithms/CycleSort.cs
@@ -1,4 +1,4 @@
-using System;
+    using System;
 using System.Collections.Generic;
 using System.Drawing;
 using System.Linq;
@@ -15,13 +15,7 @@ class CycleSort : AlgorithmBase
 
         public override void BeginAlgorithm(int[] elements)
         {
-            elementCount = elements.Length;
-
             StartCycleSort(elements);
-
-            DisplaySort.SortComplete = true;
-
-            ShowCompletedDisplay(graphics, maxWidth, maxHeight, elements, threadDelay);
         }
 
         private void StartCycleSort(int[] elements)

diff --git a/SortingAlgorithmVisualisation/Algorithms/GnomeSort.cs b/SortingAlgorithmVisualisation/Algorithms/GnomeSort.cs
@@ -13,20 +13,13 @@ class GnomeSort : AlgorithmBase
 
         public override void BeginAlgorithm(int[] elements)
         {
-            elementCount = elements.Length;
-
             StartGnomeSort(elements);
-
-            DisplaySort.SortComplete = true;
-
-            ShowCompletedDisplay(graphics, maxWidth, maxHeight, elements, threadDelay);
         }
 
         private void StartGnomeSort(int[] elements)
         {
             for(int i = 0; i < elementCount; i++)
             {
-
                 if(i + 1 < elementCount && i >= 0 && elements[i] > elements[i + 1])
                 {
                     SwapElements(i, i + 1, elements, 1);

diff --git a/SortingAlgorithmVisualisation/Algorithms/HeapSort.cs b/SortingAlgorithmVisualisation/Algorithms/HeapSort.cs
@@ -20,8 +20,6 @@ class HeapSort : AlgorithmBase
 
         public override void BeginAlgorithm(int[] elements)
         {
-            elementCount = elements.Length;
-
             sortedLength = elementCount;
 
             if (elementCount % 2 == 0)
@@ -33,10 +31,6 @@ public override void BeginAlgorithm(int[] elements)
             Heapify(elements);
 
             DeleteElements(elements);
-
-            DisplaySort.SortComplete = true;
-
-            ShowCompletedDisplay(graphics, maxWidth, maxHeight, elements, threadDelay);
         }
 
         private void Heapify(int[] elements)

diff --git a/SortingAlgorithmVisualisation/Algorithms/InsertionSort.cs b/SortingAlgorithmVisualisation/Algorithms/InsertionSort.cs
@@ -14,13 +14,7 @@ class InsertionSort : AlgorithmBase
 
         public override void BeginAlgorithm(int[] elements)
         {
-            elementCount = elements.Length;
-
             StartInsertionSort(elements);
-
-            DisplaySort.SortComplete = true;
-
-            ShowCompletedDisplay(graphics, maxWidth, maxHeight, elements, threadDelay);
         }
 
         private void StartInsertionSort(int[] elements)

diff --git a/SortingAlgorithmVisualisation/Algorithms/MergeSort.cs b/SortingAlgorithmVisualisation/Algorithms/MergeSort.cs
@@ -17,15 +17,9 @@ class MergeSort : AlgorithmBase
         private int qCount = 0;
         public override void BeginAlgorithm(int[] elements)
         {
-            elementCount = elements.Length;
-
             SplitArray(elements);
 
             Thread.Sleep(200);
-
-            DisplaySort.SortComplete = true;
-
-            ShowCompletedDisplay(graphics, maxWidth, maxHeight, elements, threadDelay);
         }
 
         private int[] SplitArray(int[] unsortedElements)

diff --git a/SortingAlgorithmVisualisation/Algorithms/OddEvenSort.cs b/SortingAlgorithmVisualisation/Algorithms/OddEvenSort.cs
@@ -13,13 +13,7 @@ class OddEvenSort : AlgorithmBase
 
         public override void BeginAlgorithm(int[] elements)
         {
-            elementCount = elements.Length;
-
             StartOddEvenSort(elements);
-
-            DisplaySort.SortComplete = true;
-
-            ShowCompletedDisplay(graphics, maxWidth, maxHeight, elements, threadDelay);
         }
 
         private void StartOddEvenSort(int[] elements)

diff --git a/SortingAlgorithmVisualisation/Algorithms/QuickSort.cs b/SortingAlgorithmVisualisation/Algorithms/QuickSort.cs
@@ -14,30 +14,25 @@ class QuickSort : AlgorithmBase
 
         public override void BeginAlgorithm(int[] elements)
         {
-            elementCount = elements.Length;
-            QuickSortStart(elements, 0, elementCount - 1);
-
-            DisplaySort.SortComplete = true;
-
-            ShowCompletedDisplay(graphics, maxWidth, maxHeight, elements, threadDelay);
+            StartQuickSort(elements, 0, elementCount - 1);
         }
 
-        private void QuickSortStart(int[] elements, int startIndex, int endIndex)
+        private void StartQuickSort(int[] elements, int startIndex, int endIndex)
         {
             if(startIndex >= endIndex)
             {
                 return;
             }
             else
             {
-                int midIndex = findNextIndex(elements, startIndex, endIndex);
+                int midIndex = FindNextIndex(elements, startIndex, endIndex);
 
-                QuickSortStart(elements, startIndex, midIndex - 1);
-                QuickSortStart(elements, midIndex + 1, endIndex);
+                StartQuickSort(elements, startIndex, midIndex - 1);
+                StartQuickSort(elements, midIndex + 1, endIndex);
             }
         }
 
-        private int findNextIndex(int[] elements, int startIndex, int endIndex)
+        private int FindNextIndex(int[] elements, int startIndex, int endIndex)
         {
             int pivotValue = elements[endIndex];
             int pivotIndex = startIndex;

diff --git a/SortingAlgorithmVisualisation/Algorithms/RadixSort.cs b/SortingAlgorithmVisualisation/Algorithms/RadixSort.cs
@@ -14,12 +14,9 @@ class RadixSort : AlgorithmBase
         public override int elementCount { get; set; }
 
         private string[] elementDuplicates;
+
         public override void BeginAlgorithm(int[] elements)
         {
-            elementCount = elements.Length;
-
-            DisplaySort.SortComplete = true;
-
             StartRadixSort(elements);
         }
 
@@ -37,7 +34,6 @@ private void StartRadixSort(int[] elements)
             }
 
             Thread.Sleep(220);
-            ShowCompletedDisplay(graphics, maxWidth, maxHeight, elements, threadDelay);
         }
 
         private void CountSort(int[] elements, int LengthToMinus)

diff --git a/SortingAlgorithmVisualisation/Algorithms/SelectionSort.cs b/SortingAlgorithmVisualisation/Algorithms/SelectionSort.cs
@@ -14,13 +14,7 @@ class SelectionSort : AlgorithmBase
 
         public override void BeginAlgorithm(int[] elements)
         {
-            elementCount = elements.Length;
-
             StartSelectionSort(elements);
-
-            DisplaySort.SortComplete = true;
-
-            ShowCompletedDisplay(graphics, maxWidth, maxHeight, elements, threadDelay);
         }
 
         private void StartSelectionSort(int[] elements)

diff --git a/SortingAlgorithmVisualisation/Algorithms/ShellSort.cs b/SortingAlgorithmVisualisation/Algorithms/ShellSort.cs
@@ -12,13 +12,7 @@ class ShellSort : AlgorithmBase
         public override int elementCount { get; set; }
         public override void BeginAlgorithm(int[] elements)
         {
-            elementCount = elements.Length;
-
             StartShellSort(elements);
-
-            DisplaySort.SortComplete = true;
-
-            ShowCompletedDisplay(graphics, maxWidth, maxHeight, elements, threadDelay);
         }
 
         private void StartShellSort(int[] elements)