Программа на Бинарное дерево

#include <stdio.h>
 
/* ==================== binary tree ==================== */
 
typedef int T;
typedef struct tnode *Treeptr;
#define cmp(a, b) ((a) <= (b))
 
typedef struct tnode { 
    T data;
    Treeptr left; 
    Treeptr right; 
} Treenode;
 
Treeptr talloc(void);
 
Treeptr addtree(Treeptr p, T data)
{
    if (p == NULL) {   
        p = talloc();
        p->data = data;
        p->left = p->right = NULL;
    } else if (cmp(data, p->data))
        p->left = addtree(p->left, data);
    else             
        p->right = addtree(p->right, data);
    return p;
}
 
#include <stdlib.h>
 
Treeptr talloc(void)
{
    return (Treeptr) malloc(sizeof(Treenode));
}
 
void traversal(Treeptr p, void (*visit)(T))
{
    if (p != NULL) {
        traversal(p->left, visit);
        visit(p->data);
        traversal(p->right, visit);
    }
}
 
void deltree(Treeptr p)
{
    if (p != NULL) {
        free(p->left);
        free(p->right);
        free(p);
    }
}
 
void treeprint(Treeptr p, char *fmt)
{
    if (p != NULL) {
        treeprint(p->left, fmt);
        printf(fmt, p->data);
        treeprint(p->right, fmt);
    }
}
/* ================ end of binary tree ================= */
 
#define MAXDEPTH  100
 
int depth = 0; 
int table[MAXDEPTH];
 
void count_nodes(Treeptr p)
{
    if (p != NULL) {
        if (depth < MAXDEPTH)
            table[depth]++;
        depth++;
        count_nodes(p->left);
        count_nodes(p->right);
        depth--;
    }
}
 
#define MAXSIZE  100
 
int even[MAXSIZE], *peven = even;
int odd[MAXSIZE], *podd = odd;
 
void process_number(int n)
{
    if (n & 1) {
        if (podd < odd + MAXSIZE)
            *podd++ = n;
    } else if (peven < even + MAXSIZE)
        *peven++ = n;
}           
 
int main()
{
    Treeptr root = NULL;
    int n, *p;
 
    while (printf("enter a number (0 to stop):\n") > 0
                && scanf("%d", &n) == 1 && n)
        root = addtree(root, n);
    putchar('\n');
    treeprint(root, "%d ");
 
    count_nodes(root);
    printf("\n\n");
    for (n = 0; table[n] != 0; n++) 
        printf("depth: %d, number of nodes: %d\n", n, table[n]);
 
    traversal(root, process_number);
    for (printf("\neven: "), p = even; p != peven; p++)
        printf("%d ", *p);
    for (printf("\nodd:  "), p = odd; p != podd; p++)
        printf("%d ", *p);
    putchar('\n');
 
    deltree(root);
    return 0;
}