C Primer Plus （第五版） 第十七章 高级数据显示 编程练习

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

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TSIZE 45
typedef struct film {
	char title[TSIZE];
	int rating;
	struct film * next;
	struct film * up;
}Film;

void positive(Film * p);	//正序显示
void reversed(Film * p);	//逆序显示
void recursion(Film * p);	//逆序递归显示
void empty(Film * p);

int main(void)
{
	Film * head = NULL;	//指向链表头结点的指针，始终指向头结点保持不变
	Film * current;		//动态内存分配的地址。
	Film * prev;		//尾结点，可变，每次用来更新结构体内指针变量的值和自身的值。
	char input[TSIZE];

	puts("Enter first movie title: ");
	while (gets(input) != NULL && input[0] != ‘\0‘)
	{
		current = (Film *)malloc(sizeof(Film));
		/*
		if ((current = (Film *)malloc(sizeof(Film))) == NULL)
		{
			printf("内存分配失败：\n");
			exit(EXIT_FAILURE);
		}
		*/
		if (head == NULL)
		{
			head = current;
			current->up = NULL;
		}
		else
		{
			prev->next = current;
			current->up = prev;
		}
		current->next = NULL;
		strcpy(current->title, input);
		puts("Enter your rating <0-10>: ");
		scanf("%d", &current->rating);
		while (getchar() != ‘\n‘)
			continue;
		puts("Enter next movie title (empty line to stop): ");
		prev = current;
	}

	if (head == NULL)
		printf("No data entered. ");
	else
	{
		printf("Here is the movie list: \n");
		positive(head);
		printf("\n");
		printf("Here is the movie list: \n");
		reversed(prev);
		printf("\n");
		printf("Here is the movie list: \n");
		recursion(head);
	}

	printf("Bye!\n");

	return 0;
}

void positive(Film * p)
{
	while (p != NULL)
	{
		printf("Movie: %s Rating: %d\n", p->title, p->rating);
		p = p->next;
	}
}
void reversed(Film * p)
{
	while (p != NULL)
	{
		printf("Movie: %s Rating: %d\n", p->title, p->rating);
		p = p->up;
	}
}
void recursion(Film * p)
{
	if (p->next != NULL)
		recursion(p->next);
	printf("Movie: %s Rating: %d\n", p->title, p->rating);
}
void empty(Film * p)
{
	Film * temp;

	while (p != NULL)
	{
		temp = p;
		p = p->next;;
		free(temp);
	}
}

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

typedef struct list

{

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

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

}List;

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

/* 重写list.c */
#include <stdio.h>
#include <stdlib.h>
#include "list_17_3.h"

static void CopyToNode(Item item, Node * pnode);

void InitializeList(List * plist)
{
	//plist = NULL;	//Error plist是一个变量地址，只能改变变量的值 ，不能改变地址。
	plist->head = NULL;
	plist->end = NULL;
}

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

bool ListIsFull(const List * plist)
{	//判定内存是否有足够空间，可以不传递形参
	Node * pt;
	bool full;

	pt = (Node *)malloc(sizeof(Node));
	if (pt == NULL)
		full = true;
	else
		full = false;
	free(pt);
	return full;
}

unsigned int ListItemCount(const List * plist)
{
	unsigned int count = 0;
	Node * pnode = plist->head;	

	while (pnode != NULL)
	{
		++count;
		pnode = pnode->next;
	}

	return count;
}

bool AddItem(Item item, List * plist)
{
	Node * pnew;
	Node * scan = plist->head;

	pnew = (Node *)malloc(sizeof(Node));
	if (pnew == NULL)
		return false;	

	CopyToNode(item, pnew);
	pnew->next = NULL;
	if (scan == NULL)
		plist->head = pnew;
	else
		plist->end->next = pnew;
	plist->end = pnew;
	return true;
}

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

void EmptyTheList(List * plist)
{
	Node * psave;
	while (plist->head != NULL)
	{
		psave = plist->head->next;
		free(plist->head);
		plist->head = psave;
	}
}

static void CopyToNode(Item item, Node * pnode)
{
	pnode->item = item;
}

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

