数据结构课程设计-图书管理系统

用C++语言实现图书管理系统
摘要图书管理系统主要是对图书的录入、读者借阅、读者归还等功能进行
实现.本课程设计的系统开发平台为Windows XP，程序设计语言为C++，程序运行平台为Windws98/2000/XP/Seven。

在程序设计中采用了B-树方法提高书籍的查找速度。

关键词程序设计;图书管理系统；C++;数据结构;B-树
1 索引
1.1课程设计目的
设计一个小型的图书管理系统，可以实现新增图书,读者借阅,读者归还等功能。

1。

2。

系统性能要求
能较快的查到所要查找的图书；能准确统计当前每种书的库存,以确定此书是否可以外借;并且对外借的图书进行管理，记录借出时间、应还时间等。

1.3。

功能的实现
1）新书入库:确定书号后，登记到图书帐目表中，如果表中已有，则只将库存量增加；
2) 借阅：如果一种书的现存量大于0，则借出一本，登记借阅者的书证号和归还期限，改变现存量;
3）归还：注销对借阅者的登记，改变该书的现存量.
2 系统详细设计及实现
1.所用的知识体系
在整个程序的设计过程当中，用到了C++的一些基础知识，面向对象的思想和结构化的程序设计思想.数据结构的B—树建立索引，用索引提高查找的效率等。

2。

系统功能组成框图
3 . 系统功能模块划分
4。

流程图 4。

1录入图书信息
4.2借阅图书
4。

3归还图书
输入图书和读者信息
处理归还图书功能，清读
者的借阅记录，将图书的
在库数加一
5 功能实现
5．1 运行程序的主界面
图5—1 操作界面
5。

2 新书入库功能的操作界面
图5—2新书入库5.3 查询数据的界面
图5-3查询书籍
5。

4 查询所有书籍的界面
图 5—4显示库存5.5 图书借阅的界面
图5-5借阅书籍
5。

6 还书的界面
图5—6还书
3 参考文献
[1］谭浩强C语言设计(第三版)清华大学出版社
［2] 严蔚敏吴伟民数据结构（C语言版）清华大学出版社
[3] 谭浩强 C++ 程序设计清华大学出版社
［4］参考网址/manual/zh/function。

fopen。

php [5]参考网址/%B3％D5％B3％D5％
B5%C4145/blog/item/48f2b1ed1d99d1d2b21cb15c。

html
附录
＃include〈stdio。

h〉
＃include<stdlib。

h>
#include<string。

h>
#include〈conio.h〉
＃include〈time。

