addtotree funktion in bintree

bintree.c

@@ -12,7 +12,63 @@
 // if isDuplicate is NULL, otherwise ignores duplicates and sets isDuplicate to 1 (or to 0 if a new entry is added).
 TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFctType compareFct, int *isDuplicate)
 {
+    // Teil 1: Trivialfall (Einfügen des neuen Knotens)
+    if(root == NULL)
+    {
+        // Speicher für den Knoten selbst reservieren
+        TreeNode *newNode = (TreeNode*)malloc(sizeof(TreeNode));
+        if (newNode == NULL)
+        {
+            return NULL; // Fehler beim Allokieren
+        }
 
+        // Speicher für die Datenkopie reservieren
+        newNode->data = malloc(dataSize);
+        if (newNode->data == Null)
+        {
+            free(newNode);
+            return NULL; // Fehler beim Allokieren
+        }
+
+        // Daten kopieren
+        memcpy(newNode->data, data, dataSize);
+
+        // Initialisieren
+        newNode->left = NULL;
+        newNode->right = NULL;
+
+        // Flag setzen und Knoten zurückgeben
+        if (isDuplicate != NULL) *isDuplicate = 0;
+        return newNode;
+    }
+
+    // Teil 2: Rekursiver Fall (Vergleich)
+    int comparison = compareFct(data, root->data);
+
+    if (comparison == 0)
+    {
+        // Duplikat gefunden
+        if (isDuplicate != NULL) *isDuplicate = 1;
+        // Duplikate werden akzeptiert, wenn isDuplicate == NULL (siehe bintree.h)
+        // Da wir aber in createNumbers Duplikate vermeiden wollen, geben wir hier einfach root zurück.
+
+        // Wenn Duplikate erlaubt sind, könntest du hier einen zweiten Knoten einfügen,
+        // aber standardmäßig überspringen wir Duplikate, wenn isDuplicate gesetzt ist.
+        return root;
+    }
+    else if (comparison < 0)
+    {
+        // Wert ist kleiner -> gehe nach links
+        root->left = addToTree(root->left, data, dataSize, compareFct, isDuplicate);
+    }
+    else // comparison > 0
+    {
+        // Wert ist größer -> gehe nach rechts
+        root->right = addToTree(root->right, data, dataSize, compareFct, isDuplicate);
+    }
+
+    // 3. Wenn die Rekursion zurückkehrt, wird der aktuelle root-Pointer zurückgegeben.
+    return root;
 }
 
 // Iterates over the tree given by root. Follows the usage of strtok. If tree is NULL, the next entry of the last tree given is returned in ordering direction.

highscores.txt

@@ -1,10 +1,10 @@
 player_name;19803
+player;19540
 player_name;19102
 player_test2;9976
 player_test;9967
 player;9960
 player_name;9960
 player_name;9953
-player_name;6966
+miguel;9935
-player1;3999
+player;9920
-player_name;2995

numbers.c

@@ -5,12 +5,27 @@
 #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. */
 
+// Implementierung für unsigned int
+int compareNumbers(const void *arg1, const void *arg2)
+{
+  // Die void-Pointer auf unsigned int Pointer casten
+  const unsigned int *num1 = (const unsigned int *)arg1;
+  const unsigned int *num2 = (const unsigned int *)arg2;
+
+  // Werte dereferenzieren und vergleichen
+  if (*num1 < *num2) return -1;
+  if (*num1 > *num2) return 1;
+  return 0;
+}
+
 // 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.