#define MAXZIZE 100

typedef struct list

{

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

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

}List;

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

/* 重写list.c */
#include <stdio.h>
#include <stdlib.h>
#include "list_17_3.h"

static void CopyToNode(Item item, Item * pnode);

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

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

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

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

bool AddItem(Item item, List * plist)
{
	int i = plist->items;
	if (i < MAXSIZE)
	{
		CopyToNode(item, &plist->entries[i]);
		plist->items++;
		return true;
	}

	return false;
}

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;
}

static void CopyToNode(Item item, Node * pnode)
{
	pnode->item = item;
}

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

//mall.c明明是程序清单17.9，书上搞错了？？？

/* 重写mall.c 用两个队列模拟二个摊位*/
/* 
	以分钟为单位程序有局限性。
	当有两个摊位时，因为每分钟才会有一个顾客生成，所以一个小时最多只可能有60个顾客
	就算每个顾客都要三分钟，那么两个摊位可以接客40人，再加上两个队列可容纳20人
	所以永远不可能出现被拒绝加入队列的情况。
*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "queue.h"
#define MIN_PER_HR 60.0

bool newcustomer(double x);
Item customertime(long when);

int main(void)
{
	Queue line1, line2;
	Item temp;
	int hours;
	int perhour;
	long cycle, cyclelimit;
	long turnaways = 0;
	long customers = 0;
	long served1 = 0, served2 = 0;
	long sum_line1 = 0, sum_line2 = 0;
	int wait_time1 = 0, wait_time2 = 0;
	double min_per_cust;
	long line_wait1 = 0, line_wait2 = 0;

	InitQueue(&line1);
	InitQueue(&line2);

	srand((unsigned)time(NULL));

	puts("Case Study: Sigmund Lander‘s Advice Booth");
	puts("Enter the number of simulation hours:");
	scanf("%d", &hours);
	//以秒为单位
	cyclelimit = MIN_PER_HR * hours;

	puts("Enter the average number of customers per hour: ");
	scanf("%d", &perhour);
	min_per_cust = perhour / MIN_PER_HR;
	printf("%.2lf\n", min_per_cust);
	int i = 0;
	for (cycle = 0; cycle < cyclelimit; cycle++)
	{
		if (newcustomer(min_per_cust))
		{
			i++;
			if (QueueIsFull(&line1) && QueueIsFull(&line2))
				turnaways++;
			else
			{
				customers++;
				temp = customertime(cycle);
				if (QueueItemCount(&line1) < QueueItemCount(&line2))
					EnQueue(temp, &line1);
				else
					EnQueue(temp, &line2);
			}
		}
		if (wait_time1 <= 0 && !QueueIsEmpty(&line1))
		{
			DeQueue(&temp, &line1);
			wait_time1 = temp.processtime;
			line_wait1 += cycle - temp.arrive;
			served1++;
		}
		if (wait_time2 <= 0 && !QueueIsEmpty(&line2))
		{
			DeQueue(&temp, &line2);
			wait_time2 = temp.processtime;
			line_wait2 += cycle - temp.arrive;
			served2++;
		}
		if (wait_time1 > 0) wait_time1--;
		if (wait_time2 > 0)	wait_time2--;
		sum_line1 += QueueItemCount(&line1);
		sum_line2 += QueueItemCount(&line1);
	}
	if (customers > 0)
	{	//两个摊位总的营业情况
		printf("customers accepted: %ld\n", customers);
		printf("   custmers served: %ld\n", served1 + served2);
		printf("		 turnaways: %ld\n", turnaways);
		printf("average queue size: %.2f\n", (double)(sum_line1 + sum_line2) / cyclelimit);
		printf("average wait time: %.2f minutes\n", (double)(line_wait1 + line_wait2) / (served1 + served2));
	}
	else
		puts("No customers!");

	printf("i = %d\n", i);
	return 0;
}

bool newcustomer(double x)
{
	if (rand()*x / RAND_MAX < 1)
		return true;
	else
		return false;
}

Item customertime(long when)
{
	Item cust;

	cust.processtime = rand() % 3 + 1;
	cust.arrive = when;

	return cust;
}

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

/* stack.h -- 栈接口 */
#ifndef _STACK_H_
#define _STACK_H_
#include <stdbool.h>

