bugfix

highscores.txt

@@ -1,4 +1,5 @@
 player_name;6979
 player_name;4982
 player1;3999
+player_name;3992
 player_name;2996

numbers.c

@@ -5,105 +5,120 @@
 #include "numbers.h"
 #include "bintree.h"
 
-//TODO: getDuplicate und createNumbers implementieren
+// TODO: getDuplicate und createNumbers implementieren
 /*  *   * Erzeugen eines Arrays mit der vom Nutzer eingegebenen Anzahl an Zufallszahlen.
-  * Sicherstellen, dass beim Befüllen keine Duplikate entstehen.
+ * Sicherstellen, dass beim Befüllen keine Duplikate entstehen.
-  * Duplizieren eines zufälligen Eintrags im Array.
+ * Duplizieren eines zufälligen Eintrags im Array.
-  * in `getDuplicate()`: Sortieren des Arrays und Erkennen der doppelten Zahl durch Vergleich benachbarter Elemente. */
+ * 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.
 
-//ohne Binärbaum
+/*
+// ohne Binärbaum
 unsigned int *createNumbers(unsigned int len)
 {
   if (len <= 2)
     return NULL;
-  
+
   // Zufallszahlen erzeugen
   srand(time(NULL));
   unsigned int *numbers = malloc(len * sizeof(unsigned int));
-  //prüfen, ob Speicher richtig reserviert wurde
+  // prüfen, ob Speicher richtig reserviert wurde
-  if(numbers == NULL){
+  if (numbers == NULL)
+  {
     printf("Es konnte nicht genügend Speicher reserviert werden");
     free(numbers);
     return NULL;
   }
-  //einsetzen der Zahlen ins array
+  // einsetzen der Zahlen ins array
-  for (size_t i = 0; i < len; i++){
+  for (size_t i = 0; i < len; i++)
-    numbers[i] = rand()%((2*len)+1);
+  {
-    //stellt sicher, dass keine Duplikate vorhanden sind
+    numbers[i] = rand() % ((2 * len) + 1);
-    for(size_t j = 0; j < i; j++){
+    // stellt sicher, dass keine Duplikate vorhanden sind
-      if(numbers[i] == numbers[j]){
+    for (size_t j = 0; j < i; j++)
+    {
+      if (numbers[i] == numbers[j])
+      {
         i--;
         break;
       }
     }
-
   }
-  //numbers[rand()% (len+1)] = rand()% ((2* len) + 1);
+  // numbers[rand()% (len+1)] = rand()% ((2* len) + 1);
-  size_t dupIndex = rand() % len;         // Index, der dupliziert wird
+  size_t dupIndex = rand() % len;    // Index, der dupliziert wird
-  size_t targetIndex = rand() % len;      // Ziel-Index, wo das Duplikat hin soll
+  size_t targetIndex = rand() % len; // Ziel-Index, wo das Duplikat hin soll
-  if (dupIndex != targetIndex) {
+  if (dupIndex != targetIndex)
+  {
     numbers[targetIndex] = numbers[dupIndex]; // echtes Duplikat
-}
+  }
   return numbers;
   free(numbers);
 }
 
-int compare(const void *a, const void *b) {
+int compare(const void *a, const void *b)
-    return (*(int*)a - *(int*)b);
+{
+  return (*(int *)a - *(int *)b);
 }
+*/
+// mit Binärbaum
 
-//mit Binärbaum
-/*
 unsigned int *createNumbers(unsigned int len)
 {
   if (len <= 2)
     return NULL;
-  
+
   // Zufallszahlen erzeugen
   srand(time(NULL));
   unsigned int *numbers = malloc(len * sizeof(unsigned int));
-  //prüfen, ob Speicher richtig reserviert wurde
+  // prüfen, ob Speicher richtig reserviert wurde
-  if(numbers == NULL){
+  if (numbers == NULL)
+  {
     printf("Es konnte nicht genügend Speicher reserviert werden");
     free(numbers);
     return NULL;
   }
 
   TreeNode *root = NULL;
-  for(size_t i= 0; i < len; i++){
+  for (size_t i = 0; i < len; i++)
-    unsigned int isDup = 0; 
+  {
-    numbers[i] = (rand()%(2*len))+1;
+    unsigned int isDup = 0;
+    numbers[i] = (rand() % (2 * len)) + 1;
     root = addToTree(root, &numbers, sizeof(numbers), compare, &isDup);
-    if(isDup != 1){
+    if (isDup != 1)
+    {
       i--;
     }
   }
 
-  numbers[rand()% len] = (rand()% (2* len) + 1);
+  // numbers[rand()% len] = (rand()% (2* len) + 1);
+  size_t dupIndex = rand() % len;    // Index, der dupliziert wird
+  size_t targetIndex = rand() % len; // Ziel-Index, wo das Duplikat hin soll
+  if (dupIndex != targetIndex)
+  {
+    numbers[targetIndex] = numbers[dupIndex]; // echtes Duplikat
+  }
   return numbers;
   clearTree(root);
   free(numbers);
 }
-*/
-
 
 // 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)
 {
   unsigned int dobble;
-  // neues Array zum reinkopieren initialisieren 
+  // neues Array zum reinkopieren initialisieren
   unsigned int *nums = malloc(len * sizeof(unsigned int));
-  for(int l = 0; l < len; l++)
+  for (int l = 0; l < len; l++)
-    nums[l] = numbers[l]; 
+    nums[l] = numbers[l];
 
-  //array sortieren
+  // array sortieren
   qsort(nums, len, sizeof(unsigned int), compare);
-  for(int k = 0; k < len; k++){
+  for (int k = 0; k < len; k++)
-    if(nums[k] == nums[k+1]){
+  {
+    if (nums[k] == nums[k + 1])
+    {
       dobble = nums[k];
       break;
     }