bintree fehler im struct behoben und nubers rest impementiert doble spiel funktioniert jetzt

bintree.c

@@ -12,96 +12,153 @@
 // if isDuplicate is NULL, otherwise ignores duplicates and sets isDuplicate to 1 (or to 0 if a new entry is added).
 
 // Hilfsfunktion: neuen Knoten erstellen und Daten kopieren
-TreeNode* newNode(const void* data, size_t dataSize) {
+static TreeNode* createNode(const void* data, size_t dataSize)
-    TreeNode* node = malloc(sizeof(TreeNode));
+{
-    if (!node) return NULL;
+    TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));
+    if (node == NULL)
+    {
+        return NULL;
+    }
     
     node->data = malloc(dataSize);
-    if (!node->data) {
+    if (node->data == NULL)
+    {
         free(node);
         return NULL;
     }
-    memcpy(node->data, data, dataSize); // Daten kopieren
+    
-    node->left = node->right = NULL;
+    memcpy(node->data, data, dataSize);
+    // dataSize wird NICHT im struct gespeichert, da es nicht im Header ist
+    node->left = NULL;
+    node->right = NULL;
+    
     return node;
 }
+
+// Fügt eine Kopie der Daten in den Baum ein (rekursiv)
 TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, 
                     CompareFctType compareFct, int *isDuplicate)
 {
-    if (root == NULL) {
+    // Basisfall: leerer Baum oder Blattknoten erreicht
-        *isDuplicate = 0; // kein Duplikat, neuer Knoten
+    if (root == NULL)
-        return newNode(data, dataSize); // neuer Knoten wird Wurzel
+    {
+        // isDuplicate auf 0 setzen, wenn nicht NULL
+        if (isDuplicate != NULL)
+        {
+            *isDuplicate = 0;
+        }
+        
+        return createNode(data, dataSize);
     }
     
+    // Daten vergleichen
     int result = compareFct(data, root->data);
     
-    if (result < 0) {
+    if (result < 0)
+    {
+        // Daten sind kleiner -> in linken Teilbaum einfügen
         root->left = addToTree(root->left, data, dataSize, compareFct, isDuplicate);
-    } else if (result > 0) {
+    }
+    else if (result > 0)
+    {
+        // Daten sind größer -> in rechten Teilbaum einfügen
         root->right = addToTree(root->right, data, dataSize, compareFct, isDuplicate);
-    } else {
+    }
-        // result == 0 → Duplikat
+    else
-        *isDuplicate = 1;
+    {
+        // result == 0 → Duplikat gefunden
+        if (isDuplicate != NULL)
+        {
+            *isDuplicate = 1; // Duplikat, nicht einfügen
+        }
+        else
+        {
+            // Duplikate sind erlaubt -> in rechten Teilbaum einfügen
+            root->right = addToTree(root->right, data, dataSize, compareFct, isDuplicate);
+        }
     }
     
     return root;
 }
 
+// Statischer Stack für die Iterator-Funktion (wie bei strtok)
+static StackNode *iteratorStack = NULL;
 
-// 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.
+// Iteriert über den Baum (In-Order-Traversierung mit Stack)
-// Use your implementation of a stack to organize the iterator. Push the root node and all left nodes first. On returning the next element,
+// Funktioniert wie strtok: beim ersten Aufruf root übergeben, dann NULL
-// push the top node and push all its left nodes.
+void *nextTreeData(TreeNode *root)
-// Initialisiert den Stack mit der Wurzel und allen linken Nachfolgern
+{
-StackNode* initTraversal(TreeNode* root) {
+    // Wenn root != NULL: neuer Iterator-Durchlauf starten
-    StackNode* stack = NULL;
+    if (root != NULL)
-    TreeNode* current = root;
+    {
+        // Alten Stack löschen, falls vorhanden
+        clearStack(iteratorStack);
+        iteratorStack = NULL;
         
-    while (current != NULL) {
+        // Alle linken Knoten auf den Stack pushen (bis zum kleinsten Element)
-        stack = push(stack, current);
+        TreeNode *current = root;
-        current = current->left;
+        while (current != NULL)
-    }
+        {
-    return stack;
+            iteratorStack = push(iteratorStack, current);
-}
+            current = current->left;
-void* nextTreeData(StackNode** stack) {
+        }
-    if (*stack == NULL) {
-        return NULL; // Traversierung beendet
-
-    // Obersten Knoten holen
-    TreeNode* node = (TreeNode*)top(*stack);
-    *stack = pop(*stack);
-
-    // Falls rechter Teilbaum existiert, diesen und alle linken Nachfolger auf den Stack legen
-    TreeNode* current = node->right;
-    while (current != NULL) {
-        *stack = push(*stack, current);
-        current = current->left;
     }
     
+    // Wenn Stack leer ist, sind wir fertig
+    if (iteratorStack == NULL)
+    {
+        return NULL;
+    }
+    
+    // Oberstes Element vom Stack holen
+    TreeNode *node = (TreeNode *)top(iteratorStack);
+    iteratorStack = pop(iteratorStack);
+    
+    // Wenn der Knoten einen rechten Teilbaum hat,
+    // alle linken Knoten des rechten Teilbaums auf den Stack pushen
+    if (node->right != NULL)
+    {
+        TreeNode *current = node->right;
+        while (current != NULL)
+        {
+            iteratorStack = push(iteratorStack, current);
+            current = current->left;
+        }
+    }
+    
+    // Daten des aktuellen Knotens zurückgeben
     return node->data;
-}}
+}
 
-// Releases all memory resources (including data copies).
+// Gibt den gesamten Baum frei (rekursiv, Post-Order)
 void clearTree(TreeNode *root)
 {
- if (root == NULL) return; // Basisfall: leerer Teilbaum
+    if (root == NULL)
+    {
+        return; // Basisfall: leerer Teilbaum
+    }
     
-    // Rekursiv zuerst die Kinder freigeben
+    // Erst linken Teilbaum löschen
     clearTree(root->left);
+    
+    // Dann rechten Teilbaum löschen
     clearTree(root->right);
     
-    // Daten freigeben
+    // Dann Daten und Knoten selbst löschen
     free(root->data);
 
     // Knoten selbst freigeben
     free(root);
 }
 
-// Returns the number of entries in the tree given by root.
+// Zählt die Knoten im Baum (rekursiv)
 unsigned int treeSize(const TreeNode *root)
 {
- if (root == NULL) {
+    if (root == NULL)
+    {
         return 0; // Basisfall: leerer Teilbaum
     }
-    // Rekursiv: Größe = 1 (aktueller Knoten) + Größe des linken Teilbaums + Größe des rechten Teilbaums
+    
+    // Rekursiv: Größe = 1 (aktueller Knoten) + linker Teilbaum + rechter Teilbaum
     return 1 + treeSize(root->left) + treeSize(root->right);
 }

bintree.h

@@ -7,9 +7,10 @@ typedef int (*CompareFctType)(const void *arg1, const void *arg2);
 
 typedef struct node
 {
-    void *data;
+    void *data;              // Zeiger auf die Daten
-    struct node *left;
+    size_t dataSize;         // ← NEU: Größe der Daten
-    struct node *right;
+    struct node *left;       // Linker Teilbaum
+    struct node *right;      // Rechter Teilbaum
 } TreeNode;
 
 // Adds a copy of data's pointer destination to the tree using compareFct for ordering. Accepts duplicates 

highscores.txt

@@ -1 +1,4 @@
+manu;9959
+manu;9949
+player2;9925
 player1;3999

numbers.c

@@ -5,6 +5,18 @@
 #include "numbers.h"
 #include "bintree.h"
 
+
+// Vergleichsfunktion für unsigned int (für Binärbaum und qsort)
+static int compareUnsignedInt(const void *a, const void *b)
+{
+    unsigned int valA = *(unsigned int *)a;
+    unsigned int valB = *(unsigned int *)b;
+    
+    if (valA < valB) return -1;
+    if (valA > valB) return 1;
+    return 0;
+}
+
 // TODO: getDuplicate und createNumbers implementieren
 /*  *   * Erzeugen eines Arrays mit der vom Nutzer eingegebenen Anzahl an Zufallszahlen.
  * Sicherstellen, dass beim Befüllen keine Duplikate entstehen.
@@ -14,44 +26,110 @@
 // 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.
+// Erzeugt ein Array mit len eindeutigen Zufallszahlen zwischen 1 und 2*len
+// Verwendet Binärbaum zur Duplikatsvermeidung
+// Gibt dann eine zufällige Zahl doppelt zurück
 unsigned int *createNumbers(unsigned int len)
 {
+    // Eingabevalidierung
+    if (len == 0)
+    {
+        return NULL;
+    }
     
-  int n;
+    // Array allokieren
-  printf("Wie viele Zufallszahlen sollen erstellt werden? ");
+    unsigned int *numbers = (unsigned int *)malloc(len * sizeof(unsigned int));
-  scanf("%d", &n);
+    if (numbers == NULL)
+    {
+        return NULL;
+    }
     
-  int array[n];
+    // Binärbaum zur Duplikatsprüfung erstellen
-  srand(time(NULL)); // Zufallsgenerator initialisieren
+    TreeNode *tree = NULL;
     
-  for (int i = 0; i < n; i++)
+    // Zufallsgenerator initialisieren
-  {
+    static int seedInitialized = 0;
-    int zahl;
+    if (!seedInitialized)
-    char vorhanden;
+    {
+        srand(time(NULL));
+        seedInitialized = 1;
+    }
+    
+    // Zufallszahlen zwischen 1 und 2*len generieren (keine Duplikate)
+    unsigned int inserted = 0;
+    while (inserted < len)
+    {
+        // Zufallszahl zwischen 1 und 2*len generieren
+        unsigned int randomNum = (rand() % (2 * len)) + 1;
+        
+        // In Baum einfügen und prüfen, ob Duplikat
+        int isDuplicate = 0;
+        tree = addToTree(tree, &randomNum, sizeof(unsigned int), 
+                        compareUnsignedInt, &isDuplicate);
+        
+        // Wenn kein Duplikat, ins Array einfügen
+        if (!isDuplicate)
+        {
+            numbers[inserted] = randomNum;
+            inserted++;
+        }
+    }
+    
+    // Baum aufräumen
+    clearTree(tree);
+    
+    // Einen zufälligen Eintrag duplizieren
+    // Wähle zwei verschiedene Indizes
+    unsigned int sourceIndex = rand() % len;
+    unsigned int targetIndex;
     
     do
     {
-      vorhanden = 0;
+        targetIndex = rand() % len;
-      zahl = rand() % n; // Zufallszahl zwischen 1 und 100
+    } while (targetIndex == sourceIndex);
     
-      // Prüfen, ob Zahl schon im Array existiert
+    // Kopiere Wert von source nach target (erzeugt Duplikat)
-      for (int j = 0; j < i; j++)
+    numbers[targetIndex] = numbers[sourceIndex];
-      {
-        if (array[j] == zahl)
-        {
-          vorhanden = 1;
-          break;
-        }
-      }
-    } while (vorhanden); // solange wiederholen, bis Zahl einzigartig ist
     
-    array[i] = zahl;
+    return numbers;
-  }
-
-  return 0;
 }
 
-// Returns only the only number in numbers which is present twice. Returns zero on errors.
+// Findet das Duplikat durch Sortieren und Vergleich benachbarter Elemente
+// Gibt 0 bei Fehlern zurück
 unsigned int getDuplicate(const unsigned int numbers[], unsigned int len)
 {
+    // Eingabevalidierung
+    if (numbers == NULL || len < 2)
+    {
+        return 0; // Fehler
+    }
+    
+    // Kopie des Arrays erstellen (um Original nicht zu verändern)
+    unsigned int *sortedNumbers = (unsigned int *)malloc(len * sizeof(unsigned int));
+    if (sortedNumbers == NULL)
+    {
+        return 0; // Speicherfehler
+    }
+    
+    // Array kopieren
+    memcpy(sortedNumbers, numbers, len * sizeof(unsigned int));
+    
+    // Array mit qsort sortieren
+    qsort(sortedNumbers, len, sizeof(unsigned int), compareUnsignedInt);
+    
+    // Benachbarte Elemente vergleichen, um Duplikat zu finden
+    unsigned int duplicate = 0;
+    for (unsigned int i = 0; i < len - 1; i++)
+    {
+        if (sortedNumbers[i] == sortedNumbers[i + 1])
+        {
+            duplicate = sortedNumbers[i];
+            break;
+        }
+    }
+    
+    // Aufräumen
+    free(sortedNumbers);
+    
+    return duplicate;
 }