typedef char Item;

typedef struct node
{
	Item item;
	struct node * next;
} Node;

typedef struct stack{
	Node * top;
	Node * bottom;
}Stack;

void InitStack(Stack * ps);
bool StackIsFull(const Stack * ps);
bool StackIsEmpty(const Stack * ps);
int StackItemCount(const Stack * ps);
bool push(Item item, Stack * ps);
bool Pop(Item * pitem, Stack * ps);

#endif

/* stack.c -- 栈相关函数定义 */
#include <stdio.h>
#include <stdlib.h>
#include "stack.h"

static void CopyToNode(Item item, Node * pn);
static void CopyToItem(Node * pn, Item * pi);

void InitStack(Stack * ps)
{
	ps->bottom = ps->top = NULL;
}
bool StackIsFull(const Stack * ps)
{
	Node * temp;
	temp = (Node *)malloc(sizeof(Node));
	if (temp == NULL)
		return true;
	else
		free(temp);
	return false;
}
bool StackIsEmpty(const Stack * ps)
{
	return ps->top == NULL;
}
bool push(Item item, Stack * ps)
{
	Node * pnew;

	if (StackIsFull(ps))
		return false;
	pnew = (Node *)malloc(sizeof(Node));
	if (pnew == NULL)
	{
		fprintf(stderr, "Unable to allocate memory!\n");
		exit(1);
	}
	CopyToNode(item, pnew);
	if (StackIsEmpty(ps))
	{
		pnew->next = NULL;
		ps->bottom = pnew;
	}
	else
		pnew->next = ps->top;
	ps->top = pnew;

	return true;
}
bool Pop(Item * pitem, Stack * ps)
{
	Node * pt;

	if (StackIsEmpty(ps))
		return false;
	CopyToItem(ps->top, pitem);
	pt = ps->top;
	ps->top = ps->top->next;
	free(pt);
	if (ps->top == NULL)
		ps->bottom = NULL;
	return true;
}
static void CopyToNode(Item item, Node * pn)
{
	pn->item = item;
}
static void CopyToItem(Node * pn, Item * pi)
{
	*pi = pn->item;
}

/* test.c -- 测试栈，与stack.c一起编译 */
#include <stdio.h>
#include "stack.h"
#define STRLEN 80
int main(void)
{
	char str[STRLEN];
	Stack stack;
	int i;
	Item ch;

	InitStack(&stack);
	printf("请输入字符串：");
	gets(str);

	for (i = 0; str[i] != ‘\0‘ && i < STRLEN; i++)
		push(str[i], &stack);
	printf("出栈输出字符串：");
	while (Pop(&ch, &stack))
		putchar(ch);

	putchar(‘\n‘);

	return 0;
}

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

/*
折半查找1-99中有哪些数包含在数组中
*/

#include <stdio.h>
#include <stdbool.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-1, i))
		printf("%d ", i);
	printf("\n");
	return 0;
}

int search(int table[], int max, int number)
{
	int min = 0, half;
	int i = 0;
	while (1)
	{
		i++;
		half = (min + max) / 2;		//最小数加最大数除以2等于这两个数的中间数
		if (number > table[half])
		{
			min = half + 1;			//确定最小数
		}
		else
		{
			if (number < table[half])
				max = half - 1;		//确定最大数
			else
				return true;
		}			

		if (min + 1 == max)
		{	//如果重合说明中中间已没有数，直接判断临的两个数
			if (number == table[min] || number == table[max])
				return true;
			else
				return false;
		}
	}
}

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

