Дерево

#ifndef KJAHERT_TEACHER_H
#define KJAHERT_TEACHER_H
 
#define TEACHER_NAME_LENGTH 30
#define TEACHER_DISC_LENGTH 10
#define TEACHER_POST_LENGTH 10
#define TEACHER_NUMBER_DISC  3
 
struct teacher {
    char name[TEACHER_NAME_LENGTH];
    char post[TEACHER_POST_LENGTH];
    char disc[TEACHER_NUMBER_DISC][TEACHER_DISC_LENGTH];
};
 
#endif /* KJAHERT_TEACHER_H */

#ifndef KJAHERT_TREE_H
#define KJAHERT_TREE_H
 
#include <stdio.h>
#include "teacher.h"
 
struct binary_tree_node;
 
struct binary_tree
{
    struct binary_tree_node *root;
};
 
struct binary_tree *binary_tree_new();
void binary_tree_delete(struct binary_tree *);
void binary_tree_clear(struct binary_tree *tree);
void binary_tree_remove(struct binary_tree *tree, const char *key); 
void binary_tree_insert(struct binary_tree *tree, struct teacher *item);
 
void binary_tree_print(FILE *stream, struct binary_tree *tree);
 
#endif /* KJAHERT_TREE_H */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
 
#include "tree.h"
 
struct binary_tree_node {
    struct teacher item;
    struct binary_tree_node *left;
    struct binary_tree_node *right;
};
 
struct binary_tree_node *binary_tree_node_new(struct binary_tree_node *left,
                                              struct binary_tree_node *right)
{
    struct binary_tree_node *node = 
           (struct binary_tree_node *)calloc(1, sizeof(struct binary_tree_node));
 
    if (node) {
        node->left = left;
        node->right = right;
    }
    
    return node;
}
 
void binary_tree_insert(struct binary_tree *tree, struct teacher *item) {
    struct binary_tree_node *node = tree->root;
    struct binary_tree_node *parent = NULL;
    
    assert(tree);
    assert(item);
    
    while (node) {
        parent = node;
        if (strcmp(node->item.name, item->name) == -1)
            node = node->left;
        else
            node = node->right;
    }
    
    node = binary_tree_node_new(NULL, NULL);
    node->item = *item; // memcpy(&node->item, item, sizeof(*item)); //
    printf("%p NODE created\n", node);
    
    if (!parent) {
        tree->root = node;
    }
    else {
        if (strcmp(parent->item.name, item->name) == -1)
            parent->left = node;
        else
            parent->right = node;
    }
}
 
void binary_tree_remove(struct binary_tree *tree, const char *key) {
    struct binary_tree_node *node = tree->root;
    struct binary_tree_node *child = NULL;
    struct binary_tree_node *parent = NULL;
    struct binary_tree_node *removed = NULL;
    struct binary_tree_node *most_left = NULL;
    struct binary_tree_node *most_left_parent = NULL;
 
    assert(key);
    assert(tree);
 
    while (node && strcmp(node->item.name, key)) {
        parent = node;
        if (strcmp(node->item.name, key) == -1)
            node = node->left;
        else
            node = node->right;
    }
 
    if (node) {
        if (!node->left || !node->right) {
            removed = node;
            if (node->left)
                child = node->left;
            else if (node->right)
                child = node->right;
            
            if (!parent) {
                tree->root = child;
            }
            else {
                if (parent->left == node)
                    parent->left = child;
                else
                    parent->right = child;
            }
        }
        else {
            most_left = node->right;
            most_left_parent = node;
            
            while (most_left->left) {
                most_left_parent = most_left;
                most_left = most_left->left;
            }
            
            node->item = most_left->item;
            removed = most_left;
            
            if (most_left_parent->left == most_left)
                most_left_parent->left = NULL;
            else
                most_left_parent->right = NULL;
        }
 
        printf("%p NODE deleted\n", removed);
    } 
}
 
void binary_tree_clear(struct binary_tree *tree) {
    assert(tree);
    while (tree->root) {
        binary_tree_remove(tree, tree->root->item.name);
    }
}
 
struct binary_tree *binary_tree_new() {
    struct binary_tree *p = (struct binary_tree *)calloc(1, sizeof(struct binary_tree));
    printf("%p TREE created\n", p);
    
    return p;
}
 
void binary_tree_delete(struct binary_tree *tree) {
    if (tree) {
        binary_tree_clear(tree);
        
        printf("%p TREE deleted\n", tree);
        free(tree);
    }
}
 
void binary_tree_postorder_print(FILE *stream, struct binary_tree_node *node) {
    int i;
    if (node) {
        binary_tree_postorder_print(stream, node->left);
        binary_tree_postorder_print(stream, node->right);
        
        fprintf(stream, "%10s: %s\n%10s: %s\n%10s:\n", "name", node->item.name, "post", node->item.post, "disciplines");
        for (i = 0; *(node->item.disc[i]); ++i) {
            fprintf(stream, "%10s: %s\n", "", node->item.disc[i]);
        }
    }
}
 
void binary_tree_print(FILE *stream, struct binary_tree *tree) {
    assert(tree);
    binary_tree_postorder_print(stream, tree->root);
}

#include "tree.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
struct teacher *input_info(FILE *stream, struct teacher *t) {
    int i;
    
    printf ("INPUT info for %p\n", t);
    printf ("NAME: ");
    fgets(t->name, TEACHER_NAME_LENGTH, stream);
    t->name[strlen(t->name) - 1] = '\0';
    
    printf ("POST: ");
    fgets(t->post, TEACHER_POST_LENGTH, stream);
    t->post[strlen(t->post) - 1] = '\0';
    
    for (i = 0; i < TEACHER_NUMBER_DISC; ++i) {
        printf ("DISC: ");
        fgets(t->disc[i], TEACHER_DISC_LENGTH, stream);
        t->disc[i][strlen(t->disc[i]) - 1] = '\0';
    }
    
    return t;
}
 
int main()
{
    struct binary_tree *tree;
    struct teacher t;
    int i;
    
    if ((tree = binary_tree_new()) == NULL) {
        fprintf(stderr, "allocate memory error\n");
        exit(1);
    }
    
    for (i = 0; i < 3; ++i) {
        memset(&t, 1, sizeof(t));
        binary_tree_insert(tree, input_info(stdin, &t));
    }
    
    binary_tree_print(stdout, tree);
    
    binary_tree_delete(tree);
    return 0;
}