Added color for moving elements and checking animation at the end. Added more key events: Change time in milliseconds between each comparison, change number of elements and stop sorting.

Author: alesbe

SortAlgorithms.cpp

@@ -1,40 +1,22 @@
 #include "SortAlgorithms.h"
-#include <iostream>
-#include <chrono>
-#include <thread>
 
-namespace algo {
-	void bubbleSort(std::vector<Sortable>& sortElements, int timeSleep) {
+void algo::bubbleSort(std::vector<Sortable>& sortElements, int timeSleep) {
+	for (int n = 0; n < sortElements.size() - 1; n++) {
+		if (sortElements[n].value > sortElements[n + 1].value) {
+			sortElements[n+1].color = sf::Color::Red;
+			sortElements[n].color = sf::Color::Red;
 
-		for (int n = 0; n < sortElements.size() - 1; n++) {
-
-			/*
-			std::cout << "[";
-			for (auto i : sortElements) {
-				std::cout << i.value << ", ";
-			}
-			std::cout << "]" << std::endl;
-			
-			*/
-
-			if (sortElements[n].value > sortElements[n + 1].value) {
-				// Change color while sorting
-				sortElements[n].color = sf::Color::Red;
-				sortElements[n+1].color = sf::Color::Red;
-
-				// Swap positions
-				auto currElement = sortElements[n];
-				auto tempElement = sortElements[n + 1];
-				sortElements[n + 1] = currElement;
-				sortElements[n] = tempElement;
-
-				// Reset color
-				sortElements[n].color = sf::Color::White;
-				sortElements[n + 1].color = sf::Color::White;
-			}
+			// Swap positions
+			auto currElement = sortElements[n];
+			auto tempElement = sortElements[n + 1];
+			sortElements[n + 1] = currElement;
+			sortElements[n] = tempElement;
 
 			// Wait timeSleep ms between iterations
-			std::this_thread::sleep_for(std::chrono::milliseconds(timeSleep));
+			sf::sleep(sf::milliseconds(timeSleep));
+
+			sortElements[n+1].color = sf::Color::White;
+			sortElements[n].color = sf::Color::White;
 		}
 	}
 }

SortAlgorithms.h

@@ -1,5 +1,11 @@
 #pragma once
 #include <vector>
+
+#if defined(_WIN32)
+#include <Windows.h>
+#define PLATFORM "windows"
+#endif
+
 #include "Sortable.h"
 
 namespace algo {

SortController.cpp

@@ -1,4 +1,6 @@
 #include "SortController.h"
+#include <iostream>
+#include <SFML/System.hpp>
 
 SortController::SortController(sf::Vector2u windowSize, int timeSleep) {
 	this->winWidth = windowSize.x;
@@ -7,38 +9,54 @@ SortController::SortController(sf::Vector2u windowSize, int timeSleep) {
 	this->timeSleep = timeSleep;
 }
 
+///////////////////////////////
+//
+// Vector control methods
+//
+///////////////////////////////
+
 void SortController::clear() {
 	sortElements.clear();
 }
 
 void SortController::populate(int numOfElements) {
 	for (int n = 0; n < numOfElements; n++) {
-		std::cout << (winWidth / numOfElements) << std::endl;
 		Sortable sortable(((float)winWidth / numOfElements), ((float)winHeight / numOfElements) * (n+1), n); // Width defined to space max space in window, height defined by Sortable value
 		sortElements.push_back(sortable);
 	}
 }
 
+void SortController::randomize() {
+	auto rd = std::random_device{};
+	auto rng = std::default_random_engine{ rd() };
+	std::shuffle(std::begin(sortElements), std::end(sortElements), rng);
+};
+
+void SortController::setTimeSleep(int t) {
+	timeSleep = t;
+}
+
+///////////////////////////////
+//
+// Sorting methods
+//
+///////////////////////////////
+
 void SortController::startSort(int sortType) {
-	std::cout << "Sort started via thread!" << std::endl;
 	isSorting = true;
+	sf::Clock timeSort;
 	while (!isSorted())
 	{
 		if (sortType == 0) {
 			algo::bubbleSort(sortElements, timeSleep);
 		}
 	}
+
+	std::cout << timeSort.getElapsedTime().asMilliseconds() << std::endl;
+	checkSort();
 	isSorting = false;
-	std::cout << "Sorting finished!" << std::endl;
-	std::cout << std::endl;
 }
 
-void SortController::randomize() {
-	auto rd = std::random_device{};
-	auto rng = std::default_random_engine{ rd() };
-	std::shuffle(std::begin(sortElements), std::end(sortElements), rng);
-};
-
 bool SortController::isSorted() {
 	for (int n = 0; n < sortElements.size()-1; n++) {
 		if (sortElements[n].value > sortElements[n+1].value)
@@ -50,6 +68,10 @@ bool SortController::isSorted() {
 	return true;
 };
 
+// This function is only for the "checking animation", at this point, the vector is 100% sorted, verified by isSorted()
 void SortController::checkSort() {
-
+	for (int n = 0; n < sortElements.size(); n++) {
+		sortElements[n].color = sf::Color::Green;
+		sf::sleep(sf::milliseconds(timeSleep));
+	}
 };

SortController.h

@@ -2,6 +2,8 @@
 #include <vector>
 #include <algorithm>
 #include <random>
+#include <SFML/System.hpp>
+
 #include "Sortable.h"
 #include "SortAlgorithms.h"
 
@@ -15,11 +17,16 @@ class SortController
 	std::vector<Sortable> sortElements;
 
 	SortController(sf::Vector2u windowSize, int timeSleep);
+
+	// Vector control methods
 	void clear();
 	void populate(int numOfElements);
-	void startSort(int sortType);
 	void randomize();
-	bool isSorted();
+	void setTimeSleep(int t);
+
+	// Sorting methods
+	void startSort(int sortType);
 	void checkSort();
+	bool isSorted();
 };
 

Sortable.h

@@ -5,7 +5,7 @@
 class Sortable
 {
 public:
-	sf::Color color = sf::Color::White;
+	sf::Color color = sf::Color::White; // white 42...95, red: 42...35
 	int value;
 	float width, height;
 

main.cpp

@@ -2,23 +2,21 @@
 - Sort Types -
 0: Bubble Sort
 1: ...
+
+Due to the 1ms resolution of timers on Windows, the speed scale is smaller. The Linux version has a higher time resoltion < 1ms!
 */
 
 #include <SFML/Graphics.hpp>
 #include <iostream>
 #include <thread>
 #include "SortController.h"
 
-void test(int num) {
-    std::cout << "Hi, this is a test and this is my number: " << num << std::endl;
-}
-
 int main()
 {
-    sf::RenderWindow window(sf::VideoMode(600, 400), "Sorting visualizer v0.1-alpha");
+    sf::RenderWindow window(sf::VideoMode(600, 400), "Sorting visualizer v0.2-alpha");
 
-    int numOfElements = 10;
-    int timeSleep = 1;
+    int numOfElements = 50;
+    int timeSleep = 1; // milliseconds
     int sortType = 0;
 
     std::thread sortingThread;
@@ -39,13 +37,23 @@ int main()
                 // Randomize and start sorting
                 case sf::Keyboard::Space:
                     if (!sortController.isSorting) {
-                        std::cout << "Randomizing..." << std::endl;
+                        std::cout << "Starting sort!" << std::endl;
+                        sortController.clear();
+                        sortController.populate(numOfElements);
                         sortController.randomize();
 
                         sortingThread = std::thread(&SortController::startSort, &sortController, sortType);
                         sortingThread.detach();
                     }
+                    break;
 
+                // Stop sort
+                case sf::Keyboard::Backspace:
+                    if (sortController.isSorting) {
+                        std::cout << "Sort stopped!" << std::endl;
+                        sortController.clear();
+                        sortController.populate(numOfElements);
+                    }
                     break;
 
                 // Change sort type (increase)
@@ -76,6 +84,25 @@ int main()
                     std::cout << "Num of elements changed to: " << numOfElements << std::endl;
                     break;
 
+                // Change number of sortables through console
+                case sf::Keyboard::F1:
+                    std::cout << "Number of sortables: ";
+                    std::cin >> numOfElements;
+                    std::cout << std::endl;
+
+                    sortController.clear();
+                    sortController.populate(numOfElements);
+                    break;
+
+                // Change time between iterations
+                case sf::Keyboard::F2:
+                    std::cout << "Time between iterations (milliseconds): ";
+                    std::cin >> timeSleep;
+                    std::cout << std::endl;
+
+                    sortController.setTimeSleep(timeSleep);
+                    break;
+
                 default:
                     break;
                 }
@@ -91,6 +118,7 @@ int main()
         int index = 0;
         for (auto sortable : sortController.sortElements) {
             sf::RectangleShape shape = sortable.shape();
+            shape.setFillColor(sortable.color);
             shape.setPosition(sf::Vector2f(sortable.width * index++, sortController.winHeight - sortable.height));
             window.draw(shape);
         }