/* tree.h */
#ifndef _TEST_H_
#define _TEST_H_
#include <stdbool.h>
#define WORDLEN 55
typedef struct item
{
	char word[WORDLEN];
	int word_size;
}Item;
typedef struct node
{
	Item item;
	struct node * left;
	struct node * right;
}Node;
typedef struct tree
{
	Node * root;
	int node_size;
}Tree;
void InitTree(Tree * pt);
bool TreeIsEmpty(Tree * pt);
bool TreeIsFull(Tree * pt);
int TreeItemCount(const Tree * pt);
bool AddItem(const Item * pi, Tree * pt);
Node * InItem(const Item * pi, Tree * pt);
bool DeItem(const Item * pi, Tree * pt);
void traverse(const Tree * pt, void(* pfun)(Item item));
void DeAll(Tree * pt);
#endif

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

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

/* 局部函数 */
static Node * MakeNode(const Item * pi);
static bool ToLeft(const Item * i1, const Item * i2);
static bool ToRight(const Item * i1, const Item * i2);
static void AddNode(Node * new_node, Node * root);
static void InOrder(const Node * root, void(*pfun)(Item item));
static Pair SeekItem(const Item * pi, const Tree * ptree);
static void DeNode(Node ** ptr);
static void DeAllNodes(Node * ptr);

void InitTree(Tree * pt)
{
	pt->node_size = 0;
	pt->root = NULL;
}
bool TreeIsEmpty(Tree * pt)
{
	return pt->root == NULL;
}
bool TreeIsFull(Tree * pt)
{
	Node * ptemp;
	ptemp = (Node *)malloc(sizeof(Node));
	if (ptemp == NULL)
		return true;
	else
		return false;
}
int TreeItemCount(const Tree * pt)
{
	return pt->node_size;
}
bool AddItem(const Item * pi, Tree * pt)
{
	Node * new_node;
	if (TreeIsFull(pt))
	{
		fprintf(stderr, "Tree is full\n");
		return false;
	}
	new_node = MakeNode(pi);
	if (new_node == NULL)
	{
		fprintf(stderr, "Couldn‘t create node\n");
		return false;
	}
	if (SeekItem(pi, pt).child != NULL)
	{
		SeekItem(pi, pt).child->item.word_size++;
		free(new_node);
		return true;
	}
	if (pt->root == NULL)
		pt->root = new_node;
	else
		AddNode(new_node, pt->root);
	pt->node_size++;
	return true;
}
Node * InItem(const Item * pi, Tree * pt)
{
	return SeekItem(pi, pt).child;
}
bool DeItem(const Item * pi, Tree * pt)
{
	Pair look;
	look = SeekItem(pi, pt);
	if (look.child == NULL)
		return false;
	if (look.parent == NULL)
		DeNode(&pt->root);
	else if (look.parent->left == look.child)
		DeNode(&look.parent->left);
	else if (look.parent->right == look.child)
		DeNode(&look.parent->right);
	pt->node_size--;
	return true;
}
void traverse(const Tree * pt, void(*pfun)(Item item))
{
	if (pt != NULL)
		InOrder(pt->root, pfun);
}
void DeAll(Tree * pt)
{
	if (pt != NULL)
		DeAllNodes(pt->root);
	pt->node_size = 0;
	pt->root = NULL;
}

