From a816abfe04ed59d75bd7485990c8463c4fe83a7a Mon Sep 17 00:00:00 2001
From: Fabrice <fabrice.reintsch@gmail.com>
Date: Fri, 5 Dec 2025 09:28:40 +0100
Subject: [PATCH] numbers.c finished

---
 numbers.c | 60 ++++++++++++++++++++++---------------------------------
 1 file changed, 24 insertions(+), 36 deletions(-)

diff --git a/numbers.c b/numbers.c
index 3671c88..4f3367c 100644
--- a/numbers.c
+++ b/numbers.c
@@ -5,46 +5,33 @@
 #include "numbers.h"
 #include "bintree.h"
 
-//TODO: getDuplicate und createNumbers implementieren
-/*  *   * Erzeugen eines Arrays mit der vom Nutzer eingegebenen Anzahl an Zufallszahlen.
-  * 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. */
-
-// 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.
+//Speicher für Array erstellen, zufällige Zahlen von 1-2xlen erzeugen, mittels Binärbaum checken, ob Zahlen einzigartig sind
+//Eine Zahl duplizieren, an zufälliger Stelle einfügen und die Zahl an der Stelle ans Ende schieben
 unsigned int *createNumbers(unsigned int len)
 {
-  srand(time(NULL));
-
-  unsigned int *numbers = malloc (sizeof(unsigned int) * (len+1));
-  unsigned int newNumber;
+  unsigned int *numbers = malloc (sizeof(unsigned int) * len);
+  unsigned int upperLimit = len * 2;
+  int isDuplicate = 0;
+  TreeNode *binTree = NULL;
 
   for (unsigned int i = 0; i < len; i++) {
-    int unique = 0;
+    do
+    { 
+      numbers[i] = rand () % upperLimit + 1;
+      binTree = addToTree(binTree, &numbers[i], sizeof(unsigned int), compare, &isDuplicate);
+    } while (isDuplicate);
+  } 
 
-    while (!unique) {
-    unique = 1;
-    newNumber = rand () % (2*len) + 1;
-
-      for (unsigned int j = 0; j < i; j++) {
-        if (numbers[j] == newNumber) {
-          unique = 0;
-          break;
-        }
-      }
-    }
-    numbers[i] = newNumber;
-  }
-
-  unsigned int duplicate = numbers[rand () % len]; 
-  numbers[len] = duplicate;
+  unsigned int duplicate = numbers[rand () % len];
+  int indexDuplicate = rand () % len;
+  numbers[len] = numbers[indexDuplicate];
+  numbers[indexDuplicate] = duplicate;
 
   return numbers;
 }
 
-int compare (const void *a, const void *b) {
+//Vergleichsfunktion von qsort
+const int compare (const void *a, const void *b) {
   unsigned int *x = a;
   unsigned int *y = b;
   if (*x < *y) {
@@ -57,16 +44,17 @@ int compare (const void *a, const void *b) {
     return 0;
   }
 }
-// Returns only the only number in numbers which is present twice. Returns zero on errors.
-unsigned int getDuplicate(unsigned int numbers[], unsigned int lenPlusOne)
+
+//Sortiert Zahlen mit qsort, vergleicht dann benachbarte Elemente und gibt bei Erfolg die doppelte Zahl zurück
+unsigned int getDuplicate(unsigned int numbers[], unsigned int len)
 {
-  if (lenPlusOne < 2) {
+  if (len < 2) {
     return 0;
   }
 
-qsort(numbers,lenPlusOne, sizeof(unsigned int), compare);
+qsort(numbers, len, sizeof(unsigned int), compare);
 
-for (int i = 0; i < lenPlusOne-1; i++) {
+for (int i = 0; i < len-1; i++) {
   if (numbers[i] == numbers [i+1]) {
     return numbers[i];
   }