bintree.c

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