static 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;
}
static bool ToLeft(const Item * i1, const Item * i2)
{
	if (strcmp(&i1->word[0], &i2->word[0]) < 0)
		return true;
	else
		return false;
}
static bool ToRight(const Item * i1, const Item * i2)
{
	if (strcmp(&i1->word[0], &i2->word[0]) > 0)
		return true;
	else
		return false;
}
static void AddNode(Node * new_node, Node * root)
{
	if (ToLeft(&new_node->item, &root->item))
	{
		if (root->left == NULL)
			root->left = new_node;
		else
			AddNode(new_node, root->left);
	}
	else
	{
		if (ToRight(&new_node->item, &root->item))
		{
			if (root->right == NULL)
				root->right = new_node;
			else
				AddNode(new_node, root->right);
		}
	}
}
static void InOrder(const Node * root, void(*pfun)(Item item))
{
	if (root != NULL)
	{
		InOrder(root->left, pfun);
		(*pfun)(root->item);
		InOrder(root->right, pfun);
	}
}
static Pair SeekItem(const Item * pi, const Tree * ptree)
{
	Pair look;
	look.parent = NULL;
	look.child = ptree->root;

	if (look.child == NULL)
		return look;
	while (look.child != NULL)
	{
		if (ToLeft(pi, &look.child->item))
		{
			look.parent = look.child;
			look.child = look.child->left;
		}
		else
		{
			if (ToRight(pi, &look.child->item))
			{
				look.parent = look.child;
				look.child = look.child->right;
			}
			else
				break;
		}
	}
	return look;
}
static void DeNode(Node ** ptr)
{	//形参ptr是父节点中用来保存子节点地址的变量，实参让其初始化为父节点的指针域
	//*ptr是子节点本身，也就是要删除的节点。
	//子节点删除后，将*ptr指向新的节点也就更改了父节点的指针域。
	//ptr的值只要不更改，*ptr永远是父节点的指向。
	Node * temp;
	puts((*ptr)->item.word);
	if ((*ptr)->left = NULL)
	{
		temp = *ptr;
		*ptr = (*ptr)->right;
		free(temp);
	}
	else
	{
		if ((*ptr)->right == NULL)
		{
			temp = *ptr;
			*ptr = (*ptr)->left;
			free(temp);
		}
		else
		{
			temp = (*ptr)->left;
			while (temp->right != NULL)
				temp = temp->right;
			temp->right = (*ptr)->right;
			temp = *ptr;
			*ptr = (*ptr)->left;
			free(temp);
		}
	}
}
static void DeAllNodes(Node * root)
{
	Node * temp;
	if (root != NULL)
	{
		/*
		保存右子树指针
		找到左子树为空的节点，释放节点内存
		用保存的右子指针找左子树为空的节点，释放内存
		直到右子树指针为空
		*/
		temp = root->right;
		DeAllNodes(root->left);
		free(root);
		DeAllNodes(temp);
	}

}

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

void menu(void);
int get_ch(char * str);
void printItem(Item item);

int main(void)
{
	FILE * fp;
	Tree tree;
	Item word = { {‘\0‘}, 1 };
	char ch;
	bool n = false;

	InitTree(&tree);
	if ((fp = fopen("f:\\test\\emma.txt", "r")) == NULL)
	{
		fprintf(stderr, "文件打开失败\n");
		exit(EXIT_FAILURE);
	}

	while ((ch=getc(fp)) != EOF)
	{
		int i = 0;
		while (isalpha(ch))
		{
			word.word[i++] = ch;
			ch = getc(fp);
		}
		if (i > 0)
		{
			word.word[i++] = ‘\0‘;
			AddItem(&word, &tree);
		}
		//putchar(‘a‘);
	}
	putchar(‘\n‘);
	fclose(fp);
	menu();
	while ((ch = get_ch("abq")) != ‘q‘)
	{
		if (ch == ‘a‘)
		{
			puts("包含的单词\t\t单词出现的次数");
			traverse(&tree, printItem);
		}
		if (ch == ‘b‘)
		{
			puts("请输入要查找的单词：");
			scanf("%s", word.word);
			while (getchar() != ‘\n‘)
				;
			if (InItem(&word, &tree))
			{
				printf("单词%s在文件中出现%d次\n",
					word.word, InItem(&word, &tree)->item.word_size);
			}
			else
				printf("文件中没有找到单词%s\n", word.word);

		}
		printf("\n");
		menu();
	}
}

void menu(void)
{
	puts("请输入选项：");
	puts("a)列出所有的单词连同其出现的次数");
	puts("b)输入一个单词，程序报告该单词在文件中出现的次数");
	puts("q)退出程序");
}
int get_ch(char * str)
{
	int ch;

	ch = getchar();
	while (getchar() != ‘\n‘)
		;
	while (strchr(str, ch) == NULL)
	{

		printf("请输入正确的选项%s:", str);
		ch = getchar();
		while (getchar() != ‘\n‘)
			;
	}

	return ch;
}
void printItem(Item item)
{
	printf("%10s\t\t%14d\n", item.word, item.word_size);
}

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

