Merge pull request 'main' (#3) from main into JD_Branch

Reviewed-on: #3

bintree.c

@@ -93,11 +93,6 @@ TreeNode *addToTree(TreeNode *wurzel,
     return wurzel;
 }
 
-/*
-Die Funktion gibt bei jedem Aufruf das nächste Element des Binärbaums in **Inorder-Reihenfolge** 
-zurück und merkt sich intern, wo sie zuletzt war.
-*/
-
 void *nextTreeData(TreeNode *wurzel)
 {
     static StackNode *iteratorStack = NULL;  // interner Zustand über Aufrufe hinweg
@@ -115,8 +110,8 @@ void *nextTreeData(TreeNode *wurzel)
         return NULL;
 
     // Nächsten Knoten holen (oberstes Stack-Element)
-    TreeNode *aktuellerKnoten = (TreeNode *)top(iteratorStack); //Oberstes Element zurück
+    TreeNode *aktuellerKnoten = (TreeNode *)top(iteratorStack);
-    iteratorStack = pop(iteratorStack); // entfernt Oberstes Element
+    iteratorStack = pop(iteratorStack);
 
     // Falls rechter Teilbaum existiert: dessen linke Kette ablegen
     if (aktuellerKnoten->right != NULL)

stack.c

@@ -8,8 +8,8 @@ StackNode *push(StackNode *stack, void *data)
     if(node == NULL)
         return stack; // allocation failed -> return unchanged stack
 
-    node->data = data;      // Set the data for the new node   
+    node->data = data;      // Setze Daten   
-    node->next = stack;     // New node points to the previous top of the stack
+    node->next = stack;     // Setze nächsten Knoten auf aktuellen Stack
     return node;
 }
 
@@ -21,7 +21,7 @@ StackNode *pop(StackNode *stack)
         return NULL;
 
     StackNode *next = stack->next;
-    // Do NOT free stack->data here; caller owns the pointed data
+    // Speicher des aktuellen Knotens freigeben
     free(stack);
     return next;
 }

test_bintree.c

@@ -3,7 +3,7 @@
 #include <string.h>
 #include "bintree.h"
 
-// Vergleichsfunktion für unsigned int
+// comparator for unsigned int values stored by value in heap
 static int cmp_uint_ptr(const void *a, const void *b)
 {
     unsigned int va = *(const unsigned int *)a;
@@ -19,7 +19,7 @@ int main(void)
     unsigned int vals[] = {5, 2, 8, 1, 3, 7, 9};
     const size_t n = sizeof(vals)/sizeof(vals[0]);
 
-    // Werte in den Baum einfügen
+    // insert values (copy made by addToTree)
     for(size_t i = 0; i < n; i++)
     {
         int isDup = 0;
@@ -27,25 +27,22 @@ int main(void)
         if(root == NULL && isDup == 0) { fprintf(stderr, "addToTree allocation failed\n"); return 1; }
     }
 
-    // Baumgröße prüfen
     unsigned int sz = treeSize(root);
     if(sz != n) { fprintf(stderr, "treeSize expected %zu got %u\n", n, sz); clearTree(root); return 2; }
 
-    // Inorder-Traversierung (muss sortiert sein)
+    // inorder traversal using nextTreeData
     unsigned int last = 0;
     int first = 1;
     unsigned int *data = nextTreeData(root);
     while(data != NULL)
     {
         unsigned int v = *data;
-        // Prüfen, ob Reihenfolge korrekt ist
         if(!first && v < last) { fprintf(stderr, "inorder traversal not sorted: %u after %u\n", v, last); clearTree(root); return 3; }
         last = v; first = 0;
-        data = nextTreeData(NULL); // nächstes Element holen
+        data = nextTreeData(NULL);
     }
 
-    clearTree(root); // Speicher freigeben
+    clearTree(root);
     printf("test_bintree: OK\n");
     return 0;
 }
-

test_stack.c

@@ -8,37 +8,45 @@ int main(void)
     StackNode *s = NULL;
 
     // push 3 integers
-    int *a = malloc(sizeof(int)); *a = 1; s = push(s, a);
+    int *a = malloc(sizeof(int)); 
-    int *b = malloc(sizeof(int)); *b = 2; s = push(s, b);
+    *a = 1; 
-    int *c = malloc(sizeof(int)); *c = 3; s = push(s, c);
+    s = push(s, a);
+    int *b = malloc(sizeof(int)); 
+    *b = 2; 
+    s = push(s, b);
+    int *c = malloc(sizeof(int)); 
+    *c = 3; 
+    s = push(s, c);
 
-    // top should be c (3)
+    // oben liegt c (3)
     int *topv = (int *)top(s);
     if(topv == NULL || *topv != 3) { fprintf(stderr, "stack top expected 3\n"); return 1; }
 
-    // pop -> now top should be 2
+    // oben liegt nun 2
     s = pop(s);
     topv = (int *)top(s);
     if(topv == NULL || *topv != 2) { fprintf(stderr, "stack top expected 2 after pop\n"); return 2; }
 
-    // pop -> now top should be 1
+    // oben liegt nun 1
     s = pop(s);
     topv = (int *)top(s);
     if(topv == NULL || *topv != 1) { fprintf(stderr, "stack top expected 1 after pop\n"); return 3; }
 
-    // pop last
+    // letzen Stapelinhalt holen
     s = pop(s);
     if(s != NULL) { fprintf(stderr, "stack expected empty after popping all\n"); return 4; }
 
-    // free stored data (stack does not free data)
+    // Eigenen Speicher freigeben
-    free(a); free(b); free(c);
+    free(a); 
+    free(b); 
+    free(c);
 
-    // test clearStack on empty and small stacks
+    // test clearStack mit leerem Stack
     s = push(s, malloc(sizeof(int)));
     s = push(s, malloc(sizeof(int)));
     clearStack(s); // clearStack must free nodes but not payload; free payloads not necessary because we leaked intentionally for test of API
     // Note: above payloads are not freed (stack API spec); this test ensures clearStack doesn't crash.
-    // Success
+    // Funktioniert alles
     printf("test_stack: OK\n");
     return 0;
 }