Merge branch 'main' of https://git.efi.th-nuernberg.de/gitea/hoockth99140/Doble-Spiel

bintree.c

@@ -1,20 +1,24 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
+
 #include "stack.h"
 #include "bintree.h"
 
 static StackNode *push_left(TreeNode *node, StackNode *stack);
 
-int compareFct(const void *a, const void *b)
+/* Vergleichsfunktion */
+int compareFct(const void *argument1, const void *argument2)
 {
-    int x = *((int *)a);
+    int x = *((int *)argument1);
-    int y = *((int *)b);
+    int y = *((int *)argument2);
+
     if (x < y) return -1;
     if (x > y) return 1;
     return 0;
 }
 
+/* Erzeugt einen neuen Baumknoten mit Datenkopie */
 static TreeNode *create_node(const void *data, size_t data_size)
 {
     TreeNode *node = malloc(sizeof(TreeNode));
@@ -23,6 +27,7 @@ static TreeNode *create_node(const void *data, size_t data_size)
         perror("Speicher wurde NICHT reserviert!");
         return NULL;
     }
+
     node->data = malloc(data_size);
     if (!node->data)
     {
@@ -30,48 +35,67 @@ static TreeNode *create_node(const void *data, size_t data_size)
         free(node);
         return NULL;
     }
+
     memcpy(node->data, data, data_size);
     node->left = NULL;
     node->right = NULL;
+
     return node;
 }
 
+/* Fügt Daten in den Binärbaum ein */
 TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize,
                     CompareFctType compareFct, int *isDuplicate)
 {
     if (root == NULL)
     {
-        if (isDuplicate) *isDuplicate = 0;
+        if (isDuplicate)
+            *isDuplicate = 0;
         return create_node(data, dataSize);
     }
+
     int cmp = compareFct(data, root->data);
+
     if (cmp < 0)
+    {
         root->left = addToTree(root->left, data, dataSize, compareFct, isDuplicate);
+    }
     else if (cmp > 0)
+    {
         root->right = addToTree(root->right, data, dataSize, compareFct, isDuplicate);
-    else if (isDuplicate)
+    }
-        *isDuplicate = 1;
+    else
+    {
+        if (isDuplicate)
+            *isDuplicate = 1;
+    }
+
     return root;
 }
 
-// nextTreeData benutzt jetzt einen extern verwalteten Stack
+/* Inorder-Iterator über den Baum */
-void *nextTreeData(TreeNode *root, StackNode **stack)
+void *nextTreeData(TreeNode *root)
 {
-    if (root != NULL)
+    static StackNode *stack = NULL;
-        *stack = push_left(root, *stack);
 
-    if (*stack == NULL)
+    /* Neuer Start → linken Pfad auf Stack legen */
+    if (root != NULL)
+        stack = push_left(root, stack);
+
+    if (stack == NULL)
         return NULL;
 
-    TreeNode *node = (TreeNode *)top(*stack);
+    /* TOP lesen, dann POP */
-    *stack = pop(*stack);
+    TreeNode *node = (TreeNode *)top(stack);
+    stack = pop(stack);
 
     if (node->right != NULL)
-        *stack = push_left(node->right, *stack);
+        stack = push_left(node->right, stack);
 
     return node->data;
 }
 
+/* Hilfsfunktion: linken Pfad auf Stack legen */
 static StackNode *push_left(TreeNode *node, StackNode *stack)
 {
     while (node != NULL)
@@ -82,19 +106,23 @@ static StackNode *push_left(TreeNode *node, StackNode *stack)
     return stack;
 }
 
+/* Gibt gesamten Baum frei */
 void clearTree(TreeNode *root)
 {
     if (root == NULL)
         return;
+
     clearTree(root->left);
     clearTree(root->right);
     free(root->data);
     free(root);
 }
 
+/* Liefert Anzahl der Knoten */
 unsigned int treeSize(const TreeNode *root)
 {
     if (root == NULL)
         return 0;
+
     return 1 + treeSize(root->left) + treeSize(root->right);
 }