code finished

bintree.c

@@ -1,4 +1,7 @@
+#include <stdlib.h>
+#include <stdio.h>
 #include <string.h>
+
 #include "stack.h"
 #include "bintree.h"
 
@@ -8,6 +11,7 @@ int compareFct(const void *argument1, const void *argument2)
 {
     int x = *((int *)argument1);
     int y = *((int *)argument2);
+
     if (x < y)
         return -1;
     if (x > y)
@@ -20,14 +24,15 @@ static TreeNode *create_node(const void *data, size_t data_size)
     TreeNode *node = malloc(sizeof(TreeNode));
     if (!node)
     {
-        perror("Speicher wurde NICHT reserviert!\n");
+        perror("Speicher wurde NICHT reserviert!");
         return NULL;
     }
 
     node->data = malloc(data_size);
     if (!node->data)
     {
-        perror("Speicher wurde NICHT reserviert!\n");
+        perror("Speicher wurde NICHT reserviert!");
+        free(node);
         return NULL;
     }
 
@@ -38,25 +43,23 @@ static TreeNode *create_node(const void *data, size_t data_size)
     return node;
 }
 
-// Adds a copy of data's pointer destination to the tree using compareFct for ordering. Accepts duplicates
+TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize,
-// if isDuplicate is NULL, otherwise ignores duplicates and sets isDuplicate to 1 (or to 0 if a new entry is added).
+                    CompareFctType compareFct, int *isDuplicate)
-TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFctType compareFct, int *isDuplicate)
 {
     if (root == NULL)
     {
         if (isDuplicate)
-        {
             *isDuplicate = 0;
-        }
         return create_node(data, dataSize);
     }
 
-    int cmpFCT = compareFCT(data, root->data);
+    int cmpFct = compareFct(data, root->data);
-    if (cmpFCT < 0)
+
+    if (cmpFct < 0)
     {
         root->left = addToTree(root->left, data, dataSize, compareFct, isDuplicate);
     }
-    else if (cmpFCT > 0)
+    else if (cmpFct > 0)
     {
         root->right = addToTree(root->right, data, dataSize, compareFct, isDuplicate);
     }
@@ -65,12 +68,10 @@ TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFc
         if (isDuplicate)
             *isDuplicate = 1;
     }
+
     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)
 {
     static StackNode *stack = NULL;
@@ -81,8 +82,12 @@ void *nextTreeData(TreeNode *root)
     if (stack == NULL)
         return NULL;
 
-    TreeNode *node;
+    StackNode *sn = pop(&stack);
-    node = pop(&stack);
+    if (sn == NULL)
+        return NULL;
+
+    TreeNode *node = sn->data;
+    free(sn);
 
     if (node->right != NULL)
         stack = push_left(node->right, stack);
@@ -99,23 +104,22 @@ static StackNode *push_left(TreeNode *node, StackNode *stack)
     }
     return stack;
 }
-// Releases all memory resources (including data copies).
+
 void clearTree(TreeNode *root)
 {
-    if (root = NULL) return;
+    if (root == NULL)
+        return;
+
     clearTree(root->left);
     clearTree(root->right);
     free(root->data);
     free(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);
 
+    return 1 + treeSize(root->left) + treeSize(root->right);
 }