// tree.h -- 二叉搜索树接口
#ifndef _TREE_H
#define _TREE_H
#include <stdbool.h>
#define TREEMAX 20

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

typedef struct node_list
{
	Item item;
	struct node_list * next;
}List;
typedef struct node_tree
{
	List * list;				//同名宠物的项目列表
	int list_size;			//列表中项目个数
	struct node_tree * left;		//指向左分支的指针
	struct node_tree * right;	//指向右分支的指针
}Node;

typedef struct tree
{
	Node * root;	//指向树根的指针
	int size;		//树中项目的个数
}Tree;

void InitTree(Tree * ptree);
bool TreeIsEmpty(const Tree * ptree);
bool TreeIsFull(const Tree * ptree);
int TreeItemCount(const Tree * ptree);
bool InTree(const Item * pi, const Tree * ptree);
bool AddTreeItem(const Item * pi, Tree * ptree);
bool DeleteItem(const Item * pi, Tree * ptree);
void Traverse(const Tree * ptree, void(*pfun)(List * list));
void DeleteAll(Tree * ptree);

#endif

//tree.c -- 接口函数定义
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "tree.h"

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

//局部函数声明
static bool AddListItem(const Item * pi, Node * root);
static List * MakeListNode(const Item * pi);
static Node * MakeTreeNode(const Item * pi);
static void AddTreeNode(Node * new_node, Node * root);
static Pair SeekItem(const Item * pi, const Tree * ptree);
static bool ToLeft(const Item * i1, const Item * i2);
static bool ToRight(const Item * i1, const Item * i2);
static bool SeekListItem(const Item * pi, List * pl);
static void DeNode(const Item * pi, Node ** ptr);
static List * DeListNode(const Item * pi, List * pl);
static void InOrder(const Node * root, void(*pfun)(List * list));
static void DeleteAllNodes(Node * root);
static void DeList(List * list);
static void DeleteAllList(Node * root);

