Finish numbers.c and add tests

numbers.c

@@ -17,83 +17,113 @@
 // Vergleichsfunktion für qsort
 static int compareUnsignedInt(const void *a, const void *b)
 {
-  const unsigned int *x = (const unsigned int *)a;
-  const unsigned int *y = (const unsigned int *)b;
+const unsigned int *x = (const unsigned int *)a;
+   const unsigned int *y = (const unsigned int *)b;
 
-  if (*x < *y) return -1;
-  if (*x > *y) return 1;
-  return 0;
+   if (*x < *y) return -1;
+   if (*x > *y) return 1;
+   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) {
-    return NULL;
-  }
+   // 1. Array reservieren
+   unsigned int *numbers = malloc(len * sizeof(unsigned int));
+   if (numbers == NULL) return NULL;
 
-  unsigned int *numbers = malloc(len * sizeof(unsigned int));
-  if (numbers == NULL) {
-    return NULL;
-  }
+   // Hilfsvariablen für den Baum
+   TreeNode *root = NULL;
+   int isDuplicate = 0;
+   unsigned int count = 0;
 
-  for (unsigned int i = 0; i < len; ++i) {
+   // 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;
 
-    while (1) {
-      unsigned int value = (rand() % (2 * len)) + 1;
+       // Versuchen, in den Baum einzufügen
+       // Wir übergeben &isDuplicate, damit der Baum Duplikate ABLEHNT.
+       root = addToTree(root, &value, sizeof(unsigned int), compareUnsignedInt, &isDuplicate);
 
-      int exists = 0;
-      for (unsigned int j = 0; j < i; ++j) {
-        if (numbers[j] == value) {
-          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) {
-        numbers[i] = value;
-        break;
-      }
-    }
-  }
+   // 3. PHASE 2: Das garantierte Duplikat erzeugen
+   // Wir wählen zufällig eine der bereits existierenden Zahlen aus
+   unsigned int randomIndex = rand() % (len - 1);
+   unsigned int duplicateValue = numbers[randomIndex];
 
-  unsigned int idx1 = rand() % len;
-  unsigned int idx2 = rand() % len;
+   // Wir schreiben das Duplikat an die allerletzte Stelle
+   numbers[len - 1] = duplicateValue;
 
-  while (idx2 == idx1) {
-    idx2 = rand() % len;
-  }
+   // Optional: Duplikat auch in den Baum einfügen (Modus: Akzeptieren / isDuplicate = NULL)
+   // 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);
 
-  return numbers;
+   // 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) {
-    return 0;
-  }
+ if (numbers == NULL || len < 2) {
+   return 0;
+ }
 
-  unsigned int *copy = malloc(len * sizeof(unsigned int));
-  if (copy == NULL) {
-    return 0;
-  }
+ unsigned int *copy = malloc(len * sizeof(unsigned int));
+ if (copy == NULL) {
+   return 0;
+ }
 
-  memcpy(copy, numbers, len * sizeof(unsigned int));
+ memcpy(copy, numbers, len * sizeof(unsigned int));
 
+ qsort(copy, len, sizeof(unsigned int), compareUnsignedInt);
 
-  qsort(copy, len, sizeof(unsigned int), compareUnsignedInt);
+ unsigned int duplicate = 0;
 
-  unsigned int duplicate = 0;
+ for (unsigned int i = 0; i + 1 < len; ++i) {
+   if (copy[i] == copy[i + 1]) {
+     duplicate = copy[i];
+     break;
+   }
+ }
 
-  for (unsigned int i = 0; i + 1 < len; ++i) {
-    if (copy[i] == copy[i + 1]) {
-      duplicate = copy[i];
-      break;
-    }
-  }
-
-  free(copy);
-  return duplicate;
+ free(copy);
+ return duplicate;
 }