二叉树的接口定义及实现

/*tree.h --- ADT接口定义*/

#ifndef TREE_H_INCLUDED
#define TREE_H_INCLUDED
#include<stdbool.h>

typedef struct item
{
    char petname[20];
    char petkind[20];
}Item;

#define MAXITEM 10
typedef struct node
{
    Item item;
    struct node *left;
    struct node *right;
}Node;

typedef struct tree
{
    Node *root;
    int size;
}Tree;

typedef struct pair
{
    Node *parent;//该节点的父节点
    Node *child; //该节点本事
}Pair;

void InitilizeTree(Tree *ptree);
bool TreeIsEmpty(const Tree *ptree);
bool TreeIsFull(const Tree *ptree);
int TreeItemCount(const Tree *ptree);
bool AddItem(const Item *pi,Tree *ptree);
bool InTree(const Item *pi,const Tree *ptree);
bool DeleteItem(const Item *pi,Tree *ptree);
void Traverse(const Tree *ptree,void (*pfun)(Item item));
void DeleteAll(Tree *ptree);
void InOrder(const Node *root,void(*fpun)(Item item));
void DeleteAllNodes(Node *root);
void ADDNodes(Node *new_node,Node *root);
bool ToLeft(const Item *i1,const Item *i2);
bool ToRight(const Item *i1,const Item *i2);
Node *MakeNode(const Item *pi);
Pair SeekItem(const Item *ip,const Tree *ptree);
void DeleteNode(Node **ptr);
#endif // TREE_H_INCLUDED

/*tree.c ADT接口实现*/

#include"tree.h"
#include<stdio.h>
void InitilizeTree(Tree *ptree)
{
    ptree->root = NULL;
    ptree->size = 0;
}
bool TreeIsEmpty(const Tree *ptree)
{
    if(ptree->root == NULL)
        return true;
    else
        return false;
}
bool TreeIsFull(const Tree *ptree)
{
    if(ptree->size == MAXITEM)
        return true;
    else
        return false;
}
int TreeItemCount(const Tree *ptree)
{
    return ptree->size;
}
bool AddItem(const Item *pi,Tree *ptree)
{
    Node *new_node;
    if(TreeIsFull((ptree)))
    {
        fprintf(stderr,"Tree is full\n");
        return false;
    }
    if(SeekItem(pi,ptree).child != NULL)
    {
        fprintf(stderr,"Attempt to add duplicate item\n");
        return false;
    }
    new_node = MakeNode(pi);
    if(new_node == NULL)
    {
        fprintf(stderr,"Couldn't create node\n");
        return false;
    }
    ptree->size++;
    if(ptree->root == NULL)
        ptree->root = new_node;
    else
        AddItem(new_node,ptree);
    return true;
}
bool InTree(const Item *pi,const Tree *ptree)
{
    return (SeekItem(pi,ptree).child == NULL)?false:true;
}
bool DeleteItem(const Item *pi,Tree *ptree)
{
    Pair look;
    look = SeekItem(pi,ptree);
    if(look.child == NULL)
        return false;
    if(look.parent == NULL)
        DeleteNode(&ptree->root);
    else if(look.parent->left == look.child)
        DeleteNode(&look.parent->left);
    else
        DeleteNode(&look.parent->right);
    ptree->size--;
    return true;
}
void Traverse(const Tree *ptree,void (*pfun)(Item item))
{
    if(ptree != NULL)
        InOrder(ptree->root,pfun);
}
void DeleteAll(Tree *ptree)
{
    if(ptree != NULL)
        DeleteAllNodes(ptree->root);
    ptree->root =NULL;
    ptree->size = 0;
}
void InOrder(const Node *root,void(*pfun)(Item item))
{
    if(root != NULL)
    {
        InOrder(root->left,pfun);
        (*pfun)(root->item);
        InOrder(root->right,pfun);
    }
}
void DeleteAllNodes(Node *root)
{
    Node *pright;
    if(root != NULL)
    {
        pright = root->right;
        DeleteAllNodes(root->left);
        free(root);
        DeleteAllNodes(pright);
    }
}
void ADDNodes(Node *new_node,Node *root)
{
    if(ToLeft(&new_node->item,&root->item))
    {
        if(root->left == NULL)
            root->left = new_node;
        else
            ADDNodes(new_node,root->left);
    }
    else if(ToRight(&new_node->item,&root->item))
    {
        if(root->right == NULL)
            root->right = new_node;
        else
            ADDNodes(new_node,root->right);
    }
    else
    {
        fprintf(stderr,"location error in AddNode()\n");
        exit(1);
    }
}
bool ToLeft(const Item *i1,const Item *i2)
{
    int compl;
    if((compl = strcmp(i1->petname,i2->petname)) < 0)
        return true;
    else if(compl == 0 && strcmp(i1->petkind,i2->petkind)<0)
        return true;
    else
        return false;
}
bool ToRight(const Item *i1,const Item *i2)
{
    int compl;
    if((compl = strcmp(i1->petname,i2->petname)) > 0)
        return true;
    else if(compl == 0 && strcmp(i1->petkind,i2->petkind)>0)
        return true;
    else
        return false;
}
Node *MakeNode(const Item *pi)
{
    Node *new_node;
    new_node = (Node*)malloc(sizeof(Node));
    if(new_node != NULL)
    {
        new_node->item = *pi;
        new_node->left = NULL;
        new_node->right = NULL;
    }
    return new_node;
}
Pair SeekItem(const Item *ip,const Tree *ptree)
{
    Pair look;
    look.parent = NULL;
    look.child = ptree->root;

    if(look.child == NULL)
        return look;
    while(look.child != NULL)
    {
        if(ToLeft(ip,&(look.child->item)))
        {
            look.parent = look.child;
            look.child = look.child->left;
        }
        else if(ToRight(ip,&(look.child->item)))
        {
            look.parent = look.child;
            look.child = look.child->right;
        }
        else
            break;
    }
    return look;
}
void DeleteNode(Node **ptr)
{
    Node *temp;
    puts((*ptr)->item.petname);
    if((*ptr)->left == NULL)
    {
        temp = *ptr;
        *ptr = (*ptr)->right;
        free(temp);
    }
    else if((*ptr)->right == NULL)
    {
        temp = *ptr;
        *ptr = (*ptr)->left;
        free(temp);
    }
    else
    {
        for(temp = (*ptr)->left;temp->right != NULL;temp = temp->right)
            continue;
        temp->right = (*ptr)->right;
        temp = *ptr;
        *ptr = (*ptr)->left;
        free(temp);
    }
}