.gitignore

@@ -1,6 +1,3 @@
 doble_initial
-stackTests
-bintreeTests
-doble
 *.o
 *.exe

bintree.c

@@ -12,55 +12,7 @@
 // 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){
-        //Allocate Memory for Node
-        TreeNode *newNode = calloc(1, sizeof(TreeNode));
-        if(newNode == NULL){
-            return NULL; //Memory allocation failed
-        }
 
-        //Allocate Memory for data
-        newNode->data = malloc(dataSize);
-        if(newNode->data == NULL){
-            free(newNode); //Free unused Memory
-            return NULL;; //Memory allocation failed
-        }
-        memcpy(newNode->data, data, dataSize); //Copy Data
-
-        newNode->left = NULL;
-        newNode->right = NULL;
-
-        if(isDuplicate != NULL){
-            *isDuplicate = 0;
-        }
-
-        return newNode;
-
-    }
-    int cmp = compareFct(root->data, data);
-    
-    if(cmp == 0){
-        //Duplicate
-        if(isDuplicate != NULL){
-            //Ignore duplicate
-            *isDuplicate = 1;
-            return root;
-        } else{
-            //Accept duplicate
-            root->right = addToTree(root->right, data, dataSize, compareFct, NULL);
-        }
-    }
-    else if (cmp > 0)
-    {
-        //Data is smaller -> left
-        root->left = addToTree(root->left, data, dataSize, compareFct, isDuplicate);
-    }else{
-        //Data is bigger -> right
-        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.
@@ -68,52 +20,17 @@ 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;
-    static TreeNode *current = NULL;
 
-    if(root != NULL){
-        clearStack(stack);
-        stack = NULL;
-        current = root;
-    }
-
-    while (current != NULL){
-        stack = push(stack, current);
-        current = current->left;
-    }
-
-    if(stack == NULL){
-        return 0;
-    }
-    TreeNode *node = (TreeNode *)top(stack);
-    stack = pop(stack);
-
-    current = node->right;
-
-    return node->data;
-    
-} 
+}
 
 // Releases all memory resources (including data copies).
 void clearTree(TreeNode *root)
 {
-    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);
+
 }

bintreeTest.c

