initial implementation for numbers.c with some testing in test_numbers.c

numbers.c currently uses the qsort() function from stdlib

numbers.c

@@ -5,22 +5,82 @@
 #include "numbers.h"
 #include "bintree.h"
 
-//TODO: getDuplicate und createNumbers implementieren
+static int compareInt(const void *ptr1, const void *ptr2);
+
+// 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. */
+ * 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.
+
+/*
+the implemented tree can't efficiently check if it contains a specific number, but we don't actually need that anyways
+create numbers just counts and checks if the just inserted number sets the isDuplicate pointer
+*/
+// srand should have been called before this function
 unsigned int *createNumbers(unsigned int len)
 {
+  unsigned int *randomNumbers = malloc(len * sizeof(int));
 
+  // including upper limit
+  int upperLimit = len * 2;
+
+  int numberCnt = 0;
+
+  int isDuplicate = 0;
+  TreeNode *root = NULL;
+  // we only need len-1 numbers because 1 will be duplicated
+  while (numberCnt < len - 1)
+  {
+    // numbers up to and including upperLimit without 0
+    int randNum = rand() % upperLimit + 1;
+    // reset isDuplicate
+    isDuplicate = 0;
+    // don't forget to set the root here
+    root = addToTree(root, &randNum, sizeof(randNum), (CompareFctType)compareInt, &isDuplicate);
+    if (isDuplicate)
+    {
+      // number already exists
+      continue;
+    }
+    randomNumbers[numberCnt++] = randNum;
+  }
+
+  // select which number to duplicate
+  int dupNum = randomNumbers[rand() % numberCnt];
+  // ...and where to insert
+  int dupNumIdx = rand() % len;
+
+  // move the number currently at the dupNumIdx to the end
+  // and insert the dupNum at the index
+  // this also works if the last idx was selected for dupNum
+  randomNumbers[len - 1] = randomNumbers[dupNumIdx];
+  randomNumbers[dupNumIdx] = dupNum;
+
+  // clean up memory
+  clearTree(root);
+  return randomNumbers;
 }
 
 // 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)
 {
+  qsort((void *)numbers, len, sizeof(int), compareInt); // sort the array
+  for (int i = 0; i < len - 1; i++)
+  {
+    if (numbers[i] == numbers[i + 1])
+      return numbers[i];
+  }
+  return 0; // zero on errors
+}
 
+static int compareInt(const void *ptr1, const void *ptr2)
+{
+  int num1 = *(int *)ptr1;
+  int num2 = *(int *)ptr2;
+  return num1 - num2;
 }