add: selection sort

Author: Casqade

include/SortingAlgorithmVisualizer/Sorters/SelectionSorter.hpp

@@ -0,0 +1,88 @@
+#pragma once
+
+#include <SortingAlgorithmVisualizer/Sorters/ISorterSpecialized.hpp>
+
+
+template <typename T>
+class SelectionSorter : public ISorterSpecialized <T>
+{
+  size_t mSortedIndex {};
+  size_t mCurrentIndex {};
+  size_t mMinimumIndex {};
+
+
+public:
+  SelectionSorter() = default;
+  ~SelectionSorter() override = default;
+
+
+  inline void reset() override
+  {
+    mSortedIndex = 0;
+    mCurrentIndex = 0;
+    mMinimumIndex = 0;
+    resetColors();
+  }
+
+  inline bool step() override
+  {
+    using PlotColor = PlotValueColorIndex::PlotValueColorIndex;
+
+    if ( this->mValues.size() < 2 )
+      return true;
+
+
+    auto& values = this->mValues;
+    auto& colors = this->mColors;
+
+
+    if ( mCurrentIndex != mMinimumIndex && mCurrentIndex != mSortedIndex )
+      colors[mCurrentIndex] = PlotColor::Unsorted;
+
+    colors[++mCurrentIndex] = PlotColor::Caret;
+
+
+    if ( values[mCurrentIndex] < values[mMinimumIndex] )
+    {
+      colors[mMinimumIndex] = PlotColor::Unsorted;
+      mMinimumIndex = mCurrentIndex;
+      colors[mMinimumIndex] = PlotColor::SwappedGreater;
+    }
+
+
+    if ( mCurrentIndex == values.size() - 1 )
+    {
+      std::swap(
+        values[mSortedIndex],
+        values[mMinimumIndex] );
+
+      colors[mMinimumIndex] = PlotColor::Unsorted;
+      colors[mCurrentIndex] = PlotColor::Unsorted;
+
+      mMinimumIndex = ++mSortedIndex;
+      mCurrentIndex = mSortedIndex;
+
+      colors[mMinimumIndex] = PlotColor::SwappedGreater;
+      colors[mSortedIndex - 1] = PlotColor::Sorted;
+    }
+
+
+    bool isSorted =
+      mSortedIndex == values.size() - 1;
+
+    if ( isSorted == true )
+      colors[mSortedIndex] = PlotColor::Sorted;
+
+
+    flushValues();
+    flushColors();
+    swapBuffers();
+
+    return isSorted;
+  }
+
+  inline size_t instanceSize() const override
+  {
+    return sizeof(*this);
+  }
+};

src/main.cpp

@@ -8,6 +8,7 @@
 #include <SortingAlgorithmVisualizer/Sorters/BubbleSorter.hpp>
 #include <SortingAlgorithmVisualizer/Sorters/CocktailSorter.hpp>
 #include <SortingAlgorithmVisualizer/Sorters/InsertionSorter.hpp>
+#include <SortingAlgorithmVisualizer/Sorters/SelectionSorter.hpp>
 #include <SortingAlgorithmVisualizer/Allocators/ArenaAllocator.hpp>
 
 
@@ -22,25 +23,28 @@ WinMain(
   LPSTR cmdArgs,
   int windowShowState )
 {
-  const size_t plotCount = 4;
+  const size_t plotCount = 5;
 
   const char* plotTitles[] =
   {
     "Pseudo sort (PLACEHOLDER)",
     "Bubble sort",
     "Cocktail sort",
     "Insertion sort",
+    "Selection sort",
   };
 
   using Sorter1Type = MockSorter <float>;
   using Sorter2Type = BubbleSorter <int>;
   using Sorter3Type = CocktailSorter <int>;
   using Sorter4Type = InsertionSorter <int>;
+  using Sorter5Type = SelectionSorter <int>;
 
   const size_t plot1ValueCount = 20;
   const size_t plot2ValueCount = 20;
   const size_t plot3ValueCount = 20;
   const size_t plot4ValueCount = 20;
+  const size_t plot5ValueCount = 20;
 
   const size_t callbackStackDepth = 2;
 
@@ -54,10 +58,12 @@ WinMain(
     sizeof(Sorter2Type) +
     sizeof(Sorter3Type) +
     sizeof(Sorter4Type) +
+    sizeof(Sorter5Type) +
     Sorter1Type::HeapMemoryBudget(plot1ValueCount) +
     Sorter2Type::HeapMemoryBudget(plot2ValueCount) +
     Sorter3Type::HeapMemoryBudget(plot3ValueCount) +
     Sorter4Type::HeapMemoryBudget(plot4ValueCount) +
+    Sorter5Type::HeapMemoryBudget(plot5ValueCount) +
 
 //    allocation bookkeeping
     sizeof(IAllocator*) * 9 +
@@ -119,6 +125,7 @@ WinMain(
   backend->addSorter <Sorter2Type> (1, plot2ValueCount);
   backend->addSorter <Sorter3Type> (2, plot3ValueCount);
   backend->addSorter <Sorter4Type> (3, plot4ValueCount);
+  backend->addSorter <Sorter5Type> (4, plot5ValueCount);
 
 
   auto frontend = ObjectCreate <Frontend> (arena, arena, *backend);