Implement numbers functions

numbers.c

@@ -5,6 +5,24 @@
 #include "numbers.h"
 #include "bintree.h"
 
+// Vergleichsfunktion fuer qsort und den Binaerbaum
+static int compareUnsignedInt(const void *arg1, const void *arg2)
+{
+    unsigned int number1 = *(const unsigned int *)arg1;
+    unsigned int number2 = *(const unsigned int *)arg2;
+
+    if(number1 < number2)
+    {
+        return -1;
+    }
+
+    if(number1 > number2)
+    {
+        return 1;
+    }
+
+    return 0;
+}
 //TODO: getDuplicate und createNumbers implementieren
 /*  *   * Erzeugen eines Arrays mit der vom Nutzer eingegebenen Anzahl an Zufallszahlen.
   * Sicherstellen, dass beim Befüllen keine Duplikate entstehen.
@@ -16,11 +34,97 @@
 // creating random numbers.
 unsigned int *createNumbers(unsigned int len)
 {
+    // Ungueltige Groesse abfangen
+    if(len < 2)
+    {
+        return NULL;
+    }
 
+    // Speicher fuer das Zahlenarray reservieren
+    unsigned int *numbers = malloc(len * sizeof(unsigned int));
+
+    if(numbers == NULL)
+    {
+        return NULL;
+    }
+
+    TreeNode *root = NULL;
+    unsigned int filledNumbers = 0;
+
+    srand((unsigned int)time(NULL));
+
+    // Solange Zahlen erzeugen bis len - 1 Plaetze gefuellt sind
+    while(filledNumbers < len - 1)
+    {
+        // Zufallszahl zwischen 1 und 2 * len erzeugen
+        unsigned int randomNumber = (rand() % (2 * len)) + 1;
+
+        int isDuplicate = 0;
+
+        // Zahl in den Baum einfuegen
+        root = addToTree(root,
+                         &randomNumber,
+                         sizeof(unsigned int),
+                         compareUnsignedInt,
+                         &isDuplicate);
+
+        // Nur speichern wenn sie noch nicht existiert
+        if(isDuplicate == 0)
+        {
+            numbers[filledNumbers] = randomNumber;
+            filledNumbers++;
+        }
+    }
+
+    // Zufaellige vorhandene Zahl auswaehlen
+    unsigned int duplicateIndex = rand() % (len - 1);
+
+    // Diese Zahl absichtlich doppelt speichern
+    numbers[len - 1] = numbers[duplicateIndex];
+
+    // Speicher des Baumes freigeben
+    clearTree(root);
+
+    return numbers;
 }
 
 // Returns only the only number in numbers which is present twice. Returns zero on errors.
 unsigned int getDuplicate(const unsigned int numbers[], unsigned int len)
 {
+    // Fehlerfaelle pruefen
+    if(numbers == NULL || len < 2)
+    {
+        return 0;
+    }
 
+    // Kopie erzeugen da qsort das Array veraendert
+    unsigned int *copy = malloc(len * sizeof(unsigned int));
+
+    if(copy == NULL)
+    {
+        return 0;
+    }
+
+    // Originalarray kopieren
+    memcpy(copy, numbers, len * sizeof(unsigned int));
+
+    // Zahlen sortieren
+    qsort(copy, len, sizeof(unsigned int), compareUnsignedInt);
+
+    // Nach dem Sortieren stehen Duplikate nebeneinander
+    for(unsigned int i = 0; i < len - 1; i++)
+    {
+        if(copy[i] == copy[i + 1])
+        {
+            unsigned int duplicate = copy[i];
+
+            free(copy);
+
+            return duplicate;
+        }
+    }
+
+    free(copy);
+
+    return 0;
 }