二叉树实现例子

#ifndef TREE_H_
#define TREE_H_

#include <stdbool.h>
#define STRSIZE 32
#define TREEMAX 10

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

typedef struct node
{
    Item item;
    struct node * left;
    struct node * right;
} Node;

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

void InitializeTree(Tree * ptree);

bool TreeIsEmpty(const Tree * ptree);

bool TreeIsFull(const Tree * ptree);

int TreeItemCount(const Tree * ptree);

bool AddItem(const Item * pitem, Tree * ptree);

bool DeleteItem(const Item * pitem, Tree * ptree);

bool CheckItem(const Item * pitem, const Tree * ptree);

void Traverse(const Tree * ptree, void (* pfun)(Item item));

void DeleteAll(Tree * ptree);

#endif

 

#include <stdio.h>
#include <string.h>
#include "tree.h"

char menu(void);
void addpet(Tree * ptree);
void deletepet(Tree * ptree);
void checkpet(const Tree * ptree);
void numberpets(const Tree * ptree);
void showpets(const Tree * ptree);
void printitem(Item item);

int main(void)
{
    Tree pets;

    InitializeTree(&pets);

    char choice;
    while('q' != (choice = menu()))
    {
        switch(choice)
        {
            case 'a': addpet(&pets);
                      break;
            case 'd': deletepet(&pets);
                      break;
            case 'c': checkpet(&pets);
                      break;
            case 'n': numberpets(&pets);
                      break;
            case 's': showpets(&pets);
                      break;
            default:  printf("Unknow command!\n");
                      break;
        }
    }
    DeleteAll(&pets);
    printf("Bye!\n");

    return 0;
}

void eatline(void)
{
    while('\n' != getchar())
        continue;
}

char menu(void)
{
    char ch;

    printf("<a. add    d. delete    c. check    n. number    s. show>\n");
    while(EOF != (ch = getchar()))
    {
        eatline();
        if(NULL == strchr("adcns", ch))
        {
            printf("invalid input!\n");
            printf("<a. add    d. delete    c. check    n. number    s. show>\n");
            continue;
        }
        else
            break;
    }
    if(EOF == ch)
        ch = 'q';

    return ch;
}

void addpet(Tree * ptree)
{
    if(TreeIsFull(ptree))   
    {
        fprintf(stderr, "addpet error: tree is full!\n");
        return;
    }

    Item temp;

    printf("Enter pet name to add: ");
    gets(temp.petname);
    printf("Enter pet kind to add: ");
    gets(temp.petkind);
    AddItem(&temp, ptree);
}

void deletepet(Tree * ptree)
{
    Item temp;

    if(TreeIsEmpty(ptree))
    {
        fprintf(stderr, "deletepet error: tree is empty!\n");
        return;
    }

    printf("Enter pet name to delete: ");
    gets(temp.petname);
    printf("Enter pet kind to delete: ");
    gets(temp.petkind);
    printf("<%s - %s> ", temp.petname, temp.petkind);
    if(DeleteItem(&temp, ptree))
        printf("delete success.\n");
    else
        printf("delete failed.\n");
}

void checkpet(const Tree * ptree)
{
    if(TreeIsEmpty(ptree))
    {
        printf("Tree is empty!\n");
        return;
    }

    Item temp;

    printf("Enter pet name to check: ");
    gets(temp.petname);
    printf("Enter pet kind to check: ");
    gets(temp.petkind);
    printf("<%s - %s> ", temp.petname, temp.petkind);
    if(CheckItem(&temp, ptree))
        printf("check true.\n");
    else
        printf("check false.\n");
}

void numberpets(const Tree * ptree)
{
    printf("pets count: %d\n", TreeItemCount(ptree));
}

void showpets(const Tree * ptree)
{
    if(TreeIsEmpty(ptree))
        printf("Tree is empty.\n");
    else
        Traverse(ptree, printitem);
}

void printitem(Item item)
{
    printf("Name: %s, Kind: %s\n", item.petname, item.petkind);
}

#include <stdio.h>
#include <stdlib.h>
#include "tree.h"

typedef struct pair
{
    Node * parent;
    Node * self;
} Pair;



static Pair SeekItem(const Item * pitem, const Tree * ptree);
static void InOrder(const Node * root, void (* pfun)(Item item));
static void DeleteNode(Node ** ppnode);
static bool ToLeft(const Item * pitem, const Item * pitem2);
static bool ToRight(const Item * pitem, const Item * pitem2);
static void DeleteAllNodes(Node * root);
static void AddNode(Node * pnew, Node * root);
static Node * CreateNode(const Item * pitem);


void InitializeTree(Tree * ptree)
{
    ptree->root = NULL;
    ptree->size = 0;
}

bool TreeIsEmpty(const Tree * ptree)
{
    return 0 == ptree->size;
}

