Finished work on numbers

bintree.c

@@ -1,3 +1,4 @@
+
 #include <string.h>
 #include "stack.h"
 #include "bintree.h"
@@ -12,49 +13,102 @@
 // 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)
 {
-    if (!root) {
-        TreeNode *newNode = (TreeNode *)malloc(sizeof(TreeNode));
-        if (!newNode) return NULL;
-        newNode->data = malloc(dataSize);
-        if (!newNode->data) {
-            free(newNode);
+  //*******************  Prüfen ob wir kein Nullzeiger oder Null speicher haben
+    if (root == NULL) {
+        // Kein Knoten vorhanden : neuer Knoten wird erstellt
+        TreeNode *node = malloc(sizeof(TreeNode));
+        if (!node)
+          return NULL;
+        node->data = malloc(dataSize);
+        if (!node->data) {
+            free(node);
             return NULL;
         }
-        memcpy(newNode->data, data, dataSize);
-        newNode->left = NULL;
-        newNode->right = NULL;
-        if (isDuplicate) *isDuplicate = 0;
-        return newNode;
+  //*******************   Ende von Prüfungen
+
+        memcpy(node->data, data, dataSize);
+        node->left = NULL;
+        node->right = NULL;
+
+        if (isDuplicate != NULL)
+          *isDuplicate = 0;
+        return node;
     }
 
     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 { // cmp == 0 → Duplikat
-        if (isDuplicate) *isDuplicate = 1;
-        // Duplikate ignorieren, wenn isDuplicate != NULL
+
+    if (cmp == 0) {
+        if (isDuplicate)
+          *isDuplicate = 1;
+        return root;  // Ignorieren, keine Änderung
     }
+
+    if (cmp < 0)
+        root->left = addToTree(root->left, data, dataSize, compareFct, isDuplicate);
+    else
+        root->right = addToTree(root->right, data, dataSize, compareFct, isDuplicate);
+
     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.
 // Use your implementation of a stack to organize the iterator. Push the root node and all left nodes first. On returning the next element,
 // push the top node and push all its left nodes.
-void *nextTreeData(TreeNode *root)
-{
+void *nextTreeData(TreeNode *root) {
 
+    // static stack : wie strtok interner Zustand
+    static StackNode *stack = NULL;
+
+    if (root != NULL) {
+        // neuer Durchlauf : alten Stack löschen
+        clearStack(stack);
+        stack = NULL;
+
+        // alle linken Knoten pushen
+        TreeNode *curr = root;
+        while (curr != NULL) {
+            stack = push(stack, curr);
+            curr = curr->left;
+        }
+    }
+
+    if (stack == NULL)
+        return NULL;   // nichts mehr da
+
+    // obersten Knoten holen
+    TreeNode *node = (TreeNode *) top(stack);
+    stack = pop(stack);
+
+    // rechten Teilbaum durchsuchen (und alle linken davon)
+    TreeNode *curr = node->right;
+    while (curr != NULL) {
+        stack = push(stack, curr);
+        curr = curr->left;
+    }
+
+    return node->data;
 }
 
+
 // Releases all memory resources (including data copies).
-void clearTree(TreeNode *root)
-{
-
+void clearTree(TreeNode *root) {
+    if (root == NULL)
+        return;
+//erstens in die tiefsten Ebenen gehen
+    clearTree(root->left);
+    clearTree(root->right);
+// dann zeiger auf Datei löschen
+    free(root->data);
+//Und am ende element des Baums löschen
+    free(root);
 }
 
-// Returns the number of entries in the tree given by root.
-unsigned int treeSize(const TreeNode *root)
-{
 
-}
+// Returns the number of entries in the tree given by root.
+unsigned int treeSize(const TreeNode *root) {
+    if (root == NULL)
+        return 0;
+
+    return 1 + treeSize(root->left) + treeSize(root->right);
+}