第17章 高级数据表示 编程练习

1、修改程序17.2，使其即能以正序又能以逆序显示电影列表。一种方法是修改链表定义以使链表能被双向遍历；另一种方法是使用递归。

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

#define TSIZE 45

struct movie{
char name[TSIZE];
int rating;
struct movie *next;
struct movie *former;
};

void CreateMovies(struct movie **phead, struct movie **pend);
void DisplayOriginal(struct movie *head, struct movie *end);
void DisplayReverse(struct movie *head, struct movie *end);
void FreeMoives(struct movie *head, struct movie *end);

int main(void)
{
struct movie *head = NULL, *end = NULL;
CreateMovies(&head ,&end);
DisplayOriginal(head,end);
DisplayReverse(head,end);
FreeMoives(head,end);

return 0;
}

void CreateMovies(struct movie **phead, struct movie **pend)
{
char input[TSIZE];
puts("Enter first movie title:");
while(gets(input) != NULL && input[0] != '\0')
{
if(*phead == NULL)
{
*phead = malloc( sizeof(struct movie) );
(*pend) = *phead;
}
else
{
(*pend)->next = malloc( sizeof(struct movie) );
(*pend)->next->former = (*pend);
(*pend) = (*pend)->next;
}
strcpy((*pend)->name, input);

puts("Enter your rating :");
scanf("%d",&(*pend)->rating);
getchar();

puts("Enter next movie title (empty line to stop):");
}
}

void DisplayOriginal(struct movie *head, struct movie *end)
{
if( head == NULL )
{
printf("No movies in the list\n");
return;
}
printf("display in the original order:\n");
while(head != end)
{
printf("%s\t\t%d\n",head->name,head->rating);
head = head->next;
}
printf("%s\t\t%d\n",head->name,head->rating);
}

void DisplayReverse(struct movie *head, struct movie *end)
{
if( end == NULL )
{
printf("No movies in the list\n");
return;
}
printf("display in the reverse order:\n");
while(end != head)
{
printf("%s\t\t%d\n",end->name,end->rating);
end = end->former;
}
printf("%s\t\t%d\n",end->name,end->rating);
}

void FreeMoives(struct movie *head, struct movie *end)
{
struct movie *previous;
if( head == NULL ) return;
while(head != end)
{
previous = head;  //注意：先得到下一个指针，再释放前一个指针
head = head->next;
free(previous);
}
free(head);
}

2．假设list.h（程序清单17.3）如下定义列表：

typedef struct list

{

Node * head; /* 指向列表首 */

Node * end; /* 指向列表尾 */

} List;

根据这个定义，重写list.c（程序清单17.5）函数，并用films3.c（程序清单17.4）测试结果代码。

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

void InitializeList(List * plist)
{
plist->head = NULL;
plist->end  = NULL;
}

int ListIsEmpty(const List *plist)
{
if(plist->head == NULL) return true;
else return false;
}

