added insertion sort

Author: sethcg

core/include/sorts/InsertionSort.hpp

@@ -0,0 +1,17 @@
+#ifndef INSERTION_SORT_H
+#define INSERTION_SORT_H
+
+#include <SDL3/SDL.h>
+
+#include <Rect.hpp>
+#include <Sort.hpp>
+
+namespace InsertionSort {
+
+    int GetStepCount(Rectangle* items);
+
+    SortSequence GetSequence(Rectangle* items);
+
+}
+
+#endif

core/src/sorts/BubbleSort.cpp

@@ -14,7 +14,6 @@ namespace BubbleSort {
 
         int stepCount = 1;
 
-        int temp;
         bool swapped;
         for (int i = 0; i < LIST_SIZE - 1; i++) {
             swapped = false;
@@ -44,7 +43,7 @@ namespace BubbleSort {
         sort.steps = (SortStep*) malloc(LIST_SIZE * stepCount * sizeof(SortStep));
 
         int currentStep = 0;
-        int temp, offset;
+        int offset;
         bool swapped;
         for (int index = 0; index < LIST_SIZE - 1; index++) {
             swapped = false;

core/src/sorts/CocktailSort.cpp

@@ -12,7 +12,6 @@ namespace CocktailSort {
     int GetStepCount(Rectangle* items) {
         Rectangle* array = CopyArray(items);
 
-        int temp;
         int stepCount = 0;
 
         bool swapped = true;
@@ -76,8 +75,8 @@ namespace CocktailSort {
         SortSequence sort = create_sort_sequence(stepCount);
         sort.steps = (SortStep*) malloc(LIST_SIZE * stepCount * sizeof(SortStep));
 
+        int offset;
         int currentStep = 0;
-        int temp, offset;
 
         bool swapped = true;
         int start = 0;

core/src/sorts/HeapSort.cpp

@@ -62,7 +62,6 @@ namespace HeapSort {
         (*stepCount)++;
 
         free(array);
-        int test = stepCount[0];
         return stepCount[0];
     }
 

core/src/sorts/InsertionSort.cpp

@@ -0,0 +1,98 @@
+#include <stdlib.h>
+#include <SDL3/SDL.h>
+
+#include <InsertionSort.hpp>
+#include <List.hpp>
+#include <Rect.hpp>
+#include <Sort.hpp>
+#include <Utils.hpp>
+
+namespace InsertionSort {
+
+    int GetStepCount(Rectangle* items) {
+        Rectangle* array = CopyArray(items);
+
+        int stepCount = 1;
+
+        for (int index = 1; index < LIST_SIZE; ++index) {
+            int key = array[index].value;
+            int j = index - 1;
+
+            while (j >= 0 && array[j].value > key) {
+                array[j + 1].value = array[j].value;
+                j = j - 1;
+
+                // INCREMENT THE STEP COUNTER (CHECKING)
+                stepCount++;
+            }
+            array[j + 1].value = key;
+
+            // INCREMENT THE STEP COUNTER
+            stepCount++;
+        }
+
+        free(array);
+        return stepCount;
+    }
+
+    SortSequence GetSequence(Rectangle* items) {
+        Rectangle* array = CopyArray(items);
+
+        // INITIALLY RUN THE SORT TO CALCULATE THE TOTAL NUMBER OF STEPS
+        int stepCount = GetStepCount(items);
+
+        SortSequence sort = create_sort_sequence(stepCount);
+        sort.steps = (SortStep*) malloc(LIST_SIZE * stepCount * sizeof(SortStep));
+
+        int currentStep = 0;
+        int offset;
+
+        for (int index = 1; index < LIST_SIZE; ++index) {
+            int key = array[index].value;
+            int j = index - 1;
+
+            while (j >= 0 && array[j].value > key) {
+                array[j + 1].value = array[j].value;
+                j = j - 1;
+
+                // RECORD THE SORTING STEP (SNAPSHOT OF THE ARRAY)
+                for (int i = 0; i < LIST_SIZE; i++) {
+                    offset = (currentStep * LIST_SIZE) + i;
+                    sort.steps[offset].value = array[i].value;
+
+                    // SET RECTANGLE COLOR VALUE
+                    bool isCurrent = i == (index - 1);
+                    bool isChecking = i == j;
+                    bool isOrdered = !isCurrent && !isChecking && i < index;
+                    sort.steps[offset].rect_color = GetRectangleColor(isOrdered, isCurrent, isChecking);
+                }
+                currentStep++;
+            }
+            array[j + 1].value = key;
+
+            // RECORD THE SORTING STEP (SNAPSHOT OF THE ARRAY)
+            for (int i = 0; i < LIST_SIZE; i++) {
+                offset = (currentStep * LIST_SIZE) + i;
+                sort.steps[offset].value = array[i].value;
+
+                // SET RECTANGLE COLOR VALUE
+                bool isCurrent = i == (index - 1);
+                bool isChecking = i == j;
+                bool isOrdered = !isCurrent && !isChecking && i < index;
+                sort.steps[offset].rect_color = GetRectangleColor(isOrdered, isCurrent, isChecking);
+            }
+            currentStep++;
+        }
+
+        // RECORD FINAL STEP (ORDERED LIST)
+        for (int i = 0; i < LIST_SIZE; i++) {
+            offset = (currentStep * LIST_SIZE) + i;
+            sort.steps[offset].value = array[i].value;
+            sort.steps[offset].rect_color = rect_green_color;
+        }
+
+        free(array);
+        return sort;
+    }
+
+}

core/src/utils/Sort.cpp

@@ -6,6 +6,7 @@
 #include <BubbleSort.hpp>
 #include <CocktailSort.hpp>
 #include <HeapSort.hpp>
+#include <InsertionSort.hpp>
 
 SortSequence GetSortSequence(int sortId, Rectangle* items) {
     switch(sortId) {
@@ -16,8 +17,7 @@ SortSequence GetSortSequence(int sortId, Rectangle* items) {
         case 2:
             return HeapSort::GetSequence(items);
         case 3:
-            SDL_Log("Start Insertion Sort...");
-            break;
+            return InsertionSort::GetSequence(items);
         case 4:
             SDL_Log("Start Merge Sort...");
             break;