From 51e5ba0db686229b17d75acbd5eef26dbb12965f Mon Sep 17 00:00:00 2001 From: Pascal Siepe Date: Thu, 12 Nov 2026 14:04:09 +0100 Subject: [PATCH 1/6] createNumbers first draft --- Startcode/numbers.c | 56 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 56 insertions(+) diff --git a/Startcode/numbers.c b/Startcode/numbers.c index f59d9a2..e734b9e 100644 --- a/Startcode/numbers.c +++ b/Startcode/numbers.c @@ -14,11 +14,67 @@ // Returns len random numbers between 1 and 2x len in random order which are all different, except for two entries. // Returns NULL on errors. Use your implementation of the binary search tree to check for possible duplicates while // creating random numbers. + + +static unsigned int randNumExists(unsigned int randNum, TreeNode *node){ + unsigned int randExists = 0; + while(node != NULL || node->left != NULL || node->right != NULL){ + if(node->data == randNum){ + randExists = 1; + break; + } + if(randNum < node->data){ + node = node->left; + } + else{ + node = node->right; + } + } + return 0; +} + + unsigned int *createNumbers(unsigned int len) { + srand(time(NULL)); + int randomNumber = rand() % len + len; + TreeNode randRoot; + randRoot.data = randomNumber; + randRoot.left = NULL; + randRoot.right = NULL; + unsigned int randomNumbers[len]; + randomNumbers[0] = randRoot.data; + int i = 1; + int pairExists = 0; + while(i < len-1){ + randomNumber = rand() % len + len; + if(!randNumExists(randomNumber, &randRoot)){ + randomNumbers[i++] = randomNumber; + } + else{ + if(!pairExists){ + randomNumbers[i++] = randomNumber; + pairExists = 1; + } + else{ + { + randomNumber = rand() % len + len; + }while(randNumExists(randomNumber)); + randomNumbers[i++] = randomNumber; + } + } + } + if(!pairExists){ + randomNumbers[len-1] = randomNumbers[rand() % (len-1)]; + } + else{ + randomNumbers[len-1] = rand() % len + len; + } + return randomNumbers; } + // Returns only the only number in numbers which is present twice. Returns zero on errors. unsigned int getDuplicate(const unsigned int numbers[], unsigned int len) { From ee64ef74c1f982e0b01d06323fe5ed908f09b08a Mon Sep 17 00:00:00 2001 From: Alex Reece Date: Thu, 12 Nov 2026 14:24:07 +0100 Subject: [PATCH 2/6] stack tests implemented --- Startcode/test_stack.c | 77 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 77 insertions(+) create mode 100644 Startcode/test_stack.c diff --git a/Startcode/test_stack.c b/Startcode/test_stack.c new file mode 100644 index 0000000..3c939c5 --- /dev/null +++ b/Startcode/test_stack.c @@ -0,0 +1,77 @@ +#include "unity.h" +#include "stack.h" + +void test_stackCreate() { + int* firstData = calloc(1, sizeof(int)); + *firstData = 1; + StackNode* initial = push(NULL, firstData); + + TEST_ASSERT_EQUAL_INT(1, *((int *)initial->data)); + TEST_ASSERT_NULL(initial->left); + TEST_ASSERT_NULL(initial->right); +} + +void test_stackPush() { + int* firstData = calloc(1, sizeof(int)); + *firstData = 1; + int* secondData = calloc(1, sizeof(int)); + *secondData = 2; + + StackNode* tree = push(NULL, firstData); + tree = push(tree, secondData); + + TEST_ASSERT_EQUAL_INT(2, *((int *)tree->data)); + TEST_ASSERT_EQUAL_INT(2, *((int*)top(tree))); + +} + +void test_stackPop() { + int* firstData = calloc(1, sizeof(int)); + *firstData = 1; + int* secondData = calloc(1, sizeof(int)); + *secondData = 2; + + StackNode* tree = push(NULL, firstData); + tree = push(tree, secondData); + + free(tree->data); + tree = pop(tree); + TEST_ASSERT_EQUAL_INT(1, *((int*)top(tree))); + +} + +// void test_stackClear() { +// int* firstData = calloc(1, sizeof(int)); +// *firstData = 1; +// int* secondData = calloc(1, sizeof(int)); +// *secondData = 2; + +// StackNode* stack = push(NULL, firstData); +// stack = push(stack, secondData); + +// clearStack(stack); +// TEST_ASSERT_NULL(stack); + + +// } + +void setUp(void) { + // Falls notwendig, kann hier Vorbereitungsarbeit gemacht werden +} + +void tearDown(void) { + // Hier kann Bereinigungsarbeit nach jedem Test durchgeführt werden +} + +int main() { + + UNITY_BEGIN(); + + printf("\n============================\nStack tests\n============================\n"); + RUN_TEST(test_stackCreate); + RUN_TEST(test_stackPush); + RUN_TEST(test_stackPop); + // RUN_TEST(test_stackClear); + + return UNITY_END(); +} From 1b09573787602c75d9d77de1518bc3a544d0897e Mon Sep 17 00:00:00 2001 From: Pascal Siepe Date: Thu, 12 Nov 2026 15:17:58 +0100 Subject: [PATCH 3/6] treeSize implementation --- Startcode/bintree.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/Startcode/bintree.c b/Startcode/bintree.c index 5cf82a9..ce4a24c 100644 --- a/Startcode/bintree.c +++ b/Startcode/bintree.c @@ -26,11 +26,12 @@ void *nextTreeData(TreeNode *root) // Releases all memory resources (including data copies). void clearTree(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); } \ No newline at end of file From 942c816dfccf107cc9b91c8684f86d4edbf9296e Mon Sep 17 00:00:00 2001 From: Alex Reece Date: Thu, 12 Nov 2026 15:25:11 +0100 Subject: [PATCH 4/6] stack fixed segfault --- Startcode/stack.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/Startcode/stack.c b/Startcode/stack.c index 6477ba4..a09b8df 100644 --- a/Startcode/stack.c +++ b/Startcode/stack.c @@ -12,7 +12,9 @@ StackNode *push(StackNode *stack, void *data) { StackNode *newItem = (StackNode*)calloc(1, sizeof(StackNode)); if (newItem == NULL) return NULL; - stack->left = newItem; + if (stack != NULL) { + stack->left = newItem; + } newItem->right = stack; newItem->left = NULL; newItem->data = data; From b2b6f6a8963e52e10c279768b2351a2632a817c1 Mon Sep 17 00:00:00 2001 From: Pascal Siepe Date: Thu, 12 Nov 2026 15:27:52 +0100 Subject: [PATCH 5/6] clearTree implementation --- Startcode/bintree.c | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/Startcode/bintree.c b/Startcode/bintree.c index ce4a24c..75f8c8f 100644 --- a/Startcode/bintree.c +++ b/Startcode/bintree.c @@ -26,7 +26,19 @@ void *nextTreeData(TreeNode *root) // Releases all memory resources (including data copies). void clearTree(TreeNode *root) { - + if(root->left != NULL){ + clearTree(root->left); + free(root->left->data); + free(root->left); + root->left = NULL; + } + + if(root->right != NULL){ + clearTree(root->right); + free(root->right->data); + free(root->right); + root->right; + } } // Returns the number of entries in the tree given by root. From fab92499fa9e912b324b727ab1b03ecd0dfab537 Mon Sep 17 00:00:00 2001 From: Alex Reece Date: Thu, 12 Nov 2026 15:38:28 +0100 Subject: [PATCH 6/6] addToTree implemented --- Startcode/bintree.c | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/Startcode/bintree.c b/Startcode/bintree.c index 75f8c8f..3185307 100644 --- a/Startcode/bintree.c +++ b/Startcode/bintree.c @@ -7,11 +7,23 @@ * `clearTree`: gibt den gesamten Baum frei (rekursiv), * `treeSize`: zählt die Knoten im Baum (rekursiv), * `nextTreeData`: Traversierung mit Hilfe des zuvor implementierten Stacks. */ - // Adds a copy of data's pointer destination to the tree using compareFct for ordering. Accepts duplicates // 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) { + // create new node + TreeNode* newNode = (TreeNode *)calloc(1, sizeof(TreeNode)); + newNode->data = calloc(1, dataSize); + memcpy(newNode->data, data, dataSize); + + if (root == NULL) return newNode; + if (compareFct(data, root->data)) { + root->left = addToTree(root->left, data, dataSize, compareFct, isDuplicate); + } else if (compareFct(root->data, data)) { + root->right = addToTree(root->right, data, dataSize, compareFct, isDuplicate); + } + return root; + }