wip

bintree.c

@@ -18,7 +18,50 @@ count	-	number of bytes to copy
 */
 TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFctType compareFct, int *isDuplicate)
 {
+    if (root == NULL)
+    {
+        TreeNode *newtreenode = malloc(sizeof(TreeNode));
+        if (newtreenode != NULL)
+        {
 
+            newtreenode->data = malloc(dataSize);
+            if (newtreenode->data == NULL)
+            {
+                free(newtreenode);
+                return NULL;
+            }
+
+            memcpy(newtreenode->data, data, dataSize);
+
+            newtreenode->left = NULL;
+            newtreenode->right = NULL;
+
+            if (isDuplicate != NULL)
+            {
+                *isDuplicate = 0;
+            }
+        }
+        return newtreenode;
+    }
+
+    int compare_value = compareFct(data, root->data); // wie funktioniert comparefcttype funktion? bzw wo steht diese?
+
+    if (compare_value == 0 && isDuplicate != NULL)
+    {
+        *isDuplicate = 1;
+        return root;
+    }
+
+    if (compare_value < 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.
@@ -26,17 +69,60 @@ TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFc
 // push the top node and push all its left nodes.
 void *nextTreeData(TreeNode *root)
 {
+    static StackNode *stack = NULL;
+    TreeNode *currentElement = root;
 
+    if (currentElement != NULL)
+    {
+        clearStack(stack);
+        stack = NULL;
+
+        while (currentElement != NULL)
+        {
+            stack = push(stack, currentElement);
+            currentElement = currentElement->left;
+        }
+    }
+
+    if (stack == NULL)
+    {
+        return NULL;
+    }
+
+    TreeNode *node = (TreeNode *)top(stack);
+    stack = pop(stack);
+
+    currentElement = node->right;
+    while (currentElement != NULL)
+    {
+        stack = push(stack, currentElement);
+        currentElement = currentElement->left;
+    }
+    return node->data;
 }
 
 // Releases all memory resources (including data copies).
 void clearTree(TreeNode *root)
 {
-
+    if (root != NULL)
+    {
+        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)
 {
-
+    unsigned int count = 0;
+    
+    if (root != NULL)
+    {
+        count = 1;
+        count += treeSize(root->right);
+        count += treeSize(root->left);
+    }
+    return count;
 }