h>
//定义局变量
＃define N10000
//表示状态的字段
#define TRUE1
＃define FALSE0
#define OK1
#define ERROR0
＃define INFEASIBLE -1
#define OVERFLOW -2
typedef int Status；
typedef char＊string；
＃define m3//B—树的阶，设为
// 借阅者的结构体
typedef struct User{
unsigned int number; //借书证号码
int year;
int month;
int day; //借书时间
int dyear；//截至日期的年
int dmonth; //截至日期的月
int dday；//截至日期的日
struct User *next; //下一个借阅者
}User; //定义用户的的信息
//书的结构体
struct Book{
unsigned int key; //图书的书号
char bname[20］；// 书名
char writter［20］; // 著者
unsigned int left；// 现存量
unsigned int total; // 总存量
User *user；//借阅该书的人｝b［N]; //定义书的信息
//B—树的存储结构
typedef Book KeyType；
typedef struct BTNode{
int keynum; //结点中关键字个数,即结点的大小
struct BTNode *parent; //指向双亲结点
KeyType key［m + 1］; //关键字向量,号单元未用struct BTNode＊ptr［m + 1]; //子树指针向量}BTNode,＊BTree；
//查找结果的存储结构体
typedef struct{
BTNode *pt；//指向找到的结点
int i; //1……m，在结点中的关键字序号
int tag; //B—树的查找结果类型
｝Result；
BTree root = NULL; //树根
//*＊*＊＊*＊＊**＊*＊**＊**函数声明部分
//输入书的具体信息
void InBookMess（KeyType＆book）；
//输入书的关键字
void InBookKey(KeyType &book)；
//显示书的具体信息,如果书存在就显示
void ShowBookMess(Book book)；
//显示一个结点中所包含的全部信息,显示单个结点
void ShowBTNode（BTree p)；
//显示，以层次的方法显示树的结点
void display(BTree T);
//复制关键字的信息
void KeyTypeCopy(KeyType＆bak，KeyType k)；
//查找在某个结点中的位置
int Search(BTree p，KeyType K）;
//查找
Result SearchBTree(BTree T，KeyType K);
//插入
void Insert（BTree＆q, int i, KeyType x, BTree ap);
//分裂结点
void split(BTree &q, int s, BTree＆ap）；
//生成一个新的结点
void NewRoot(BTree &T, BTree p, KeyType x, BTree ap);
//将书的信息插入到B- 树中
Status InsertBTree（BTree＆T，KeyType K);
//删除树结点
Status DeleteBT(BTree＆T，KeyType k）；
//与右最左结点交换
void exchange(BTree＆T，int i)；
//用户借阅
Status BorrowBook（BTree T,KeyType k）;
//注销对借阅者的登记，改变该书的显存量
Status ReturnBook（BTree T，KeyType k）;
void temp(BTree T）；
void save（BTree p）;
/＊***＊＊**＊*＊＊*＊**＊＊*＊＊*＊*＊**＊＊＊**＊＊******＊*＊**＊＊*＊/ void save（BTree p）//保存模块程序
{
FILE *fp；//定义文件指针
if(（fp=fopen(”book。

txt”，"wb”)）==NULL)//判断文件的存在,若非空，将fp 指向filename中记载的文件名的文件
{
printf("创建文件失败！\n\n”）；//打印出错提示
getchar（）；
return;
}
for（int i = 1; i〈= p—>keynum；i++）｛
fprintf（fp,"％d ％s %s %d %d \n”,p—〉key［
i］.key,p->key[i］.bname,p—>key［i］.writter，p->key［i].left,p-〉key［i］.total);
｝
fclose（fp);//关闭文件
}
void temp(BTree T）
{
int i;
if(T）｛
save(T); //保存这个结点的全部值
for（i=0；i<=T—>keynum；i++){ //使用递归的方法显示每个结点
if(T-〉ptr[i］){
temp（T—>ptr［i］）；
}
}
｝
}
//读取文件
void read()
{
FILE＊fp,fp1;//定义文件指针
if（(fp=fopen（”book。

txt”,"rb”））==NULL&& （fp=fopen(”user。

txt”，"rb”)）==NULL)//判断文件的存在，若非空，将fp指向filename中记载的文件名的文件{
printf（”创建文件失败!\n\n”)；//打印出错提示
getchar(）；
return;
}
for（int i=1;；i++）//读取文件
｛
if（fscanf(fp，"%d％s％s%d%d”,＆b［i]。

key,＆b［i].bname,&b［
i].writter，&b［i］。

left,＆b［i]。

total)==EOF)
｛break；}
InsertBTree（root，b[i］);
｝
fclose(fp);//关闭文件
}
/＊＊**＊＊＊**＊*＊*＊＊＊＊***＊＊＊*******＊**＊＊＊***＊****＊*＊＊***＊**＊*＊*/
//复制结点，将某个结点的值复制到另外一个值上
void KeyTypeCopy(KeyType＆bak，KeyType k）｛
bak。

key = k。

key；
strcpy(bak.bname，k。

bname）；
bak。

left = k。

left；
bak.total = k.total;
strcpy（bak。

writter，k。

writter);
bak。

user = er；
｝
//在一个结点中查找元素，返回结点的位置
int Search（BTree p, KeyType K） {
if(！p)
return—1;
int i=0；
for(i = 0; i〈p-〉keynum &＆p-〉key［i+1].key〈= K.key；i++）;
return i;
｝
// 在m阶B树T上查找关键字K,返回结果（pt,i，tag）
Result SearchBTree（BTree T，KeyType K){
BTree p, q；
int found, i；
Result R;
//初始化变量
p = T;
q = NULL；
found = FALSE;
i = 0；
// 初始化,p指向待查结点，q指向p的双亲
while (p＆＆ !found) {
i = Search（p, K)；
// 找到待查关键字
if（i〉0 &＆p—〉key[i].key == K.key）
found = TRUE；
else {
q = p；
p = p—>ptr［i］；//在另一个分支上查找
}
｝
if（found） { // 查找成功
R。

pt = p；
R.i = i；
R。

tag = 1；
｝
else { // 查找不成功
R。

pt = q；
R.i = i;
R。

tag = 0;
}
// 返回结果信息： K的位置（或插入位置)
return R；
}
//插入一条记录
void Insert（BTree &q, int i，KeyType x, BTree ap) ｛int n = q—〉keynum；
for (int j = n; j〉i；j——） {
KeyTypeCopy(q—>key[j + 1］,q-〉key[j])；//复制结点值
q->ptr［j + 1］ = q->ptr［j]；
}
KeyTypeCopy(q—〉key［i + 1]，x）;
q->ptr[i + 1］ = ap;
if (ap）
ap—〉parent = q;
q—>keynum++;
｝
//分离结点
void split（BTree＆q, int s，BTree &ap）｛
int i,j，n = q->keynum；
ap = (BTree）malloc(sizeof（BTNode))；
ap—>ptr[0] = q-〉ptr[s］；
for（i = s + 1,j = 1; i <= n；i++，j++) {
KeyTypeCopy（ap—>key［j］，q->key[i])；
ap—〉ptr[j] = q-〉ptr［i];
}
ap—>keynum = n—s;
ap—〉parent = q—〉parent;
for（i = 0; i〈= n - s；i++）
if（ap-〉ptr[i])
ap—〉ptr[i］->parent = ap；
q—〉keynum = s—1；
｝
//生成一个新的树结点
void NewRoot（BTree &T, BTree p, KeyType x，BTree ap） {
T = (BTree）malloc（sizeof(BTNode））;
T->keynum = 1; //设置当前结点的元素个数
T—〉ptr[0] = p；//设置左边结点的树根
T->ptr[1] = ap; //设置右边的树根
KeyTypeCopy(T->key[1],x)；//将x 元素的结点值复制到T 的第一个元素中//当孩子不空的时候就设置当前结点为孩子的双亲
if (p)
p—>parent= T;
if（ap)
ap->parent = T；
T-〉parent = NULL; //当前结点的双亲为空
｝
//返回false 表示在原有结点上增加数量，返回true 表示创建了一个新的结点Status InsertBTree（BTree＆T，KeyType K） {
// 在m阶B树T上结点＊q的key［i]与key［i+1］之间插入关键字K。

// 若引起结点过大，则沿双亲链进行必要的结点分裂调整，使T仍是m阶B树。

BTree ap；
Result rs;
BTree q；
int i;
char addnum;
int finished，needNewRoot，s；
// T是空树(参数q初值为NULL)
KeyType x；
//如果T 结点为空就生成一个新的结点
if (!T){
NewRoot（T，NULL，K, NULL)；
｝
else｛
//查找元素k 在树中的位置
q = rs.pt; //查找到包含元素k 的结点
i = rs.i；//元素k 在树中的位置
if(rs。

tag == 1)｛//判断该元素在树中是否存在
if(strcmp(q->key［i］。

bname,K。

bname) ！= 0)｛
printf("\n\t录入失败，原因:\n"）;
printf（".\t书号冲突，请重新为该书编号！\n\n”)；
printf(”\t已经存在书号为%d 的书为：\n"，q—>key[i］。

key）;
ShowBookMess（q—>key［i］）;
return FALSE；
｝
else
｛
printf("\n\t该书已经存在！\n\n"）；
printf（"\t是否增加其总量（y/n)：”）;
scanf（"%s”，＆addnum)；
if(addnum == 'Y’ || addnum == 'y’）｛
q-〉key[i］。

total += K。

total；//将总量增加
q-〉key[i］.left += K。

left; //将剩余量增加
printf(”\n\t增加总量后该书的信息如下\n”）;
// ShowBookMess(q->key［i]);
}
else｛
printf（"\n\t该书的信息如下:\n"）;
// ShowBookMess(q-〉key［i］);
}
ShowBookMess(q-〉key［i]）；
return FALSE;
｝
} //if
x = K；
ap = NULL;
finished = needNewRoot = FALSE;
while（!needNewRoot＆& ！finished) ｛
Insert（q, i，x，ap)；//插入结点
if（q->keynum〈m）
finished = TRUE; // 插入完成
else { // 分裂结点*q
s = （m+1）/2；
split（q, s, ap)；
x = q—〉key[s］；
if（q->parent) ｛// 在双亲结点*q中查找x的插入位置
q = q->parent;
｝
else
needNewRoot = TRUE；
} // else
｝// while
if (needNewRoot) // 根结点已分裂为结点*q和＊ap
NewRoot（T, q, x，ap）; // 生成新根结点*T,q和ap为子树指针
}
return OK；
}
//一个结点在双亲中的位置,返回其位置i
int position(BTree T）｛
if(！T）｛
return0；
｝
int i = 0；
if(T->parent）｛
while（i <= T->parent->keynum）｛
if(T == T->parent->ptr[i]）
return i; //返回当前的位置
i++；
｝
}
return—1；
｝
//调整树的结构
Status fix（BTree &root，BTree p)｛
int i = position（p）；//取得p 在双亲中的位置
int mid = （m + 1)/2 - 1；//要交换的临界点
BTree temp = NULL;
int k;
if（i〉0 && root-〉ptr［i—1]—〉keynum〉mid）{ //当i 大于零的时候就可以向左借
temp = root—>ptr[i - 1］；//比自己小的兄弟结点
p->keynum++; //增加一个结点
for(k = p-〉keynum；k > 1;k--){
KeyTypeCopy(p-〉key[k］,p-〉key［k—1])；//将前面的结点后移一位
｝
if(p—〉ptr[0］){
for（k = p-〉keynum;k >= 1；k——）{
p—〉ptr［k] = p->ptr[k - 1]; //将要移动的结点的子结点向后移动｝
｝
KeyTypeCopy（p—〉key［1],root->key[i］）; //将双亲的结点复制到根
KeyTypeCopy（root->key[i]，temp-〉key[temp—>keynum]）; //将小兄弟结点的最大的那个移动到双亲中
if(temp—>ptr[temp->keynum]）{ //将兄弟结点的子结点也复制过来p—>ptr[0］ = temp->ptr[temp—〉keynum];
temp—〉ptr［temp-〉keynum］-〉parent = p; //修改指向双亲的结点
temp-〉ptr[temp—>keynum] = NULL；
}
temp—>keynum--；//将左兄弟删除一个结点
return OK;
}
if（i < root—>keynum && root->ptr[i + 1]—>keynum > mid)｛//当i 小于最大数量的时候就可以向右借
temp = root-〉ptr[i + 1]；
p—>keynum++；//增加结点的个数
KeyTypeCopy（p—>key［p—〉keynum]，root->key[i + 1］)；//将根结点的值复制过来
KeyTypeCopy（root—〉key[i+ 1］,temp—>key[1])；//将右兄弟的结点复制过来
for(k = 1；k < temp—>keynum；k++）｛
KeyTypeCopy(temp—〉key[k]，temp—〉key［k + 1]）; //将后面的结点向前移动一位
}
if（temp—〉ptr[0］）{
p—〉ptr［p—〉keynum］ = temp->ptr[0］；
temp->ptr[0］—>parent = p; //修改指向双亲的结点
for（k = 0；k〈temp—>keynum；k++）｛//将子结点向前移动
temp—>ptr[k] = temp—〉ptr[k + 1］;
｝
temp->ptr［k + 1］ = NULL; //将删除的结点的子结点置为空}
temp-〉keynum-—; //将右兄弟删除一个结点
return OK;
｝
return FALSE；
}
//合并结点
Status combine(BTree &root，BTree &p）{
int k,i = position(p）; //取得p 在双亲中的位置
int mid = (m + 1)/2 - 1；//交换的条件
BTree p2；
if（i == 0）｛//如果是第一个位置
i = 1；
p2 = root—〉ptr[i］;
p—〉keynum++; //增加一个结点
KeyTypeCopy(p->key[p—>keynum],root->key［i]）；//将双亲的结点复制下来
if(p2—>ptr［0］)｛
p-〉ptr[p->keynum］ = p2—〉ptr[0]; //将兄弟的子结点也复制过来
p2—〉ptr[0］—>parent = p；//修改双亲
}
for(k = i；k < root—〉keynum;k++）｛//将双亲的结点向前移动一位KeyTypeCopy（root->key[k]，root->key［k + 1］)；
}
p->keynum++;
p—〉key[p—〉keynum] = p2—>key[1］；
if(p2—>ptr［1]）｛
p—〉ptr[p—>keynum] = p2->ptr[1]; //将兄弟的子结点也复制过来
p2-〉ptr［1］—〉parent = p; //修改指向双亲的结点
}
root—>keynum-—;
free(p2）;
p2 = NULL；
for（k = 1;k <= root—〉keynum；k++){
root—〉ptr［k］ = root->ptr［k + 1]; //将双亲结点子结点向前移动｝
root—>ptr[k + 1］ = NULL;
｝
else if(i〉0）｛
p2 = root—〉ptr[i - 1];
p2—〉keynum++；
KeyTypeCopy(p2->key[p2-〉keynum],root->key[i]); //复制根结点的值到子结点中
if(p-〉ptr［0］){
p2->ptr[p2—〉keynum] = p—〉ptr［0]；
p-〉ptr［0］->parent = p2; //修改指向双亲的结点
｝
for（k = i；k〈root-〉keynum；k++）｛
KeyTypeCopy(root—>key［k］，root-〉key［k+ 1］）；//将结点前移
root—〉ptr[k］ = root—>ptr[k + 1]；//将子结点前移
}
root->ptr［k + 1］ = NULL；
root—>keynum--；
free（p）；
p = p2；
｝
return OK;
}
//与右最左结点交换
void exchange（BTree &T，int i)｛
BTree p = T；
User＊user = NULL；
if（p->ptr[i］）{
p = p-〉ptr[i］;
while（p-〉ptr［0］）{
p = p->ptr[0];
｝
while(T-〉key［i］.user){
user = T-〉key[i］.user; //指向要释放的结点
T-〉key［i］。

user = T-〉key［i］。

user-〉next; //指向下一个结点
free(user）；//释放借阅者的信息
｝
KeyTypeCopy（T—〉key[i],p-〉key[1]); //交换数据
}
while(i < p->keynum）{ //将该结点后面的数据后移
KeyTypeCopy(p—〉key［i],p-〉key［i + 1]）；//将后一个数据复制到前一个数据
i++；
}
p—>keynum--; //删除结点
T = p;
return；
｝
/*＊**＊＊*＊＊*＊＊＊*＊＊**＊**＊**＊＊**＊＊**＊***＊**＊****＊＊＊***＊＊＊**＊＊＊***/
//输入书的具体信息
void InBookMess(KeyType &book）{
char s[5］；
printf("\t请输入书号（编号最多为位数且不大于)：");
do｛
scanf(”％s",s）；
book.key = atoi（s）;
if（book.key < 1 || book。

key > 65535）｛
printf（"\t输入有误,请重新输入：”）;
｝
｝while(book。

key < 1 || book。

key〉65535);
printf("\t请输入书名:"）;
scanf（”％s”,&book。

bname）；
printf(”\t请输入作者：")；
scanf（"%s”，＆book.writter);
printf（"\t请输入总量(不能大于）:"）;
do｛
scanf（”％s"，s）；
book.total = atoi(s）；
if(book.total〈1 || book。

total > 65535){ printf("\t输入有误,请重新输入：”）;
｝
}while(book。

total < 1｜| book.total > 65535）;
book.left = book。

total;
book。

user = NULL；
//er = （User ＊）malloc(sizeof(User）)；｝
//输入书的关键字
void InBookKey(KeyType＆book）{
char s［5］;
printf("\t请输入书号："）;
do｛
scanf("%s”，s）;
book.key = atoi(s);
if（book.key〈1 |｜book.key > 65535)｛
printf(”\t输入有误，请重新输入:");
}
}while(book。

key < 1 |｜book。

key〉65535)；
book.bname［0] = ’\0’;
book。

writter[0] = '\0’;
book。

total = 0;
book.left = 0;
｝
//显示书的具体信息
void ShowBookMess（Book book)｛
User＊temp；
printf（"\t书号为：％3d\n”，book.key)；
printf("\t书名为:%3s\n”，book。

bname）;
printf（"\t作者为：%3s\n", book。

writter);
printf（"\t剩余量为：%3d\n"，book。

left）；
printf（”\t总量为：%3d\n”，book。

total);
printf(”\t—----————-—- 已借该书的人有—-—-—----——-\n");
temp = er；
while（temp){
printf(”\t图书证号:％d\t借书日期：％d年%d月％d日\t归还日期:％d年％d月%d日\n”,temp-〉number，temp->year，temp—〉month,temp->day，temp-〉dyear,temp->dmonth,temp->dday）；
temp = temp—>next；
}
printf("\n")；
}
//显示某个结点的信息
void ShowBTNode（BTree p）｛
for(int i = 1；i〈= p->keynum; i++){
printf（"\t”）；
printf("书号为:％d "，p—>key［i］。

key);
printf（"书名为：％5s "，p—〉key［i］.bname）；
printf（”作者为：%5s "，p—〉key［i］.writter)；
printf（"剩余量为:％5d "，p->key[i]。

left);
printf("总量为:%5d”，p->key[i］.total）；
printf（"\n”）;
｝
}
//显示整棵树的信息
void display（BTree T）{
int i = 0;
if(T) {
ShowBTNode(T）；//显示这个结点的全部值
for（i=0; i〈=T->keynum；i++）｛//使用递归的方法显示每个结点if(T->ptr［i］）{
display（T->ptr［i］）；
}
}
｝
}
/*＊*＊*＊＊*＊＊*＊*＊***＊*＊＊＊＊****＊**＊**＊＊**＊＊＊***＊＊*＊****＊＊***＊＊＊**＊＊＊**＊*＊＊**＊＊＊＊＊/
/＊用户借阅说明
＊借阅登记的信息可以链接在相应的那种书的记录之后
*/
//输入借阅的信息
Status InUserMess（User *user）{
char s［5]；
time_t nowtime；
struct tm＊timeinfo；
time( ＆nowtime )；
timeinfo = localtime（＆nowtime）；
printf(”\n\t输入借阅者的信息\n”)；
printf(”\t请输入图书证号:”)；
do{
scanf(”％s"，s）；
user—〉number = atoi(s）;
if（user—>number〈1｜| user—〉number > 65535){
printf（"\t输入有误，请重新输入（0到之间):”)；
｝
}while(user->number < 1 |｜user-〉number〉65535);
printf（"\t请输入归还日期（格式:％d年%d月％d日)\n”，timeinfo—>tm_year + 1900,timeinfo—>tm_mon + 1,timeinfo—>tm_mday);
//归还日期的输入
printf（”\t年:”);
do{
scanf(”％s”，s）;
user->dyear = atoi（s);
if(user—〉dyear〈timeinfo->tm_year + 1900){
printf（"\t输入有误,请重新输入（大于%d）:”，timeinfo-〉tm_year + 1900）；
}
｝while（user-〉dyear < timeinfo-〉tm_year + 1900）；
printf（”\t月:")；
do｛
scanf（”％s"，s）；
user—>dmonth = atoi（s);
if(user->dmonth > 12 |｜user-〉dmonth < 1｜｜（user-〉dmonth <
timeinfo—>tm_mon + 1 && user—〉dyear == timeinfo->tm_year + 1900）){ printf（”\t输入有误，请重新输入（1到月）:"）;
}
｝while（user-〉dmonth > 12 |｜user—〉dmonth〈1 |｜（user->dmonth 〈timeinfo—〉tm_mon+ 1&＆user-〉dyear== timeinfo—〉tm_year+ 1900））；
printf（"\t日：”）;
do｛
scanf（”%s”，s);
user->dday = atoi(s);
if（user-〉dday〉31 || user->dday〈1｜｜ (user-〉dday
〈timeinfo->tm_mday＆& user—>dyear== timeinfo-〉tm_year+ 1900&& user—〉dmonth == timeinfo-〉tm_mon + 1)){
printf（"\t输入有误,请重新输入（1到日）：”)；
}
｝while(user—〉dday> 31|| user—>dday< 1|| （user-〉dday〈timeinfo—〉tm_mday && user—>dyear == timeinfo->tm_year + 1900＆＆user—〉dmonth == timeinfo-〉tm_mon + 1));
//设置借书的时间
user—〉year = timeinfo—>tm_year + 1900;
user—〉month = timeinfo->tm_mon + 1；
user-〉day = timeinfo-〉tm_mday;
user—>next = NULL；
return OK;
｝
//借阅，如果一种书的显存量大于零,则借出一本，登记借阅着的图书证号和归还期限
Status BorrowBook(BTree T,KeyType k){
Result rs = SearchBTree（T,k）；
User *user;
if（rs.tag == 0）{
printf(”\t很抱歉!你要借阅的书不存在!\n");
return FALSE；
｝
if（rs.pt—〉key[rs。

i]。

left〈1）｛
printf（"\t很抱歉！你要借阅的书已经借完!\n"）；
return FALSE；
｝
user = （User＊）malloc（sizeof（User））；
InUserMess（user);
//查找该用户是否已经借过这本书
User *temp；
temp = rs。

pt—>key［rs。

i］.user；
while（temp）{
if（temp->number == user—>number）{
printf("\n\t你已经借了这本书，不能够重复借!\n”);
free（user）;
return FALSE；
}
temp = temp-〉next；
｝
rs.pt—〉key［rs。

i].left--;
user-〉next = rs.pt->key［rs.i］。

user;
rs.pt-〉key[rs。

i］.user = user;
return OK;
}
//还书,改变该书的库存量
Status ReturnBook（BTree T,KeyType k){
User *user，＊pre；
int number;
Result rs = SearchBTree(T,k）;
if（rs。

tag == 0)｛
printf(”\t很抱歉!不存在你要还的书!\n”)；
return FALSE;
}
user = rs.pt—〉key［rs。

i].user；
if(！user）｛
printf("\t这本书暂无出借!\n”);
return FALSE；
}
printf（”\n\t请输入图书证号："）;
scanf（"％d”,＆number)；
pre = user;
do{
if（user-〉number == number）{
if(user == rs.pt-〉key[rs。

i］。

user)｛
rs。

pt-〉key［rs.i].user = user—〉next;
free(user);
｝
else{
pre->next = user—>next；
free（user）；
}
rs.pt->key［rs.i］。

left++；
return OK；
｝
pre = user；
user = user—>next;
｝while（user）;
printf(”\t你输入的图书证号不正确!请重新操作!\n"）；
return FALSE；
}
//显示某个书的信息
void ShowWriterBook（BTree p，char writer［］） {
for（int i = 1; i〈= p—>keynum；i++）{
if(strcmp(p->key[i］。

writter，writer) == 0)｛
printf("\t\t\t书号为：%d ", p—〉key[i］。

key);
printf（”书名为：％s ”，p-〉key[i］.bname）;
printf（"作者为:%3s\n"，p—〉key［i].writter）；
}
}
}
/*＊＊*＊＊**＊＊＊＊*＊*＊＊＊＊＊*＊＊*＊***＊＊*＊**＊＊＊＊＊＊*＊＊***＊＊＊＊＊**＊＊＊*＊**＊*＊＊*＊*/
//菜单的显示，并接受用户返回的选项
char menu_selete（）{
char ch;
system("cls"）；//清屏
printf("\t＊*＊＊***＊**＊＊*＊＊＊*＊*＊＊＊** 图书管理系统*＊**＊*＊＊*＊＊**＊＊***＊＊*＊\n\n”）;
printf（"\t1.新书入库. \t2.查找书籍。

\n"）;
printf("\t3.显示库存。

\t4。

借阅. \n”);
printf（”\t5。

还书 \t6.退出. \n”）;
printf(”\t＊**＊＊****＊＊*****＊＊＊＊＊*＊＊＊＊＊＊＊*****＊＊＊＊＊
***＊**＊***＊＊＊＊*＊＊＊＊*＊＊\n\n"）；
printf（”\t请选择你所需要的操作(1~6）:”);
do{
ch = getch（); //getch和getchar实现的效果不同
｝while（ch < '1’｜| ch > ’7’）；
return ch;
}
void main(){
KeyType k；
Result rs；//查找的结果
read(）;
while(1）｛
switch(menu_selete()）{
case’1’:
system（”cls”)；
printf（”\t-----—-—-——-—-——-- 录入书信息—-—-——-———-—--——\n");
InBookMess(k)；
InsertBTree（root,k)；
printf("\t——--—-—-- 录入结束——-———--—\n");
temp（root);
printf（”\t当前书库的库存信息如下：\n”）；
display（root）；//显示全部的书
printf（"\t按任意键返回")；
getch(）；
break；
case’2'：
system（”cls")；
printf(”\t-----—--—--—--——-—查找书信息------—----——---\n”）；
InBookKey（k）;
printf("\n")；
rs = SearchBTree（root，k）；
if（rs。

tag == 1）｛
ShowBookMess（rs.pt-〉key［rs。

i]);
}
else｛
printf（"\t你要查找的书号%d 不存在!\n\n”,k。

key）；
｝
printf（"\n\t-—-———-———--———-—- 查找结束--—-—-—--—-----—\n”）;
printf（”\t按任意键返回");
getch();
break；
case'3'：
system（"cls”）;
printf("\t———-——-—--—----——- 全部的书—--—-———-------—\n\n"）；
display(root); //显示全部的书
printf（”\t--————-——-—--——--—显示完毕—----—-—--———-—--\n");
printf(”\tt按任意键返回”）；
getch()；
break;
case’4':
system（”cls”)；
printf（"\t-——-----——-——-—-——借阅--——--—--—-——-——-\n")；
InBookKey（k)；
if(BorrowBook（root，k)){
printf(”\n\t借阅成功!\n”);
}
else｛
printf（"\n\t借阅失败！\n”);
｝
printf（”\n\t按任意键返回")；
getch()；
break;
case’5’：
system("cls”）;
printf（”\t—--——--—--———--——还书—-—--—--———-—--——\n\n"）；
InBookKey(k)；
if(ReturnBook(root,k））{
printf（"\n\t归还成功！\n”）；
｝
else{
printf（”\n\t归还失败！\n"）；
}
printf（"\n\t按任意键返回"）；
getch()；
break；
case’6’：
exit（0）;
｝
}
}。