Erweitern numbers.c

numbers.c

@@ -1,6 +1,6 @@
 #include <stdlib.h>
 #include <stdio.h>
-#include <time.h>
+#include <time.h> // für Zufallszahlen 
 #include <string.h>
 #include "numbers.h"
 #include "bintree.h"
@@ -10,17 +10,91 @@
   * Sicherstellen, dass beim Befüllen keine Duplikate entstehen.
   * Duplizieren eines zufälligen Eintrags im Array.
   * in `getDuplicate()`: Sortieren des Arrays und Erkennen der doppelten Zahl durch Vergleich benachbarter Elemente. */
+// Vergleichsfunktion für unsigned int
+
+static int compareUInt(const void *a, const void *b)
+{
+    unsigned int x = *(unsigned int *)a; // beide void Zeiger in unsigned int
+    unsigned int y = *(unsigned int *)b;
+
+    // Vergleich wie beim Binärbaum
+    if (x < y) return -1; // links
+    if (x > y) return 1; // rechts
+    return 0; // gleich
+}
 
 // Returns len random numbers between 1 and 2x len in random order which are all different, except for two entries.
 // Returns NULL on errors. Use your implementation of the binary search tree to check for possible duplicates while
 // creating random numbers.
 unsigned int *createNumbers(unsigned int len)
 {
+ if (len < 2) // min 2 Zahlen sind notwendig
+        return NULL;
 
+    // Erzeugen eines Arrays (unsigned int)
+    unsigned int *arr = malloc(sizeof(unsigned int) * len);
+    if (!arr)
+        return NULL; // kein Speicher -> Fehler
+
+    srand((unsigned int)time(NULL)); // Initialisieren Zufallszahl
+
+    TreeNode *root = NULL; 
+    int isDup; // zeigt ob Duplikat
+
+    unsigned int count = 0;
+
+    // Erzeugen der Zufallszahlen
+    while (count < len - 1)   // ERST len-1 verschiedene Zahlen (ein Platz übrig für Duplikat)
+    {
+        unsigned int value = (rand() % (2 * len)) + 1; // Bereich 1 bis 2len (wahrscheinlich wenig Duplikate)
+
+        root = addToTree(root, &value, sizeof(unsigned int), compareUInt, &isDup);
+        // Einfügen der Zahl in Binärbaum (isDup==0 neue Zahl ) (isDup==1 Zahl war schon)
+
+        if (!isDup)   // nur hinzufügen, wenn kein Duplikat
+        {
+            arr[count] = value; //Neuer Wert gespeichert (Duplikate ignoriert)
+            count++;
+        }
+    }
+
+    // EIN zufälliges Duplikat hinzufügen
+    unsigned int idx = rand() % (len - 1);
+    arr[len - 1] = arr[idx];
+
+    clearTree(root); // Freigeben des Baumes
+    return arr; // Zurückgeben des Array
 }
 
 // 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)
 {
+if (!numbers || len < 2) // Prüfen ob Array leer oder zu kurz
+        return 0;
 
+    // Kopie erstellen zum Sortieren
+    unsigned int *tmp = malloc(sizeof(unsigned int) * len);
+    if (!tmp)
+        return 0;
+
+    for (unsigned int i = 0; i < len; i++) // Werte kopieren
+        tmp[i] = numbers[i];
+
+    // Sortieren (qsort - Vergleichsfunktion)
+    qsort(tmp, len, sizeof(unsigned int), compareUInt);
+
+    // benachbarte Duplikate finden
+    unsigned int duplicate = 0;
+
+    for (unsigned int i = 0; i < len - 1; i++) // Durchlaufen des Arrays
+    {
+        if (tmp[i] == tmp[i + 1]) // wenn 2 aufeinanderfolgende Werte gleich -> Duplikat
+        {
+            duplicate = tmp[i];
+            break;
+        }
+    }
+
+    free(tmp); // Kopie freigeben
+    return duplicate; //gefundene Zahl zurückgeben
 }