v0.1

Author: adrianfn21

OriginalSortAlgorithms/BubbleSort.cpp

@@ -0,0 +1,19 @@
+#include <vector>
+
+using namespace std;
+
+// O(N^2)
+void bubble_sort(vector<int> &vector) {
+    int length = vector.size();
+    // Main loop
+    for (int i = 0; i < length - 1; i++) {
+        for (int j = 0; j < length - i - 1; j++) {
+            // Variable swap
+            if (vector[j] > vector[j + 1]) {
+                int aux = vector[j];
+                vector[j] = vector[j + 1];
+                vector[j + 1] = aux;
+            }
+        }
+    }
+}

OriginalSortAlgorithms/SelectionSort.cpp

@@ -0,0 +1,28 @@
+#include <vector>
+
+using namespace std;
+
+// O(N^2)
+void selection_sort(vector<int> &vector) {
+    int length = vector.size();
+    // Main loop
+    for (int i = 0; i < length; i++) {
+        // With two variables (one for the minimum value and one for its index) we managed to halve the
+        // number of memory accesses of the algorithm
+        int minimum = vector[i];
+        int minumum_index = i;
+        // Search for the minimum
+        for (int j = i + 1; j < length; j++) {
+            if (vector[j] < minimum) {
+                minimum = vector[j];
+                minumum_index = j;
+            }
+        }
+        // Variable swap
+        if (minumum_index != i) {
+            int aux = vector[i];
+            vector[i] = vector[minumum_index];
+            vector[minumum_index] = aux;
+        }
+    }
+}

README.md