bool TreeIsFull(const Tree * ptree)
{
    return TREEMAX == ptree->size;
}

int TreeItemCount(const Tree * ptree)
{
    return ptree->size;
}

bool AddItem(const Item * pitem, Tree * ptree)
{
    if(TreeIsFull(ptree))
    {
        fprintf(stderr, "Tree is full");
        return false;
    }
    if(NULL != SeekItem(pitem, ptree).self)
    {
        fprintf(stderr, "Add item error: duplicate item.\n");
        return false;
    }

    Node * pnew;
    pnew = CreateNode(pitem);
    if(NULL == pnew)
    {
        fprintf(stderr, "Create node failed!\n");
        return false;
    }

    if(NULL == ptree->root)
        ptree->root = pnew;
    else
        AddNode(pnew, ptree->root);

    ptree->size++;

    return true;
}

bool DeleteItem(const Item * pitem, Tree * ptree)
{
    Pair look;

    look = SeekItem(pitem, ptree);
    if(NULL == look.self)
        return false;

    if(NULL == look.parent)
        DeleteNode(&ptree->root);
    else if(look.parent->left == look.self)
        DeleteNode(&look.parent->left);
    else
        DeleteNode(&look.parent->right);

    ptree->size--;

    return true;
}

bool CheckItem(const Item * pitem, const Tree * ptree)
{
    return (NULL == SeekItem(pitem, ptree).self) ? false : true;
}

void Traverse(const Tree * ptree, void (* pfun)(Item item))
{
    if(NULL != ptree)
        InOrder(ptree->root, pfun);
}

void DeleteAll(Tree * ptree)
{
    if(NULL != ptree)
        DeleteAllNodes(ptree->root);
    ptree->root = NULL;
    ptree->size = 0;
}

static void InOrder(const Node * root, void (* pfun)(Item item))
{
    if(NULL != root)
    {
        InOrder(root->left, pfun);
        (*pfun)(root->item);
        InOrder(root->right, pfun);
    }
}

static void DeleteAllNodes(Node * root)
{
    Node * pleft, * pright;
    

    if(NULL != root)
    {
        pleft = root->left;
        pright = root->right;

        DeleteAllNodes(pleft);
        free(root);
        DeleteAllNodes(pright);
    }
}

static void AddNode(Node * pnew, Node * root)
{
    if(ToLeft(&pnew->item, &root->item))
    {
        if(NULL == root->left)
            root->left = pnew;
        else
            AddNode(pnew, root->left);
    }
    else if(ToRight(&pnew->item, &root->item))
    {
        if(NULL == root->right)
            root->right = pnew;
        else
            AddNode(pnew, root->right);
    }
    else
    {
        fprintf(stderr, "location error in AddNode()\n");
        exit(1);
    }
}

static bool ToLeft(const Item * pitem, const Item * pitem2)
{
    int comp;

    if((comp = strcmp(pitem->petname, pitem2->petname)) < 0)
        return true;
    else if(0 == comp && strcmp(pitem->petkind, pitem2->petkind) < 0)
        return true;
    else
        return false;
}

static bool ToRight(const Item * pitem, const Item * pitem2)
{
    int comp;

    if((comp = strcmp(pitem->petname, pitem2->petname)) > 0)
        return true;
    else if(0 == comp && strcmp(pitem->petkind, pitem2->petkind) > 0)
        return true;
    else
        return false;
}

static Node * CreateNode(const Item * pitem)
{
    Node * pnew;

    pnew = (Node *)malloc(sizeof(Node));
    if(NULL != pnew)
    {
       pnew->item = *pitem;
       pnew->left = NULL;
       pnew->right = NULL;
    }

    return pnew;
}

static Pair SeekItem(const Item * pitem, const Tree * ptree)
{
    Pair look;
    look.parent = NULL;
    look.self = ptree->root;

    if(NULL == look.self)
        return look;

    while(NULL != look.self)
    {
        if(ToLeft(pitem, &(look.self->item)))
        {
            look.parent = look.self;
            look.self = look.self->left;
        }
        else if(ToRight(pitem, &(look.self->item)))
        {
            look.parent = look.self;
            look.self = look.self->right;
        }
        else
            break;
    }

    return look;
}

static void DeleteNode(Node ** ppnode)
{
    Node * temp;

    printf("%s\n", (*ppnode)->item.petname);

    if(NULL == (*ppnode)->left)
    {
        temp = *ppnode;
        *ppnode = (*ppnode)->right;
        free(temp);
    }
    else if(NULL == (*ppnode)->right)
    {
        temp = *ppnode;
        *ppnode = (*ppnode)->left;
        free(temp);
    }
    else
    {
        for(temp = (*ppnode)->left; NULL != temp->right; temp = temp->right)
            continue;
        temp->right = (*ppnode)->right;
        temp = *ppnode;
        *ppnode = (*ppnode)->left;
        free(temp);
    }
}