//局部函数定义
static bool AddListItem(const Item * pi, Node * root)
{	//OK
	List * new_listnode, *temp = root->list;
	new_listnode = MakeListNode(pi);
	if (new_listnode == NULL)
	{
		fprintf(stderr, "新的成员生成失败\n");
		return false;
	}
	while (NULL != temp->next)
		temp = temp->next;
	temp->next = new_listnode;
	root->list_size++;
	return true;
}
static List * MakeListNode(const Item* pi)
{	//OK
	List * new_list;
	new_list = (List *)malloc(sizeof(List));
	if (new_list != NULL)
	{
		new_list->item = *pi;
		new_list->next = NULL;
	}
	return new_list;
}
static Node * MakeTreeNode(const Item * pi)
{	//OK
	Node * new_node;
	List * new_list_node;

	new_list_node = MakeListNode(pi);
	if (new_list_node == NULL)
		return NULL;
	new_node = (Node *)malloc(sizeof(Node));
	if (new_node != NULL)
	{
		new_node->list = new_list_node;
		new_node->list_size = 1;
		new_node->left = NULL;
		new_node->right = NULL;
	}
	return new_node;
}
static void AddTreeNode(Node * new_node, Node * root)
{	//OK
	if (ToLeft(&new_node->list->item, &root->list->item))
	{
		if (NULL == root->left)
			root->left = new_node;
	}
	else if (ToRight(&new_node->list->item, &root->list->item))
	{
		if (NULL == root->right)
			root->right = new_node;
	}

}
static bool ToLeft(const Item * i1, const Item * i2)
{	//OK
	if (strcmp(i1->petname, i2->petname) < 0)
		return true;
	return false;
}
static bool ToRight(const Item * i1, const Item * i2)
{	//OK
	if (strcmp(i1->petname, i2->petname) > 0)
		return true;
	return false;
}
static bool SeekListItem(const Item * pi, List * pl)
{	//OK
	List * temp = pl;
	while (NULL != temp)
	{
		if (strcmp(pi->petkind, temp->item.petkind) == 0)
			return true;
		temp = temp->next;
	}

	return false;
}
static Pair SeekItem(const Item * pi, const Tree * ptree)
{	//OK
	Pair look;
	look.parent = NULL;
	look.child = ptree->root;

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

	}
	return look;
}
static void DeNode(const Item * pi, Node ** ptr)
{	//OK
	Node * temp;
	if (1 == (*ptr)->list_size)
	{	//列表内只有一个项目，删整个节点
		if (NULL == (*ptr)->left)
		{
			temp = *ptr;
			*ptr = (*ptr)->right;
			free(temp);
		}
		else if (NULL == (*ptr)->right)
		{
			temp = *ptr;
			*ptr = (*ptr)->left;
			free(temp);
		}
		else
		{
			temp = (*ptr)->left;
			while (NULL != temp->right)
				temp = temp->right;
			temp->right = (*ptr)->right;
			temp = *ptr;
			*ptr = (*ptr)->left;
			free(temp);
		}
	}
	else if ((*ptr)->list_size > 1)
	{	//列表内有多个项目，删列表中的一个项目
		(*ptr)->list = DeListNode(pi, (*ptr)->list);
		(*ptr)->list_size--;
	}
}
static List * DeListNode(const Item * pi, List * pl)
{	//OK
	List * phead = pl;	//保存链表头指针
	List * temp;
	if (strcmp(pi->petkind, phead->item.petkind) == 0)
	{
		phead = pl->next;
		free(pl);
	}
	else
	{
		do
		{
			temp = pl;
			pl = pl->next;
		} while (strcmp(pi->petkind, pl->item.petkind) != 0);

		temp->next = pl->next;
		free(pl);
	}
	return phead;
}
static void InOrder(const Node * root, void(*pfun)(List * list))
{	//OK
	if (root != NULL)
	{
		InOrder(root->left, pfun);
		(*pfun)(root->list);
		InOrder(root->right, pfun);
	}
}
static void DeleteAllNodes(Node * root)
{
	Node * temp = root;

	if (root != NULL)
	{
		temp = root->right;
		DeleteAllNodes(root->left);
		DeList(root->list);
		free(root);
		DeleteAllNodes(temp);
	}
}
static void DeList(List * list)
{
	List * temp;

	while (list != NULL)
	{
		temp = list;
		list = list->next;
		free(temp);
	}

}

//全局函数定义
void InitTree(Tree * ptree)
{	//OK
	ptree->root = NULL;
	ptree->size = 0;
}
bool TreeIsEmpty(const Tree * ptree)
{	//OK
	return ptree->root == NULL;
}
bool TreeIsFull(const Tree * ptree)
{	//OK
	return ptree->size >= TREEMAX;
}
int TreeItemCount(const Tree * ptree)
{	//OK
	return ptree->size;
}
bool InTree(const Item * pi, const Tree * ptree)
{
	Pair look = SeekItem(pi, ptree);
	return look.child != NULL && SeekListItem(pi, look.child->list);
}
bool AddTreeItem(const Item * pi, Tree * ptree)
{	//OK
	Node * new_node;
	Pair seek;

	if (TreeIsFull(ptree))
	{
		fprintf(stderr, "Tree is ull\n");
		return false;
	}
	seek = SeekItem(pi, ptree);
	if (seek.child != NULL)
	{
		if (AddListItem(pi, seek.child));
		return true;
		return false;
	}
	new_node = MakeTreeNode(pi);
	if (new_node == NULL)
	{
		fprintf(stderr, "Couldn‘t create node\n");
		return false;
	}
	if (ptree->root == NULL)
		ptree->root = new_node;
	else
		AddTreeNode(new_node, ptree->root);
	ptree->size++;

	return true;
}
bool DeleteItem(const Item * pi, Tree * ptree)
{	//OK
	Pair look;
	look = SeekItem(pi, ptree);
	int i = TreeItemCount(ptree);
	if (NULL == look.child)
		return false;	//是否找到同名项
	if (!SeekListItem(pi, look.child->list))
		return false;	//是否找到同类项
	DeNode(pi, &look.child);
	int j = TreeItemCount(ptree);
	if (i == j)
		ptree->size--;
	if (ptree->size == 0)
		ptree->root = NULL;

	return true;
}
void Traverse(const Tree * ptree, void(*pfun)(List * list))
{	//OK
	if (ptree->root != NULL)
		InOrder(ptree->root, pfun);
}
void DeleteAll(Tree * ptree)
{
	if (ptree->root != NULL)
		DeleteAllNodes(ptree->root);
	ptree->size = 0;
}