int ListIsFull(const List *plist)
{
Node *pnode;
pnode = (Node *)malloc(sizeof(struct(Node));
if(pnode==NULL) return true;
else
{
free(pnode);
return false;
}
}

unsigned int ListItemCount(const List *plist)
{
unsigned int count = 0;
Node * pscan = plist->head;
if(pscan == NULL) return count;
while(pscan != plist->end)
{
count++;
pscan = pscan->next;
}
return ++count;
}

int AddItem(Item item,List *plist)
{
Node *pnew;
pnew = malloc(sizeof(Node));
if(pnew==NULL) return false;

if(plist->head == NULL)
{
plist->head = pnew;
plist->end  = pnew;
plist->end->item = item;
return true;
}
plist->end->next = pnew;
plist->end = plist->end->next;
plist->end->item = item;
return true;
}

void Traverse(const List *plist,void (*pfun)(Item item))
{
Node *pscan = plist->head;
if(pscan == NULL) return;
while(pscan != plist->end)
{
(*pfun)(pscan->item);
pscan = pscan->next;
}
(*pfun)(pscan->item);
}

void EmptyTheList(List *plist)
{
Node *previous, *pscan = plist->head;
if(pscan == NULL) return;

while(pscan != plist->end)
{
previous = pscan;  //注意：先得到下一个指针，再释放前一个指针
pscan = pscan->next;
free(privious);
}
free(pscan);
}

3．假设list.h(程序清单17.3)如下定义列表：

#define MAXSIZE 100

typedef struct list

{

Item entries[MAXSIZE]; /*项目数组 */

int items; /*列表中项目的个数 */

} List;

根据这个定义，重写list.c（程序清单17.5）函数，并用films3.c（程序清单17.4）测试结果代码。

#include <stdio.h>
#include <stdlib.h>     /* prototype for exit() */
#include "list.h"      /* defines List, Item   */

void InitializerList(List *plist)
{
plist->items = 0;
}

int ListIsEmpty(const List *plist)
{
if(plist->items==0) return true;
else return false;
}

int ListIsFull(const List *plist)
{
if(plist->items == MAXSIZE) return true;
else return false;
}

unsigned int ListItemCount(const List * plist)
{
return plist->items;
}

int AddItem(Item item,List *plist)
{
if(plist->items == MAXSIZE) return false;
plist->entries[plist->items] = item;
(plist->items)++;
return 1;
}

void Traverse(const List *plist,void(*pfun)(Item item))
{
int i;
for(i=0;i<(plist->items);i++)
(*pfun)(plist->entries[i]);
}

void EmptyTheList(List *plist)
{
plist->items=0;
}

4．重写mall.c（程序清单17.7）使其用两个队列模拟两个摊位。

/* mall.c -- use the Queue interface */
/* compile with queue.c              */

//假设新来的人总是选择人数较少的队列

#include <stdio.h>
#include <stdlib.h>  /* for rand() and srand() */
#include <time.h>  /* for time()    */
#include "queue.h"  /* change Item typedef  */

//以person_per_minute的概率，为*person创造一个新人，若成功返回true
bool new_person(Item *person, int minute, double person_per_minute);

int main(void)
{
Queue line1, line2;
Item person;
int minute, total_time;
double person_per_minute;
int customer=0, served=0, turnaway=0;
int service_time1=0, service_time2=0, total_line=0, total_wait_time=0;

InitializeQueue(&line1);
InitializeQueue(&line2);
srand(time(0));    /* random initializing of rand() */

puts("Case Study: Sigmund Lander's Advice Booth");
puts("Enter the number of simulation hours:");
scanf("%d", &total_time);   //得到仿真时间，单位小时
total_time *= 60 ;     //单位转化为分钟

puts("Enter the average number of customers per hour:");
scanf("%lf", &person_per_minute);
person_per_minute = person_per_minute / 60;// 人/小时 转化为 人/分

for (minute=0; minute<total_time; minute++)
{
if ( new_person(&person, minute, person_per_minute) == true)
{
if ( QueueIsFull(&line1) == true && QueueIsFull(&line2) == true)
turnaway++;
else
{
if ( QueueItemCount(&line1) <= QueueItemCount(&line2))
EnQueue(person, &line1);
else
EnQueue(person, &line2);
customer++;
}
}

if(service_time1<=0 && QueueIsEmpty(&line1)==false)  //检查队列1
{
DeQueue(&person, &line1);
served++;
service_time1 = person.processtime;
total_wait_time += minute - person.arrive;
}

if(service_time2<=0 && QueueIsEmpty(&line2)==false)  //检查队列2
{
DeQueue(&person, &line2);
served++;
service_time2 = person.processtime;
total_wait_time += minute - person.arrive;
}
//服务一分钟
if(service_time1>0) service_time1--;
if(service_time2>0) service_time2--;
total_line += QueueItemCount(&line1) + QueueItemCount(&line2);
}

if (customer > 0)
{
printf("customers accepted: %d\n", customer);
printf("  customers served: %d\n", served);
printf("         turnaways: %d\n", turnaway);
printf("average queue size: %.2f\n", (double) total_line / total_time );
printf(" average wait time: %.2f minutes\n", (double) total_wait_time / served);
}
else
puts("No customers!");

EmptyTheQueue(&line1);
EmptyTheQueue(&line2);
puts("Bye!");

return 0;
}

bool new_person(Item *p_person, int minute, double person_per_minute)  //为*person创造一个新人，若成功返回true
{
if( (double)rand() / RAND_MAX < person_per_minute ) //概率为 person_per_minute  ,注意要有double强制转换
{
p_person->arrive = minute;  //标记 入队时间
p_person->processtime = rand()%3 + 1;  //服务时间随机为1、2、3  （等概率）
return true;
}
return false;
}

5．编写一个程序，让您输入一个字符串。该程序将此字符串中的字符逐个地压入一个栈（请参见复习题5），然后弹出这些字符并显示。结果是将字符串按逆序显示。

//stack.h

#ifndef _STACK_H_
#define _STACK_H_

typedef char Item;

typedef struct
{
Item *top;    //栈顶；
Item *save;   //用于保存初始栈顶，以便最后释放内存
}STACK;

void InitializeStack(Stack *pStack,int size);
//初始化一个大小为size的堆栈
void PushStack(Item item,Stack *pStack);
void PopStack(Item *pitem,Stack *pStack);
void EmptyStack(Stack *pStack);

#endif // _STACK_H_

//static.c
#include <stdio.h>>
#include "stack.h"

void InitializeStack(Stack *pstack,int size)
{
pStack->save = (Item *)malloc(sizeof(Item)*size);
pStack->top = pStack->save + sizeof(Item)*size;  //指向最高处加1
}

void PushStack(Item item,Stack *pStack)
{
(pStack->top)--;
*(pStack->top) = item;
}

void PopStack(Item *pitem,Stack *pStack)
{
*pitem = *(pStack->top);
(pStack->top)++;
}

void EmptyStack(Stack *pStack)
{
free(pStack->save);
}

//use_stack.c
#include<stdio.h>
#include"stack.h"
int main(void)
{
Stack buff;
Item str[30],*p;

InitializeStack(&buff,100);  //初始化一个100大小的堆栈

printf("input a str:")
gets(str);
puts("in original order:");
puts(str);

for(p=str; *p != '\0'; p++)  //入栈
PushStack(*p,&buff);
for(p=str; *p != '\0'; p++)  //出栈
PopStack(p,&buff);

puts("in reverse order:");
puts(str);
return 0;
}

6．写一个接受3个参数的函数。这3个参数为：存有已排序的整数的数组名，数组元素个数和要查找的整数。如果该整数在数组中，函数返回1：否则返回0。函数用折半搜索法实现。

#include<stdio.h>
int search (int table[],int max,int number);
#define M 10
int table[M]={1,3,5,6,9,13,19,21,34,45};

int main(void)
{
int i;
for(i=0;i<100;i++)
if(search(table,M,i))
printf("%d\t",i);
printf("\n");

return 0;
}

int search(int talble[],int max,int number)
{
int min=0,half;
while(1)
{
half=(min+max)/2;
if(number > table[half])
min=half+1;
else if(number < table[half])
max = half-1;
else return 1;

if(min+1==max)
if(number==table[min] || number==table[max])
return 1;
else return 0;
}
}

7．编写一个程序，能打开、读入一个文本文件并统计文件中每个单词出现的次数。用改进的二叉搜索树存储单词及其出现的次数。程序读入文件后，会提供一个有三个选项的菜单。第一个选项为列出所有的单词连同其出现的次数。第二个选项为让您输入一个单词，程序报告该单词在文件中出现的次数。第三个选项为退出。

//main.c
#include <stdio.h>
#include <ctype.h>
#include "tree.h"

#define LMAX 100

void display(Node *node);
char * take(char *p, char word[]);//从p字符串中读出第一个单词到word里，返回此单词后面一个字符的地址

int main(void)
{
char str[LMAX], *p;
FILE *fp;
Tree article;
Item item;
InitializeTree(&article);

printf("input the filename:");
gets(str);
while(  ( fp = fopen(str,"r") ) == NULL   )
{
printf("can't open %s,input again:",str);
gets(str);
}

while ( ( p = fgets(str, LMAX, fp) ) != NULL)
{
while( *(p = take(p, item.word) ) != '\0' )
{
if (InTree(&item, &article) == false )
{
item.times = 1;
AddItem(&item, &article);
}
else
ChangeItem(&item, &article);//将这个item的timers+1
}

}

while(1)
{
printf("\na.list all the words\n");
printf("b.report how many times the word occurred\n");
printf("c.quit\n");
gets(str);
switch( tolower(str[0]) )
{

case 'a':  Traverse (&article, display);
break;

case 'b':  gets(item.word);
if(InTree(&item, &article)) DisplayItem(&item, &article);
else puts("the word is not in the tree");
break;

case 'c':  puts("quit");
DeleteAll(&article);
return 0;

default :  break;
}

}

}

void display(Node *node)
{
printf("%-20s%-20d\n", node->item.word, node->item.times);
}

char * take(char *p, char word[])//从p字符串中读出第一个单词到word里，返回此单词后面一个字符的地址
{
while( !isalpha(*p) )
{
if( *p == '\0' ) return p;
p++;
}
do
{
*word++ = *p++;
}
while( isalpha(*p) );
*word = '\0';
return p;
}

****************************************************************************************************************************************************************************
//tree.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "tree.h"

void InorderTraversal( Node *pnode, void (* pfun)(void *) );//中序遍历：左中右
void PostorderTraversal( Node *pnode, void (* pfun)(void *) );//后序遍历：左右中
int PreorderTraversal( Node *pnode );//前序遍历：中左右
Node** BinarySearch(Item *pitem, Node **ppnode);//二分搜索，搜索到空位或匹配的结点，并返回指向该空位或结点指针的地址
Node* MakeNode(Item item);//产生一个叶子结点
int  CompareItem(Item ,Item );//比较两个Item

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

bool TreeIsEmpty(const Tree * ptree)
{
if (ptree->root == NULL) return true;
else return false;
}

bool TreeIsFull(void)
{
Node *p;
p = malloc( sizeof(Node) ) ;
if (p == NULL) return true;
free(p);
return false;
}

int TreeItemCount(const Tree * ptree)
{
return PreorderTraversal( ptree->root );//前续遍历：中左右
}

bool AddItem( Item *pitem, Tree * ptree)
{
if ( *BinarySearch(pitem, &(ptree->root) ) != NULL)
return false;
else
{
*BinarySearch( pitem, &(ptree->root) ) = MakeNode(*pitem);
return true;
}
}

bool InTree( Item * pitem,  Tree * ptree)
{
if ( *BinarySearch(pitem, &(ptree->root) ) == NULL)
return false;
else
return true;
}

bool DeleteItem( Item * pitem, Tree * ptree)
{
Node **ppnode;
Node *middle,*left,*right;
ppnode = BinarySearch( pitem, &(ptree->root) );
if (*ppnode == NULL) return false;
middle = *ppnode;
left = middle->left;
right = middle->right;
if (left == NULL && right ==NULL) //叶子结点
*ppnode = NULL;
else if(left == NULL && right !=NULL)
*ppnode = right;
else if(left != NULL && right ==NULL)
*ppnode = left;
else
{
while(left->right != NULL) left = left->right ;
left->right = right;
*ppnode = middle->left;
}
printf("delete:%s",middle->item.word);
free(middle);
return true;
}

void Traverse (const Tree * ptree, void (* pfun)(Node *node))
{
InorderTraversal(ptree->root, (* pfun) );
}

void DeleteAll(Tree * ptree)
{
PostorderTraversal(ptree->root, free );
ptree->root = NULL;
}

bool ChangeItem( Item * pitem, Tree * ptree)
{
if ( *BinarySearch(pitem, &(ptree->root) ) == NULL)
return false;
else
{
( *BinarySearch( pitem, &(ptree->root) ) )->item.times ++;
return true;
}
}

bool DisplayItem( Item * pitem, Tree * ptree)
{
Node *pnode = *BinarySearch(pitem, &(ptree->root) );
if ( pnode == NULL)
return false;
else
{
printf("%s has occurred %d times\n", pnode->item.word, pnode->item.times);
return true;
}
}

//以下 是一些上面调用子函数

void InorderTraversal( Node *pnode, void (* pfun)(void *) )//中序遍历：左中右
{
if (pnode != NULL)
{
InorderTraversal(pnode->left, (* pfun) );
(* pfun)(pnode);
InorderTraversal(pnode->right, (* pfun) );
}
}

void PostorderTraversal( Node *pnode, void (* pfun)(void *) )//后续遍历：左右中
{
if (pnode != NULL)
{
PostorderTraversal(pnode->left, (* pfun) );
PostorderTraversal(pnode->right, (* pfun) );
(* pfun)(pnode);
}
}

int PreorderTraversal( Node *pnode )//前续遍历：中左右
{
if (pnode != NULL)
return 1+PreorderTraversal(pnode->left )+PreorderTraversal(pnode->right );
else
return 0;
}

Node** BinarySearch(Item *pitem, Node **ppnode)//二分搜索，搜索到空位或匹配的结点
{
if( *ppnode == NULL || CompareItem(*pitem, (*ppnode)->item) == 0)
return ppnode;
if ( CompareItem(*pitem, (*ppnode)->item) < 0 )
return BinarySearch(pitem, &( (*ppnode)->left)) ;
else
return BinarySearch(pitem, &( (*ppnode)->right)) ;
}

Node* MakeNode(Item item)
{
Node *pnew;
pnew = (Node *)malloc(sizeof(Node));
pnew->item = item;
pnew->left = NULL;
pnew->right = NULL;
return pnew;
}

int  CompareItem(Item item1, Item item2)
{
return strcmp(item1.word, item2.word);
}

************************************************************************************************************************************************************************
//tree.h

#ifndef _TREE_H_
#define _TREE_H_

#define MAX 30

#define bool int
#define true 1
#define false 0

typedef struct
{
char word[MAX];
int times;
}Item;

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

typedef struct
{
struct node *root;
}Tree;

void InitializeTree(Tree * ptree);

bool TreeIsEmpty(const Tree * ptree);

bool TreeIsFull(void);//const Tree * ptree);

int TreeItemCount(const Tree * ptree);

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

bool InTree( Item * pi, Tree * ptree);

bool DeleteItem( Item * pi, Tree * ptree);

void Traverse (const Tree * ptree, void (* pfun)(Node *node));

void DeleteAll(Tree * ptree);

bool ChangeItem( Item * pi, Tree * ptree);

bool DisplayItem( Item * pi,  Tree * ptree);

#endif

8．修改宠物俱乐部程序，使所有同名的宠物存储在相同节点中的一个列表中。当用户选择查找一个宠物时，程序要求用户给出宠物名，而后列出所有具有此名字的宠物（连同它们的种类）。

//petclub.c
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include "tree.h"

#define LMAX 100

char menu(void);
void display(Node *node);

int main(void)
{
char choice;
Tree pets;
Item temp;

InitializeTree(&pets);

while ((choice = menu()) != 'q')
{
switch (choice)
{
case 'a' :  puts("Please enter name of pet:");
gets(temp.petname);
puts("Please enter pet kind:");
gets(temp.petkind[0]);
temp.times = 1;
if ( AddItem(&temp, &pets) == true )
printf("%s %s has been added\n", temp.petname, temp.petkind[0]);
else
puts("add error!");
break;

case 'l' :  if (TreeItemCount(&pets) >0 )
Traverse (&pets, display);
else
puts("there is no pets\n");
break;

case 'f' :  gets(temp.petname);
DisplayItem(&temp, &pets);
break;

case 'n' :  printf("%d pets in club\n", TreeItemCount(&pets));
break;

case 'd' :  gets(temp.petname);
if( DeleteItem(&temp, &pets) == true)
printf("%s has been deleted\n", temp.petname);
else
puts("the pet is not in the tree");
break;

default  :  puts("Switching error");
}
}
DeleteAll(&pets);
puts("Bye.");

return 0;
}

char menu(void)
{
int ch;

puts("Nerfville Pet Club Membership Program");
puts("Enter the letter corresponding to your choice:");
puts("a) add a pet          l) show list of pets");
puts("n) number of pets     f) find pets");
puts("d) delete a pet       q) quit");
while ((ch = getchar()) != EOF)
{
while (getchar() != '\n')  /* discard rest of line */
continue;
ch = tolower(ch);
if (strchr("alrfndq",ch) == NULL)
puts("Please enter an a, l, f, n, d, or q:");
else
break;
}

if (ch == EOF)       /* make EOF cause program to quit */
ch = 'q';

return ch;
}

***************************************************************************************************************************************************************************
//tree.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "tree.h"

void InorderTraversal( Node *pnode, void (* pfun)(void *) );//中序遍历：左中右
void PostorderTraversal( Node *pnode, void (* pfun)(void *) );//后序遍历：左右中
int PreorderTraversal( Node *pnode );//前序遍历：中左右
Node** BinarySearch(Item *pitem, Node **ppnode);//二分搜索，搜索到空位或匹配的结点，并返回指向该空位或结点指针的地址
Node* MakeNode(Item item);//产生一个叶子结点
int  CompareItem(Item ,Item );//比较两个Item
void display(Node *pnode);

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

bool TreeIsEmpty(const Tree * ptree)
{
if (ptree->root == NULL) return true;
else return false;
}

bool TreeIsFull(void)
{
Node *p;
p = malloc( sizeof(Node) ) ;
if (p == NULL) return true;
free(p);
return false;
}

int TreeItemCount(const Tree * ptree)
{
return PreorderTraversal( ptree->root );//前续遍历：中左右
}

bool AddItem( Item *pitem, Tree * ptree)
{
Node *pnode;
int i;
if ( TreeIsFull() ) return false;
pnode = *BinarySearch(pitem, &(ptree->root) );
if ( pnode != NULL)
{
for(i=0; i < pnode->item.times; i++)
if ( strcmp( pnode->item.petkind[i] , (*pitem).petkind[0] ) == 0 )
return false;
strcpy ( pnode->item.petkind[pnode->item.times] , (*pitem).petkind[0] );
(pnode->item.times)++;
return true;
}
else
{
*BinarySearch(pitem, &(ptree->root) ) = MakeNode(*pitem);
return true;
}
}

bool InTree( Item * pitem,  Tree * ptree)
{
if ( *BinarySearch(pitem, &(ptree->root) ) == NULL)
return false;
else
return true;
}

bool DeleteItem( Item * pitem, Tree * ptree)
{
Node **ppnode;
Node *middle,*left,*right;
ppnode = BinarySearch( pitem, &(ptree->root) );
if (*ppnode == NULL) return false;
middle = *ppnode;
left = middle->left;
right = middle->right;
if (left == NULL && right ==NULL) //叶子结点
*ppnode = NULL;
else if(left == NULL && right !=NULL)
*ppnode = right;
else if(left != NULL && right ==NULL)
*ppnode = left;
else
{
while(left->right != NULL) left = left->right ;
left->right = right;
*ppnode = middle->left;
}
free(middle);
return true;
}

void Traverse (const Tree * ptree, void (* pfun)(Node *node))
{
InorderTraversal(ptree->root, (* pfun) );
}

void DeleteAll(Tree * ptree)
{
PostorderTraversal(ptree->root, free );
ptree->root = NULL;
}

bool DisplayItem( Item * pitem, Tree * ptree)
{
Node *pnode = *BinarySearch(pitem, &(ptree->root) );
if ( pnode == NULL)
{
puts("the word is not in the tree");
return false;
}
else
{
display(pnode);
return true;
}
}

//以下 是一些上面调用子函数

void InorderTraversal( Node *pnode, void (* pfun)(void *) )//中序遍历：左中右
{
if (pnode != NULL)
{
InorderTraversal(pnode->left, (* pfun) );
(* pfun)(pnode);
InorderTraversal(pnode->right, (* pfun) );
}
}

void PostorderTraversal( Node *pnode, void (* pfun)(void *) )//后续遍历：左右中
{
if (pnode != NULL)
{
PostorderTraversal(pnode->left, (* pfun) );
PostorderTraversal(pnode->right, (* pfun) );
(* pfun)(pnode);
}
}

int PreorderTraversal( Node *pnode )//前续遍历：中左右
{
if (pnode != NULL)
return pnode->item.times+PreorderTraversal(pnode->left )+PreorderTraversal(pnode->right );
else
return 0;
}

Node** BinarySearch(Item *pitem, Node **ppnode)//二分搜索，搜索到空位或匹配的结点
{
if( *ppnode == NULL || CompareItem(*pitem, (*ppnode)->item) == 0)
return ppnode;
if ( CompareItem(*pitem, (*ppnode)->item) < 0 )
return BinarySearch(pitem, &( (*ppnode)->left)) ;
else
return BinarySearch(pitem, &( (*ppnode)->right)) ;
}

Node* MakeNode(Item item)
{
Node *pnew;
pnew = (Node *)malloc(sizeof(Node));
pnew->item = item;
pnew->left = NULL;
pnew->right = NULL;
return pnew;
}

int  CompareItem(Item item1, Item item2)
{
return strcmp(item1.petname, item2.petname);
}

void display(Node *pnode)
{
int i;
printf("%-15s", pnode->item.petname);
if ( pnode->item.times == 1)
printf("%d kind  pet: ", 1);
else
printf("%d kinds pet: ", pnode->item.times);
for(i=0; i < pnode->item.times; i++)
printf("%s,", pnode->item.petkind[i] );
printf("\b\n");
}

************************************************************************************************************************************************************************

//tree.h

#ifndef _TREE_H_
#define _TREE_H_

#define MAX 30
#define TMAX 20

#define bool int
#define true 1
#define false 0

typedef struct
{
char petname[MAX];
char petkind[TMAX][MAX];
int times;
}Item;

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

typedef struct
{
struct node *root;
}Tree;

void InitializeTree(Tree * ptree);

bool TreeIsEmpty(const Tree * ptree);

bool TreeIsFull(void);//const Tree * ptree);

int TreeItemCount(const Tree * ptree);

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

bool InTree( Item * pi, Tree * ptree);

bool DeleteItem( Item * pi, Tree * ptree);

void Traverse (const Tree * ptree, void (* pfun)(Node *node));

void DeleteAll(Tree * ptree);

bool DisplayItem( Item * pi,  Tree * ptree);

#endif