@@ -1,330 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "unity.h"
-#include "bintree.h"
-
-int compareInts(const void *arg1, const void *arg2){
-    int val1 = *(int *)arg1;
-    int val2 = *(int *)arg2;
-
-    if(val1 < val2) return -1;
-    if(val1 > val2) return 1;
-    return 0;
-}
-
-int compareStrings(const void *arg1, const void *arg2){
-    return -strcmp((const char *)arg1, (const char *)arg2);
-}
-
-
-void setUp(void){
-    //Use if needed    
-}
-void tearDown(void){
-    //Use if needed
-}
-
-//addToTree()
-void test_addToTree_singleElement(void){
-    int value = 42;
-    TreeNode *tree = NULL;
-
-    tree = addToTree(tree, &value, sizeof(int), compareInts, NULL);
-
-    TEST_ASSERT_NOT_NULL(tree);
-    TEST_ASSERT_EQUAL_INT(value, *(int *)tree->data);
-    TEST_ASSERT_NULL(tree->left);
-    TEST_ASSERT_NULL(tree->right);
-}
-
-void test_addToTree_multipleElements(void){
-    TreeNode *tree = NULL;
-    int values[] = {20, 30, 40, 50, 60, 70, 80};
-
-    for(int i = 0; i < 7; i++){
-        tree = addToTree(tree, &values[i], sizeof(int), compareInts, NULL);
-    }
-
-    TEST_ASSERT_NOT_NULL(tree);
-    TEST_ASSERT_EQUAL_INT(20, *(int *)tree->data);
-    TEST_ASSERT_EQUAL_INT(30, *(int *)tree->right->data);
-    TEST_ASSERT_EQUAL_INT(40, *(int *)tree->right->right->data);
-    TEST_ASSERT_EQUAL_INT(50, *(int *)tree->right->right->right->data);
-    TEST_ASSERT_EQUAL_INT(60, *(int *)tree->right->right->right->right->data);
-}
-
-void test_addToTree_multipleElements_optimized(void){
-    TreeNode *tree = NULL;
-    int values[] = {50, 30, 70, 20, 40, 60, 80};
-
-    for(int i = 0; i < 7; i++){
-        tree = addToTree(tree, &values[i], sizeof(int), compareInts, NULL);
-    }
-
-    TEST_ASSERT_NOT_NULL(tree);
-    TEST_ASSERT_EQUAL_INT(50, *(int *)tree->data);
-    TEST_ASSERT_EQUAL_INT(30, *(int *)tree->left->data);
-    TEST_ASSERT_EQUAL_INT(70, *(int *)tree->right->data);
-    TEST_ASSERT_EQUAL_INT(20, *(int *)tree->left->left->data);
-    TEST_ASSERT_EQUAL_INT(40, *(int *)tree->left->right->data);
-}
-
-void test_addToTree_withDuplicatesAccept(void){
-    TreeNode *tree = NULL;
-    int values[] = {50, 30, 70, 20, 20, 60, 60};
-
-    for(int i = 0; i < 7; i++){
-        tree = addToTree(tree, &values[i], sizeof(int), compareInts, NULL);
-    }
-
-    TEST_ASSERT_NOT_NULL(tree);
-
-    TEST_ASSERT_EQUAL_INT(20, *(int *)tree->left->left->data);
-    TEST_ASSERT_EQUAL_INT(20, *(int *)tree->left->left->right->data);
-    TEST_ASSERT_EQUAL_INT(60, *(int *)tree->right->left->data);
-    TEST_ASSERT_EQUAL_INT(60, *(int *)tree->right->left->right->data);
-}
-
-void test_addToTree_withoutDuplicatesAccept(void){
-    TreeNode *tree = NULL;
-    int values[] = {50, 30, 70, 20, 20, 60, 60};
-    int isDuplicate = 0;
-
-    for(int i = 0; i < 7; i++){
-        tree = addToTree(tree, &values[i], sizeof(int), compareInts, &isDuplicate);
-        if(i == 4 || i == 6){
-            TEST_ASSERT_EQUAL_INT(1, isDuplicate);
-        } else{
-            TEST_ASSERT_EQUAL_INT(0, isDuplicate);
-        }
-    }
-
-    TEST_ASSERT_NOT_NULL(tree);
-    TEST_ASSERT_EQUAL_INT(20, *(int *)tree->left->left->data);
-    TEST_ASSERT_EQUAL_INT(60, *(int *)tree->right->left->data);
-    TEST_ASSERT_EQUAL_INT(5, treeSize(tree));
-}
-
-//treeSize()
-void test_treeSize_emptyTree(void){
-    
-    TEST_ASSERT_EQUAL_UINT(0, treeSize(NULL));
-}
-
-void test_treeSize_singleNode(void){
-    TreeNode *tree = NULL;
-    int value = 42;
-    tree = addToTree(tree, &value, sizeof(int), compareInts, NULL);
-
-    TEST_ASSERT_NOT_NULL(tree);
-    TEST_ASSERT_EQUAL_UINT(1, treeSize(tree));
-}
-
-void test_treeSize_multipleNodes(void){
-    TreeNode *tree = NULL;
-    int values[] = {50, 30, 70, 20, 40, 60, 80};
-
-    for(int i = 0; i < 7; i++){
-        tree = addToTree(tree, &values[i], sizeof(int), compareInts, NULL);
-    }
-
-
-    TEST_ASSERT_NOT_NULL(tree);
-    TEST_ASSERT_EQUAL_UINT(7, treeSize(tree));
-
-}
-
-//nextTreeData()
-void test_nextTreeData_emptyTree(void){
-    TEST_ASSERT_NULL(nextTreeData(NULL));
-}
-
-void test_nextTreeData_singleElement(void){
-    TreeNode *tree = NULL;
-    int value = 42;
-    tree = addToTree(tree, &value, sizeof(int), compareInts, NULL);
-
-    int *result = (int *)nextTreeData(tree);
-    TEST_ASSERT_NOT_NULL(result);
-    TEST_ASSERT_EQUAL_INT(value, *result);
-
-    TEST_ASSERT_NULL(nextTreeData(NULL));
-
-    clearTree(tree);
-}
-
-void test_nextTreeData_multipleElements(void){
-
-    TreeNode *tree = NULL;
-    int values[] = {20, 30, 40, 50, 60, 70, 80};
-    int expected[] = {20, 30, 40, 50, 60, 70, 80}; 
-
-    for(int i = 0; i < 7; i++){
-        tree = addToTree(tree, &values[i], sizeof(int), compareInts, NULL);
-    }
-
-    int *result = (int *)nextTreeData(tree);
-    TEST_ASSERT_NOT_NULL(result);
-    TEST_ASSERT_EQUAL_INT(expected[0], *result);
-
-    for(int i = 1; i < 7; i++){
-        result = (int *)nextTreeData(NULL);
-
-        TEST_ASSERT_NOT_NULL(result);
-        TEST_ASSERT_EQUAL_INT(expected[i], *result);
-    }
-
-    TEST_ASSERT_NULL(nextTreeData(NULL));
-
-    clearTree(tree);
-}
-
-void test_nextTreeData_multipleElements_optimized(void){
-
-    TreeNode *tree = NULL;
-    int values[] = {50, 30, 70, 20, 40, 60, 80};
-    int expected[] = {20, 30, 40, 50, 60, 70, 80};
-
-    for(int i = 0; i < 7; i++){
-        tree = addToTree(tree, &values[i], sizeof(int), compareInts, NULL);
-    }
-
-    int *result = (int *)nextTreeData(tree);
-    TEST_ASSERT_NOT_NULL(result);
-    TEST_ASSERT_EQUAL_INT(expected[0], *result);
-
-    for(int i = 1; i < 7; i++){
-        result = (int *)nextTreeData(NULL);
-
-        TEST_ASSERT_NOT_NULL(result);
-        TEST_ASSERT_EQUAL_INT(expected[i], *result);
-    }
-
-    TEST_ASSERT_NULL(nextTreeData(NULL));
-
-    clearTree(tree);
-}
-
-
-void test_nextTreeData_withDuplicates(void){
-    TreeNode *tree = NULL;
-    int values[] = {50, 30, 70, 20, 20, 60, 60};
-    int expected[] = {20, 20, 30, 50, 60, 60, 70};
-
-    for(int i = 0; i < 7; i++){
-        tree = addToTree(tree, &values[i], sizeof(int), compareInts, NULL);
-    }
-
-    int *result = (int *)nextTreeData(tree);
-
-    TEST_ASSERT_NOT_NULL(result);
-    TEST_ASSERT_EQUAL_INT(expected[0], *result);
-
-    for(int i = 1; i < 7; i++){
-        result = (int *)nextTreeData(NULL);
-
-        TEST_ASSERT_NOT_NULL(result);
-        TEST_ASSERT_EQUAL_INT(expected[i], *result);
-    }
-
-    TEST_ASSERT_NULL(nextTreeData(NULL));
-}
-
-void test_nextTreeData_restart(void){
-    TreeNode *tree = NULL;
-    int values[] = {50, 30, 70, 20, 40, 60, 80};
-    int expected[] = {20, 30, 40, 50, 60, 70, 80};
-
-    for(int i = 0; i < 7; i++){
-        tree = addToTree(tree, &values[i], sizeof(int), compareInts, NULL);
-    }
-
-    int *result = (int *)nextTreeData(tree);
-
-    TEST_ASSERT_NOT_NULL(result);
-    TEST_ASSERT_EQUAL_INT(expected[0], *result);
-
-    for(int i = 1; i < 4; i++){
-        result = (int *)nextTreeData(NULL);
-
-        TEST_ASSERT_NOT_NULL(result);
-        TEST_ASSERT_EQUAL_INT(expected[i], *result);
-    }
-
-    result = (int *)nextTreeData(tree);
-
-    TEST_ASSERT_NOT_NULL(result);
-    TEST_ASSERT_EQUAL_INT(expected[0], *result);
-
-    for(int i = 1; i < 7; i++){
-        result = (int *)nextTreeData(NULL);
-
-        TEST_ASSERT_NOT_NULL(result);
-        TEST_ASSERT_EQUAL_INT(expected[i], *result);
-    }
-}
-
-//clearTree()
-void test_clearTree_emptyTree(void){
-    clearTree(NULL);
-    TEST_ASSERT_TRUE(1);
-}
-
-void test_clearTree_singleElement(void){
-    int value = 42;
-    TreeNode *tree = NULL;
-
-    tree = addToTree(tree, &value, sizeof(int), compareInts, NULL);
-
-    clearTree(tree);
-
-    TEST_ASSERT_TRUE(1);
-}
-
-void test_clearTree_multipleElements(void){
-    TreeNode *tree = NULL;
-    int values[] = {50, 30, 70, 20, 40, 60, 80};
-
-    for(int i = 0; i < 7; i++){
-        tree = addToTree(tree, &values[i], sizeof(int), compareInts, NULL);
-    }
-
-    clearTree(tree);
-
-    TEST_ASSERT_TRUE(1);
-}
-
-int main(){
-    UNITY_BEGIN();
-
-    printf("\n============================\nBintree tests\n============================\n");
-    
-    //addToTree()
-    RUN_TEST(test_addToTree_singleElement);
-    RUN_TEST(test_addToTree_multipleElements);
-    RUN_TEST(test_addToTree_multipleElements_optimized);
-    RUN_TEST(test_addToTree_withDuplicatesAccept);
-    RUN_TEST(test_addToTree_withoutDuplicatesAccept);
-
-    //treeSize()
-    RUN_TEST(test_treeSize_emptyTree);
-    RUN_TEST(test_treeSize_singleNode);
-    RUN_TEST(test_treeSize_multipleNodes);
-
-    //nextTreeData()
-    RUN_TEST(test_nextTreeData_emptyTree);
-    RUN_TEST(test_nextTreeData_singleElement);
-    RUN_TEST(test_nextTreeData_multipleElements);
-    RUN_TEST(test_nextTreeData_multipleElements_optimized);
-    RUN_TEST(test_nextTreeData_withDuplicates);
-    RUN_TEST(test_nextTreeData_restart);
-
-    //clearTree()
-    RUN_TEST(test_clearTree_emptyTree);
-    RUN_TEST(test_clearTree_singleElement);
-    RUN_TEST(test_clearTree_multipleElements);
-
-    return UNITY_END();
-    
-}