//test_tree.c -- 测试二叉搜索树
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include "tree.h"

char menu(void);					//显示菜单，判定用用户输入
void addpet(Tree * pt);				//添加内容
void droppet(Tree * pt);			//删除项目
void showpets(const Tree * pt);		//显示整个树
void findpet(const Tree * pt);		//搜索某个项目是否在树中
void printitem(List * list);			//打印项目内容
void uppercase(char * str);			//转换大写
int ListItemCount(Node * root);

int main(void)
{
	Tree pets;		//定义树变量
	char choice;
	int conut=0, temp=0;

	InitTree(&pets);
	while ((choice = menu()) != ‘q‘)
	{
		switch (choice)
		{
		case ‘a‘: addpet(&pets);
			break;
		case ‘l‘: showpets(&pets);
			break;
		case ‘f‘: findpet(&pets);
			break;
		case ‘n‘: 
			conut = ListItemCount(pets.root);
			conut -= temp;
			temp += conut;
			printf("%d pets in club\n", conut);
			break;
		case ‘d‘: droppet(&pets);
			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 per		l)show list of pets");
	puts("n)number of pets	f)find pets");
	puts("d)delete apet		q)quit");
	while ((ch = getchar()) != EOF)
	{
		while (getchar() != ‘\n‘)	//丢弃输入行的剩余部分
			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)		//令EOF导致程序退出
		ch = ‘q‘;

	return ch;
}

void addpet(Tree * pt)
{
	Item temp;

	if (TreeIsFull(pt))		//树已满
		puts("No room in the club!");	//提示无空间
	else
	{	//
		puts("Please enter name of pet: ");
		gets(temp.petname);
		puts("Please enter pet kind: ");
		gets(temp.petkind);
		uppercase(temp.petname);
		uppercase(temp.petkind);
		AddTreeItem(&temp, pt);
	}
}

void showpets(const Tree * pt)
{
	if (TreeIsEmpty(pt))
		puts("No enteries!");
	else
		Traverse(pt, printitem);
}

void printitem(List * list)
{
	while (list != NULL)
	{
		printf("pet: %-19s kind: %-19s\n", list->item.petname,
			list->item.petkind);
		list = list->next;
	}
}

void findpet(const Tree * pt)
{
	Item temp;

	if (TreeIsEmpty(pt))
	{
		puts("No entries!");
		return;
	}

	puts("Please enter name of pet you wish to find: ");
	gets(temp.petname);
	puts("Please enter pet kind: ");
	gets(temp.petkind);
	uppercase(temp.petname);
	uppercase(temp.petkind);
	printf("%s the %s ", temp.petkind, temp.petname);
	if (InTree(&temp, pt))
		printf("is a member.\n");
	else
		printf("is not a member .\n");
}

void droppet(Tree * pt)
{
	Item temp;

	if (TreeIsEmpty(pt))
	{
		puts("No entries!");
		return;
	}
	puts("Please enter name of pet you wish to delete: ");
	gets(temp.petname);
	puts("Please enter pet dind: ");
	gets(temp.petkind);
	uppercase(temp.petname);
	uppercase(temp.petkind);
	printf("%s the %s ", temp.petname, temp.petkind);

	if (DeleteItem(&temp, pt))
		printf("is dropped from the club.\n");
	else
		printf("is not a member.\n");
}

void uppercase(char * str)
{
	while (*str)
	{
		*str = toupper(*str);
		str++;
	}
}

int ListItemCount(Node * root)
{
	static int conut = 0;

	if (root != NULL)
	{
		ListItemCount(root->left);
		conut += root->list_size;
		ListItemCount(root->right);
	}

	return conut;
}