Finish numbers.c and add tests

numbers.c

@@ -25,50 +25,81 @@ static int compareUnsignedInt(const void *a, const void *b)
    return 0;
 }
 
+// Fisher-Yates Shuffle Algorithmus zum Mischen des Arrays
+static void shuffleArray(unsigned int *array, unsigned int n)
+{
+   if (n > 1)
+   {
+       for (unsigned int i = n - 1; i > 0; i--)
+       {
+           unsigned int j = rand() % (i + 1);
+           unsigned int temp = array[i];
+           array[i] = array[j];
+           array[j] = temp;
+       }
+   }
+}
+
 unsigned int *createNumbers(unsigned int len)
 {
+   if (len < 2) return NULL;
 
-  if (len < 2) {
+   // 1. Array reservieren
-    return NULL;
-  }
-
    unsigned int *numbers = malloc(len * sizeof(unsigned int));
-  if (numbers == NULL) {
+   if (numbers == NULL) return NULL;
-    return NULL;
-  }
 
-  for (unsigned int i = 0; i < len; ++i) {
+   // Hilfsvariablen für den Baum
+   TreeNode *root = NULL;
+   int isDuplicate = 0;
+   unsigned int count = 0;
 
-    while (1) {
+   // 2. PHASE 1: Erzeuge (len - 1) EINZIGARTIGE Zahlen mit Hilfe des Baums
+   // Wir nutzen den Baum als "Türsteher"
+   while (count < len - 1)
+   {
+       // Zufallszahl generieren (1 bis 2*len)
        unsigned int value = (rand() % (2 * len)) + 1;
 
-      int exists = 0;
+       // Versuchen, in den Baum einzufügen
-      for (unsigned int j = 0; j < i; ++j) {
+       // Wir übergeben &isDuplicate, damit der Baum Duplikate ABLEHNT.
-        if (numbers[j] == value) {
+       root = addToTree(root, &value, sizeof(unsigned int), compareUnsignedInt, &isDuplicate);
-          exists = 1;
+
-          break;
+       // Prüfen: War es ein Duplikat?
+       if (isDuplicate == 0)
+       {
+           // Nein, es war neu! -> Ins Array schreiben
+           numbers[count] = value;
+           count++;
        }
+       // Falls isDuplicate == 1, machen wir einfach weiter (while-Schleife läuft weiter)
    }
 
-      if (!exists) {
+   // 3. PHASE 2: Das garantierte Duplikat erzeugen
-        numbers[i] = value;
+   // Wir wählen zufällig eine der bereits existierenden Zahlen aus
-        break;
+   unsigned int randomIndex = rand() % (len - 1);
-      }
+   unsigned int duplicateValue = numbers[randomIndex];
-    }
-  }
 
-  unsigned int idx1 = rand() % len;
+   // Wir schreiben das Duplikat an die allerletzte Stelle
-  unsigned int idx2 = rand() % len;
+   numbers[len - 1] = duplicateValue;
 
-  while (idx2 == idx1) {
+   // Optional: Duplikat auch in den Baum einfügen (Modus: Akzeptieren / isDuplicate = NULL)
-    idx2 = rand() % len;
+   // Damit der Baum konsistent zum Array ist (falls man ihn später noch braucht).
-  }
+   root = addToTree(root, &duplicateValue, sizeof(unsigned int), compareUnsignedInt, NULL);
 
-  numbers[idx2] = numbers[idx1];
+   // 4. Mischen
+   // Da das Duplikat jetzt immer ganz am Ende steht, müssen wir mischen.
+   shuffleArray(numbers, len);
+
+   // 5. Aufräumen
+   // Der Baum war nur ein Hilfsmittel zur Überprüfung. Er wird jetzt gelöscht.
+   // WICHTIG: Damit verhindern wir Memory Leaks [cite: 12]
+   clearTree(root);
 
    return numbers;
 }
 
+// ... Hierunter bleibt die getDuplicate Funktion deines Kollegen unverändert ...
+// Sie ist korrekt implementiert laut Aufgabenstellung (mit qsort)[cite: 11, 43].
 unsigned int getDuplicate(const unsigned int numbers[], unsigned int len)
 {
  if (numbers == NULL || len < 2) {
@@ -82,7 +113,6 @@ unsigned int getDuplicate(const unsigned int numbers[], unsigned int len)
 
  memcpy(copy, numbers, len * sizeof(unsigned int));
 
-
  qsort(copy, len, sizeof(unsigned int), compareUnsignedInt);
 
  unsigned int duplicate = 0;