highscores.txt

@@ -1,3 +1,2 @@
-test;24999
 test;9999
 player1;3999

main.c

@@ -1,6 +1,5 @@
 #include <stdlib.h>
 #include <stdio.h>
-#include <time.h>
 #include "numbers.h"
 #include "timer.h"
 #include "highscore.h"
@@ -38,8 +37,6 @@ void showNumbers(const unsigned int *numbers, unsigned int len)
 // Main game loop: generate numbers, ask user for duplicate, measure time, update highscores.
 int main(int argc, char *argv[])
 {
-    srand(time(NULL));
-
     int exitCode = EXIT_FAILURE;
 
     if(argc != 2)

makefile

@@ -39,8 +39,6 @@ doble_initial:
 # --------------------------
 stackTests: stack.o test_stack.c $(unityfolder)/unity.c
 	$(CC) $(CFLAGS) -I$(unityfolder) -o stackTests test_stack.c stack.o $(unityfolder)/unity.c ${LDFLAGS}
-bintreeTests: bintree.o stack.o bintreeTest.c $(unityfolder)/unity.c
-	$(CC) $(CFLAGS) -I$(unityfolder) -o bintreeTests bintreeTest.c bintree.o stack.o $(unityfolder)/unity.c ${LDFLAGS}
 unitTests:
 	echo "needs to be implemented"
 
@@ -49,7 +47,7 @@ unitTests:
 # --------------------------
 clean:
 ifeq ($(OS),Windows_NT)
-	del /f *.o doble doble_initial bintreeTests stackTests
+	del /f *.o doble
 else
-	rm -f *.o doble doble_initial bintreeTests stackTests
+	rm -f *.o doble
 endif

numbers.c

@@ -14,86 +14,13 @@
 // 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.
-
-
-int compareUInts(const void *arg1, const void *arg2){
-    unsigned int val1 = *(unsigned int *)arg1;
-    unsigned int val2 = *(unsigned int *)arg2;
-
-    if(val1 < val2) return -1;
-    if(val1 > val2) return 1;
-    return 0;
-}
-
 unsigned int* createNumbers(unsigned int len)
 {
-    if(len == 0){
-        return NULL;
-    }
 
-    unsigned int* numbers = (unsigned int*)malloc(len * sizeof(unsigned int));
-    if(numbers == NULL){
-        return NULL;
-    }
-
-    TreeNode *tree = NULL;
-    
-    unsigned int i = 0;
-    while(i < len){
-        unsigned int tmp = (rand() % (2*len)) + 1;
-
-        int isDuplicate = 0;
-        tree = addToTree(tree, &tmp, sizeof(unsigned int), compareUInts, &isDuplicate);
-
-        if(!isDuplicate){
-            numbers[i] = tmp;
-            i++;
-        }
-    }
-
-    clearTree(tree);
-
-    unsigned int rIdx = rand() % len;
-    unsigned int duplicate = numbers[rIdx];
-
-    unsigned int tIdx = rand() % len;
-    while(tIdx == rIdx){
-        tIdx = rand() % len;
-    }
-    numbers[tIdx] = duplicate;
-
-    return numbers;
 }
 
 // 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)
 {
-    if(numbers == NULL || len < 2){
-        return 0;
-    }
 
-    unsigned int* sorted = (unsigned int*)malloc(len * sizeof(unsigned int));
-    if(sorted == NULL){
-        return 0;
-    }
-
-    TreeNode *tree = NULL;
-    for(unsigned int i = 0; i < len; i++){
-        tree = addToTree(tree, &numbers[i], sizeof(unsigned int), compareUInts, NULL);
-    }
-
-    sorted[0] = *(unsigned int *)nextTreeData(tree);
-
-    for(unsigned int j = 1; j < len; j++){
-        sorted[j] = *(unsigned int*)nextTreeData(NULL);
-    }
-    unsigned int duplicate = 0;
-    for(unsigned int k = 0; k < len - 1; k++){
-        if(sorted[k] == sorted[k+1]){
-            duplicate = sorted[k];
-            break;
-        }
-    }
-    free(sorted);
-    return duplicate;
 }