@@ -0,0 +1,72 @@
+# Sort Algorithm Viewer
+
+Made by Adrián Fenollar Navarro, 3rd year computer engineering student
+at the University of Murcia; October 26, 2020.
+
+## Introduction
+This project consists of a simple ordering algorithm viewer, 
+with which it is intended that it can be a tool that facilitates 
+the study and learning of these.
+
+That's the first beta version of the application, with only two sort algorithms implemented.
+
+## Requirements
+
+The only thing you need to be able to execute it is:
+
+- A Linux environment (it has only been tested on Ubuntu)
+- Have the SFML library installed
+
+If you don't have SFML installed, you can use the attached script `sfml_installer.sh`
+ to install it, or use the next commands (valid on Ubuntu):
+```
+sudo apt-get update
+sudo apt-get install libsfml-dev
+```
+If you use another version of linux and the above has not worked for you, 
+here is the [official SFML installation page on Linux](https://www.sfml-dev.org/tutorials/2.5/start-linux.php).
+
+If you want to recompile it, you must have the following packages installed:
+
+```
+sudo apt-get build-essential make cmake
+```
+
+## How to compile it
+
+In this repository there is already an executable called `SortAlgorithmViewer` with the 
+project code compiled and ready to run. In the event that this executable does not 
+work for you, or you want to try to make modifications to the code and recompile it, 
+you must execute the next commands from the project directory:
+
+```
+cmake CMakeLists.txt
+make
+```
+
+## How to use it
+
+A more detailed user manual will be included in later versions. At the moment, the 
+program runs as follows:
+
+```
+./SortAlgorithmViewer [OPTIONS] <algorithms>
+```
+
+where the `OPTIONS` are
+
+- `-n, --size <array_size>`: specifies the size of the array
+- `-f, --framerate <framerate>`: specify the number of frames per second
+- `-h, --help`: show help menu
+
+and `algorithms` can be (non case sensitive)
+
+- `Selection`
+- `Bubble`
+
+At the moment only one algorithm can be included per run.
+
+## Updates
+
+(still empty)
+

SortAlgorithmViewer

@@ -0,0 +1,20 @@
+#ifndef SORT_ALGORITHM_VIEWER_SORTALGORITHMS_H
+#define SORT_ALGORITHM_VIEWER_SORTALGORITHMS_H
+
+#include <iostream>
+using namespace std;
+
+#include "VisualWindow.h"
+
+// TODO Add new sort methods
+
+void selection_sort(class VisualWindow &window);
+
+void bubble_sort(class VisualWindow &window);
+
+const static map<string, void (*)(class VisualWindow&)> sortAlgorithm = {
+        {"selection", selection_sort},
+        {"bubble", bubble_sort}
+};
+
+#endif //SORT_ALGORITHM_VIEWER_SORTALGORITHMS_H

include/SortAlgorithms.h

@@ -0,0 +1,56 @@
+#ifndef SORT_ALGORITHM_VIEWER_VISUALVECTOR_H
+#define SORT_ALGORITHM_VIEWER_VISUALVECTOR_H
+
+#include <iostream>
+#include "SortAlgorithms.h"
+
+using namespace std;
+
+#define DEFAULT_ARRAY_SIZE 100
+
+enum BoxStatus {
+    NONE = 0, SELECTED = 1, CHANGED = 2
+};
+
+class VisualVector {
+private:
+    // Properties
+    int *array;
+    BoxStatus *status;
+    int length;
+    int max_value;
+    // Counters
+    long long contComparisons = 0, contArrayAccesses = 0, contSwaps = 0;
+
+public:
+    // Constructor
+    explicit VisualVector(int length);
+
+    // Destroyer
+    ~VisualVector();
+
+    // Operators
+    int & operator[](int i);
+
+    // Getters
+    int getLength() const;
+    int getMaxValue() const;
+    BoxStatus getStatus(int index);
+    long long getNumComparisons() const;
+    long long getNumArrayAccesses() const;
+    long long getNumSwaps() const;
+
+    // Setters
+    void setStatus(int index, BoxStatus status);
+
+    // Main methods
+    void initialize();
+    void fillWithRandom();
+    void addComparisons(int q);
+    void addArrayAccesses(int q);
+    void addSwaps(int q);
+    void print();
+};
+
+
+#endif //SORT_ALGORITHM_VIEWER_VISUALVECTOR_H

include/VisualVector.h

@@ -0,0 +1,49 @@
+#ifndef SORT_ALGORITHM_VIEWER_VISUALWINDOW_H
+#define SORT_ALGORITHM_VIEWER_VISUALWINDOW_H
+
+#include <iostream>
+#include <SFML/Graphics.hpp>
+
+#include "VisualVector.h"
+
+using namespace std;
+using namespace sf;
+
+// Window default dimensions
+#define DEFAULT_WINDOW_WIDTH 600
+#define DEFAULT_WINDOW_HEIGHT 600
+
+// Color palette
+#define NONE_COLOR Color::White
+#define SELECTED_COLOR Color::Blue
+#define CHANGED_COLOR Color::Green
+
+class VisualWindow : public RenderWindow {
+private:
+    // Properties
+    class VisualVector *vector;
+    double width, height;
+    string algorithm;
+    Font font;
+
+    // Helper methods to draw frames
+    void drawBarChart(double x, double y, double width, double height);
+
+public:
+    // Constructor
+    VisualWindow(VisualVector *vector, string algorithm, int framerate, int width, int height, const string &name);
+
+    // Destroyer
+    ~VisualWindow() override;
+
+    // Getters
+    VisualVector *getVisualVector();
+    double getWidth() const;
+    double getHeight() const;
+
+    // Draw methods
+    void drawAndDisplay();
+};
+
+
+#endif //SORT_ALGORITHM_VIEWER_VISUALWINDOW_H

include/VisualWindow.h

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+echo Installing SFML library for your distribution...
+echo Entering privileged mode...
+
+if [ $(command -v apt) ]
+then
+	exec sudo apt install libsfml-dev
+fi
+if [ $(command -v dnf) ]
+then
+	exec sudo dnf install sfml
+fi
+if [ $(command -v rpm) ]
+then
+	exec sudo rpm install sfml
+fi
+if [ $(command -v pacman) ]
+then
+	exec sudo pacman -S sfml
+else
+	echo "Sorry!!!"
+	echo "Your distribution is not supported!!!"
+fi

resources/fonts/jack.ttf

@@ -0,0 +1,97 @@
+#include "../include/SortAlgorithms.h"
+
+// Implies 4 memory accesses
+void swap(int &a, int &b) {
+    int aux = a;
+    a = b;
+    b = aux;
+}
+
+// O(N^2)
+void selection_sort(class VisualWindow &window) {
+
+    VisualVector *vector = window.getVisualVector();
+    Event e{};
+    int length = vector->getLength();
+    // Main loop
+    for (int i = 0; i < length && window.isOpen(); i++) {
+        // Window handler
+        while (window.pollEvent(e)) {
+            // Window closed
+            if (e.type == Event::Closed) {
+                window.close();
+                exit(0);
+            }
+        }
+
+        // With two variables (one for the minimum value and one for its index) we managed to halve the
+        // number of memory accesses of the algorithm
+        int minimum = (*vector)[i];
+        int minumum_index = i;
+        // Search for the minimum
+        for (int j = i + 1; j < length; j++) {
+            if ((*vector)[j] < minimum) {
+                minimum = (*vector)[j];
+                minumum_index = j;
+                vector->addArrayAccesses(1);
+            }
+        }
+        // Variable swap
+        if (minumum_index != i) {
+            swap((*vector)[i], (*vector)[minumum_index]);
+            vector->addArrayAccesses(4);
+            vector->addSwaps(1);
+        }
+
+        // Adding remaining numComparisons and numArrayAccesses
+        vector->addComparisons(length - i);
+        vector->addArrayAccesses(length - i);
+
+        // Set a status for exchanged boxes
+        vector->setStatus(i, CHANGED);
+        vector->setStatus(minumum_index, SELECTED);
+
+        // Draw the current frame
+        window.drawAndDisplay();
+    }
+}
+
+// O(N^2)
+void bubble_sort(class VisualWindow &window) {
+
+    VisualVector *vector = window.getVisualVector();
+    Event e{};
+    int length = vector->getLength();
+    // Main loop
+    for (int i = 0; i < length - 1 && window.isOpen(); i++) {
+        // Window handler
+        while (window.pollEvent(e)) {
+            // Window closed
+            if (e.type == Event::Closed) {
+                window.close();
+                exit(0);
+            }
+        }
+
+        for (int j = 0; j < length - i - 1; j++) {
+            if ((*vector)[j] > (*vector)[j+1]) {
+                swap((*vector)[j],(*vector)[j+1]);
+                vector->addArrayAccesses(4);
+                vector->addSwaps(1);
+
+                // Adding remaining numComparisons and numArrayAccesses
+                vector->addComparisons(length - i);
+                vector->addArrayAccesses(length - i);
+
+                // Set a status for exchanged boxes
+                vector->setStatus(j, CHANGED);
+                vector->setStatus(j + 1, SELECTED);
+
+            }
+
+        }
+
+        // Draw the current frame
+        window.drawAndDisplay();
+    }
+}