Doble-Spiel/bintree.c

#include <stdlib.h>          
#include <stdio.h>           
#include <string.h>          

#include "stack.h"           
#include "bintree.h"         

static StackNode *push_left(TreeNode *node, StackNode *stack);  

// Vergleichsfunktion 
int compareFct(const void *argument1, const void *argument2)
{
    int x = *((int *)argument1);                   
    int y = *((int *)argument2);                   

    if (x < y) return -1;                          
    if (x > y) return 1;                           
    return 0;                                      
}

// Erzeugt einen neuen Baumknoten mit Datenkopie 
static TreeNode *create_node(const void *data, size_t data_size)
{
    TreeNode *node = malloc(sizeof(TreeNode));    // Speicher für neuen Knoten reservieren
    if (!node)
    {
        perror("Speicher wurde NICHT reserviert!"); 
        return NULL;                               
    }

    node->data = malloc(data_size);               // Speicher für Knotendaten reservieren
    if (!node->data)
    {
        perror("Speicher wurde NICHT reserviert!"); 
        free(node);                                
        return NULL;                               
    }

    memcpy(node->data, data, data_size);          // Daten in neuen Speicher kopieren
    node->left = NULL;                             // Linken Kindzeiger initialisieren
    node->right = NULL;                            // Rechten Kindzeiger initialisieren

    return node;                                   // Zeiger auf neuen Knoten zurückgeben
}

//Fügt Daten in den Binärbaum ein 
TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFctType compareFct, int *isDuplicate)
{
    if (root == NULL)                              // Wenn Baum leer ist (Ende erreicht)
    {
        if (isDuplicate)
            *isDuplicate = 0;                      // Kein Duplikat, da neu eingefügt
        return create_node(data, dataSize);       
    }

    int cmp = compareFct(data, root->data);       // Daten mit aktuellem Knoten vergleichen

    if (cmp < 0)                                  
    {
        root->left = addToTree(root->left, data, dataSize, compareFct, isDuplicate); 
    }
    else if (cmp > 0)                             
    {
        root->right = addToTree(root->right, data, dataSize, compareFct, isDuplicate);
    }
    else                                          
    {
        if (isDuplicate)
            *isDuplicate = 1;                     
    }

    return root;                                  // Wurzel unverändert zurückgeben 
}

// Inorder-Iterator über den Baum 
void *nextTreeData(TreeNode *root)
{
    static StackNode *stack = NULL;               

    /* Linken Pfad auf Stack legen */
    if (root != NULL)
        stack = push_left(root, stack);           // Linken Pfad ab root auf Stack legen

    if (stack == NULL)                            
        return NULL;

    TreeNode *node = (TreeNode *)top(stack);     // Oberstes Element vom Stack holen
    stack = pop(stack);                           

    if (node->right != NULL)                      // Wenn rechter Teilbaum existiert
        stack = push_left(node->right, stack);   // Linken Pfad vom rechten Kind auf Stack legen

    return node->data;                            // Daten des Knotens zurückgeben
}

// Hilfsfunktion: linken Pfad auf Stack legen 
static StackNode *push_left(TreeNode *node, StackNode *stack)
{
    while (node != NULL)                          // Solange linkes Kind existiert
    {
        stack = push(stack, node);                // Knoten auf Stack legen
        node = node->left;                         
    }
    return stack;                                 
}

// Gibt gesamten Baum frei 
void clearTree(TreeNode *root)
{
    if (root == NULL)                             
        return;

    clearTree(root->left);                        
    clearTree(root->right);                       
    free(root->data);                             
    free(root);                                   
}
// Liefert Anzahl der Knoten 
unsigned int treeSize(const TreeNode *root)
{
    if (root == NULL)                             
        return 0;

    return 1 + treeSize(root->left) + treeSize(root->right); 
}