hoockth99140/Doble-Spiel
1
0
Fork 0
generated from freudenreichan/info2Praktikum-DobleSpiel
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

changes bintree finished

Browse Source
This commit is contained in:
Maximilian Ott 2025-12-15 22:54:53 +01:00
parent 0ebd521d61
commit 7d5caa5ce7
1 changed files with 26 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
bintree.c
View File

@ -1,4 +1,7 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h> #include <string.h>
#include "stack.h" #include "stack.h"
#include "bintree.h" #include "bintree.h"
@ -8,6 +11,7 @@ int compareFct(const void *argument1, const void *argument2)
{ {
int x = *((int *)argument1); int x = *((int *)argument1);
int y = *((int *)argument2); int y = *((int *)argument2);
if (x < y) if (x < y)
return -1; return -1;
if (x > y) if (x > y)
@ -20,14 +24,15 @@ static TreeNode *create_node(const void *data, size_t data_size)
TreeNode *node = malloc(sizeof(TreeNode)); TreeNode *node = malloc(sizeof(TreeNode));
if (!node) if (!node)
{ {
perror("Speicher wurde NICHT reserviert!\n"); perror("Speicher wurde NICHT reserviert!");
return NULL; return NULL;
} }
node->data = malloc(data_size); node->data = malloc(data_size);
if (!node->data) if (!node->data)
{ {
perror("Speicher wurde NICHT reserviert!\n"); perror("Speicher wurde NICHT reserviert!");
free(node);
return NULL; return NULL;
} }
@ -38,25 +43,23 @@ static TreeNode *create_node(const void *data, size_t data_size)
return node; 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 (root == NULL)
{ {
if (isDuplicate) if (isDuplicate)
{
*isDuplicate = 0; *isDuplicate = 0;
}
return create_node(data, dataSize); 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); 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); 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) if (isDuplicate)
*isDuplicate = 1; *isDuplicate = 1;
} }
return root; 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) void *nextTreeData(TreeNode *root)
{ {
static StackNode *stack = NULL; static StackNode *stack = NULL;
@ -81,8 +82,12 @@ void *nextTreeData(TreeNode *root)
if (stack == NULL) if (stack == NULL)
return 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) if (node->right != NULL)
stack = push_left(node->right, stack); stack = push_left(node->right, stack);
@ -99,23 +104,22 @@ static StackNode *push_left(TreeNode *node, StackNode *stack)
} }
return stack; return stack;
} }
// Releases all memory resources (including data copies).
void clearTree(TreeNode *root) void clearTree(TreeNode *root)
{ {
if (root = NULL) return; if (root == NULL)
return;
clearTree(root->left); clearTree(root->left);
clearTree(root->right); clearTree(root->right);
free(root->data); free(root->data);
free(root); free(root);
} }
// Returns the number of entries in the tree given by root.
unsigned int treeSize(const TreeNode *root) unsigned int treeSize(const TreeNode *root)
{ {
if (root == NULL) if (root == NULL)
{
return 0; return 0;
}
return 1 + treeSize(root->left) + treeSize(root->right);
return 1 + treeSize(root->left) + treeSize(root->right);
} }