数据结构图书借阅管理系统课程设计
『壹』 图书馆管理系统 数据结构课程设计 c语言
#include<stdio.h>
#include<math.h>
#include<string.h>
#include<stdlib.h>
struct books_list
{
char author[20]; /*作者名*/
char bookname[20]; /*书名*/
char publisher[20]; /*出版单位*/
char pbtime[15]; /*出版时间*/
char loginnum[10]; /*登陆号*/
float price; /*价格*/
char classfy[10]; /*分类号*/
struct books_list * next; /*链表的指针域*/
};
struct books_list * Create_Books_Doc(); /*新建链表*/
void InsertDoc(struct books_list * head); /*插入*/
void DeleteDoc(struct books_list * head , int num);/*删除*/
void Print_Book_Doc(struct books_list * head);/*浏览*/
void search_book(struct books_list * head); /*查询*/
void info_change(struct books_list * head);/*修改*/
void save(struct books_list * head);/*保存数据至文件*/
/*新建链表头节点*/
struct books_list * Create_Books_Doc()
{
struct books_list * head;
head=(struct books_list *)malloc(sizeof(struct books_list)); /*分配头节点空间*/
head->next=NULL; /*头节点指针域初始化，定为空*/
return head;
}
/*保存数据至文件*/
void save(struct books_list * head)
{
struct books_list *p;
FILE *fp;
p=head;
fp=fopen("data.txt","w+"); /*以写方式新建并打开 data.txt文件*/
fprintf(fp,"┏━━━┳━━━━━┳━━━━━┳━━━━━┳━━━━━━┳━━━┳━━━━┓\n"); /*向文件输出表格*/
fprintf(fp,"┃登录号┃ 书 名 ┃ 作 者┃ 出版单位 ┃ 出版时间 ┃分类号┃ 价格 ┃\n");
fprintf(fp,"┣━━━╋━━━━━╋━━━━━╋━━━━━╋━━━━━━╋━━━╋━━━━┫\n");
/*指针从头节点开始移动，遍历至尾结点，依次输出图书信息*/
while(p->next!= NULL)
{
p=p->next;
fprintf(fp,"┃%-6.6s┃%-10.10s┃%-10.10s┃%-10.10s┃%-12.12s┃%-6.6s┃%.2f ┃\n",p->loginnum,p->bookname,p->author,p->publisher,p->pbtime,p->classfy,p->price);
}
fprintf(fp,"┗━━━┻━━━━━┻━━━━━┻━━━━━┻━━━━━━┻━━━┻━━━━┛\n");
fclose(fp);
printf(" 已将图书数据保存到 data.txt 文件\n");
}
/*插入*/
void InsertDoc(struct books_list *head)
{
/*定义结构体指针变量 s指向开辟的新结点首地址 p为中间变量*/
struct books_list *s, *p;
char flag='Y'; /*定义flag,方便用户选择重复输入*/
p=head;
/*遍历到尾结点，p指向尾结点*/
while(p->next!= NULL)
{
p=p->next;
}
/*开辟新空间,存入数据,添加进链表*/
while(flag=='Y'||flag=='y')
{
s=(struct books_list *)malloc(sizeof(struct books_list));
printf("\n 请输入图书登陆号:");
fflush(stdin);
scanf("%s",s->loginnum);
printf("\n 请输入图书书名:");
fflush(stdin);
scanf("%s",s->bookname);
printf("\n 请输入图书作者名:");
fflush(stdin);
scanf("%s",s->author);
printf("\n 请输入图书出版社:");
fflush(stdin);
scanf("%s",s->publisher);
printf("\n 请输入图书出版时间:");
fflush(stdin);
scanf("%s",s->pbtime);
printf("\n 请输入图书分类号:");
fflush(stdin);
scanf("%s",s->classfy);
printf("\n 请输入图书价格:");
fflush(stdin);
scanf("%f",&s->price);
printf("\n");
p->next=s; /*将新增加的节点添加进链表*/
p=s; /*p指向尾节点，向后移*/
s->next=NULL;
printf(" ━━━━ 添加成功！━━━━");
printf("\n 继续添加？(Y/N):");
fflush(stdin);
scanf("%c",&flag);
printf("\n");
if(flag=='N'||flag=='n')
{break;}
else if(flag=='Y'||flag=='y')
{continue;}
}
save(head); /*保存数据至文件*/
return;
}
/*查询操作*/
void search_book(struct books_list *head)
{
struct books_list * p;
char temp[20];
p=head;
if(head==NULL || head->next==NULL) /*判断数据库是否为空*/
{
printf(" ━━━━ 图书库为空！━━━━\n");
}
else
{
printf("请输入您要查找的书名: ");
fflush(stdin);
scanf("%s",temp);
/*指针从头节点开始移动，遍历至尾结点，查找书目信息*/
while(p->next!= NULL)
{
p=p->next;
if(strcmp(p->bookname,temp)==0)
{
printf("\n图书已找到!\n");
printf("\n");
printf("登录号: %s\t\n",p->loginnum);
printf("书名: %s\t\n",p->bookname);
printf("作者名: %s\t\n",p->author);
printf("出版单位: %s\t\n",p->publisher);
printf("出版时间: %s\t\n",p->pbtime);
printf("分类号: %s\t\n",p->classfy);
printf("价格: %.2f\t\n",p->price);
}
if(p->next==NULL)
{
printf("\n查询完毕!\n");
}
}
}
return;
}
/*浏览操作*/
void Print_Book_Doc(struct books_list * head)
{
struct books_list * p;
if(head==NULL || head->next==NULL) /*判断数据库是否为空*/
{
printf("\n ━━━━ 没有图书记录! ━━━━\n\n");
return;
}
p=head;
printf("┏━━━┳━━━━━┳━━━━━┳━━━━━┳━━━━━━┳━━━┳━━━━┓\n");
printf("┃登录号┃ 书 名 ┃ 作 者┃ 出版单位 ┃ 出版时间 ┃分类号┃ 价格 ┃\n");
printf("┣━━━╋━━━━━╋━━━━━╋━━━━━╋━━━━━━╋━━━╋━━━━┫\n");
/*指针从头节点开始移动，遍历至尾结点，依次输出图书信息*/
while(p->next!= NULL)
{
p=p->next;
printf("┃%-6.6s┃%-10.10s┃%-10.10s┃%-10.10s┃%-12.12s┃%-6.6s┃%.2f ┃\n",p->loginnum,p->bookname,p->author,p->publisher,p->pbtime,p->classfy,p->price); /*循环输出表格*/
}
printf("┗━━━┻━━━━━┻━━━━━┻━━━━━┻━━━━━━┻━━━┻━━━━┛\n");
printf("\n");
}
/*修改操作*/
void info_change(struct books_list * head)
{
struct books_list * p;
int panan=0; /*此变量用于判断是否找到书目*/
char temp[20];
p=head;
printf("请输入要修改的书名:");
scanf("%s",temp);
while(p->next!= NULL)
{
p=p->next;
if(strcmp(p->bookname,temp)==0)
{
printf("\n 请输入图书登陆卡号:");
fflush(stdin);
scanf("%s",p->loginnum);
printf("\n 请输入图书书名:");
fflush(stdin);
scanf("%s",p->bookname);
printf("\n 请输入图书作者名:");
fflush(stdin);
scanf("%s",p->author);
printf("\n 请输入图书出版社:");
fflush(stdin);
scanf("%s",p->publisher);
printf("\n 请输入图书出版时间:");
fflush(stdin);
scanf("%s",p->pbtime);
printf("\n 请输入图书分类号:");
fflush(stdin);
scanf("%s",p->classfy);
printf("\n 请输入图书价格:");
fflush(stdin);
scanf("%f",&p->price);
printf("\n");
panan=1;
}
}
if(panan==0)
{
printf("\n ━━━━ 没有图书记录! ━━━━\n\n");
}
return;
}
/*删除操作*/
void DeleteDoc(struct books_list * head)
{
struct books_list *s,*p; /*s为中间变量，p为遍历时使用的指针*/
char temp[20];
int panan; /*此变量用于判断是否找到了书目*/
panan=0;
p=s=head;
printf(" [请输入您要删除的书名]:");
scanf("%s",temp);
/*遍历到尾结点*/
while(p!= NULL)
{
if(strcmp(p->bookname,temp)==0)
{
panan++;
break;
}
p=p->next;
}
if(panan==1)
{
for(;s->next!=p;) /*找到所需删除卡号结点的上一个结点*/
{
s=s->next;
}
s->next=p->next; /*将后一节点地址赋值给前一节点的指针域*/
free(p);
printf("\n ━━━━ 删除成功! ━━━━\n");
}
else /*未找到相应书目*/
{
printf(" 您输入的书目不存在，请确认后输入!\n");
}
return;
}
int main(void)
{
struct books_list * head;
char choice;
head=NULL;
for(;;) /*实现反复输入选择*/
{
printf(" ┏━┓━━━━━━━━━━━━━━━━━━━┏━┓\n");
printf(" ┃ ┃ socat 图书管理系统 ┃ ┃\n");
printf(" ┃ ┗━━━━━━━━━━━━━━━━━━━┛ ┃\n");
printf(" ┃ ●[1]图书信息录入 ┃\n");
printf(" ┃ ┃\n");
printf(" ┃ ●[2]图书信息浏览 ┃\n");
printf(" ┃ ┃\n");
printf(" ┃ ●[3]图书信息查询 ┃\n");
printf(" ┃ ┃\n");
printf(" ┃ ●[4]图书信息修改 ┃\n");
printf(" ┃ ┃\n");
printf(" ┃ ●[5]图书信息删除 ┃\n");
printf(" ┃ ┃\n");
printf(" ┃ ●[6]退出系统 ┃\n");
printf(" ┗━━━━━━━━━━━━━━━━━━━━━━━┛\n");
printf(" 请选择:");
fflush(stdin);
scanf("%c",&choice);
if(choice=='1')
{
if(head==NULL)
{
head=Create_Books_Doc();
}
InsertDoc(head);
}
else if(choice=='2')
{
Print_Book_Doc(head);
}
else if(choice=='3')
{
search_book(head);
}
else if(choice=='4')
{
info_change(head);
}
else if(choice=='5')
{
DeleteDoc(head);
}
else if(choice=='6')
{
printf("\n");
printf(" ━━━━━━━━ 感谢使用图书管理系统 ━━━━━━━━\n");
break;
}
else
{
printf(" ━━━━ 输入错误，请重新输入！━━━━");
break;
}
}
return 0;
}
『贰』 数据结构 图书管理系统的设计与实现
数据结构图书管理系统的设计与实现的建议：1.计算机毕业设计可不能马虎，最好还是自己动动脑筋，好好的写一写。 2.网上那种免费的毕业设计千万不能采用，要么是论文不完整，要么是程序运行不了，最重要的是到处都是，老师随时都可以知道你是在网上随便下载的一套3.如果没有时间写，可以在网上找找付费的，我们毕业的时候也是为这个头疼了很长时间，最后在网上找了很久，终于购买了一套毕业设计，还算不错，开题报告+论文+程序+答辩演示都有，主要的都是他们技术做好的成品，保证论文的完整和程序的独立运行，可以先看了作品满意以后再付款，而且同一学校不重复，不存在欺骗的性质，那个网站的名字我记的不是太清楚了，你可以在网络或者GOOGLE上搜索------七七计算机毕业论文，希望您可以找到
『叁』 图书馆借阅管理系统,（数据结构课程设计）
网络搜索51aspx这个网站上搜索!
『肆』 c语言 数据结构课程设计 图书管理系统
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
//
#define MAXSIZE 100 //最大值定义为100
#define LIST_INIT_SIZE 100//图书证使用者最大值定义为100
//借书人的结构体
typedef struct Boro//借书行为
{
char BNum[20];//借书的书号
char RetDate[8];//归还日期
struct Boro *next;
}Bor;
typedef struct LinkBook
{
Bor *next; //该图书证的借书行为
char CNum[20]; //卡号
int Total; //借书的数量
}lend[LIST_INIT_SIZE];//借书人数组
//图书的结构体信息
typedef struct LNode
{
char CardNum[20];//图书证号
struct LNode *next;
}LinkList; //借书人
typedef struct book
{//每种图书需要登记的内容包括书号ISBN、书名、作者、出版社、总库存量和现库存量。
char num[20];//书号
char name[20];//书名
char auth[20];//作者
char pub[20];//出版社
int TotNum;//总库存
int NowNum;//现库存
LinkList *next;//借了该书的人
}ook[MAXSIZE];
//
int Retotal;//读者数量
int total; //定义外部变量.书的种类数
//
//结构体初始化
void InitBo(ook &boo) //初始化图书信息
{
for(int i=0;i<MAXSIZE;i++)
{
boo[i].NowNum=0;
boo[i].TotNum=0;
boo[i].next=NULL;
}
}
void InitRe(lend &Lin) //初始化借阅者信息
{
for(int i=0;i<LIST_INIT_SIZE;i++)
Lin[i].next=NULL;
}
//
int mid=0;//外部函数mid，用来返回查找到的位置
bool BinarySearch(ook boo,char SearchNum[]) //二分法查找比较书号
{ //用bool函数，但由于函数不能有两个返回值,所以设置一个外部变量mid，用来返回查找到的位置
int low=0,high=total-1;
int found=0;
while(low<=high)
{
mid=(low+high)/2; //中间点
if(strcmp(boo[mid].num,SearchNum)==0) //书号相同
{
found=1;
return true;
}//查找成功
if(strcmp(boo[mid].num,SearchNum)!=0)//书号不同
high=mid-1;
else low=mid+1;
}
if(found==0)
return false; //查找失败
}
void Buy(ook &boo, char BuyNum[])
{//1、 采编入库：新购入一种书，如果该书在图书账目中已经存在，则将其库存量增加（包
//括总库存量和现库存量），如果该书不存在，则在图书账目中增加一种书，总库存量和现库存量均为1。
if(BinarySearch(boo,BuyNum)) //如果书库中有此书
{
boo[mid].TotNum++; //总库存加1
boo[mid].NowNum++; //现库存加1
printf("入库成功.\n");
printf("已更改书库中该书的信息。编号 %s 的书 %s 作者是 %s ,出版社是 %s ,目前的总库存是 %d ,现库存是 %d 。\n",boo[mid].num,boo[mid].name,boo[mid].auth,boo[mid].pub,boo[mid].TotNum,boo[mid].NowNum);
}
if(!BinarySearch(boo,BuyNum))
{
int i;
for(i=total;i>mid&&total;i--) //插在适合位置 保持有序
boo[i]=boo[i-1]; //空出插入位置
printf("该书在书库中不存在。设立新书目，请补全书的详细信息。\n");
strcpy(boo[i].num,BuyNum);
printf("该书购入的数量是:");
scanf(" %d",&boo[i].NowNum);
boo[i].TotNum=boo[i].NowNum;
printf("该书的名字是:");
scanf(" %s",&boo[i].name);
printf("该书的作者是:");
scanf(" %s",&boo[i].auth);
printf("该书的出版社是:");
scanf(" %s",&boo[i].pub);//补全信息
boo[i].next=NULL;
total++;//总量+1
printf("已增加该书的信息。编号 %s 的书 %s 作者是 %s ,出版社是 %s ,目前的总库存是 %d ,现库存是 %d 。\n",boo[i].num,boo[i].name,boo[i].auth,boo[i].pub,boo[i].TotNum,boo[i].NowNum);
printf("入库成功.\n");
}
}
void Delete(ook &boo,char DeleteNum[])
{//2、 清空库存：某一种书已无保留价值，将它从图书账目中注销。
if(BinarySearch(boo,DeleteNum)==false||total==0) //如果无此书
printf("书库中没有该书.\n");
if(BinarySearch(boo,DeleteNum))//若有
{
if(!boo[mid].next)
{
int j;
for( j=mid;j<total;j++)
boo[j]=boo[j+1];
strcpy(boo[j].num,boo[j+1].num);
strcpy(boo[j].name,boo[j+1].name);
strcpy(boo[j].auth,boo[j+1].auth);
strcpy(boo[j].pub,boo[j+1].pub);
boo[j].TotNum=boo[j+1].TotNum;
boo[j].NowNum=boo[j+1].NowNum;
printf("已成功删除该书.\n");
}
else printf("该书有借阅者，无法删除。\n");
}
}
void Borrow(ook &boo,lend &Lin,char BorrowNum[],char CaNum[])
{//3、 借阅：如果一种书的现库存量大于零，则借出一本书，将现库存量减1，
//并登记借阅者的图书证号和归还期限。
Bor *p,*q;
LinkList *m,*n;
if(!BinarySearch(boo,BorrowNum)||total==0) //如果没有找到此书
printf("书库里没这书。\n");//如果有这书
if(BinarySearch(boo,BorrowNum)) //书库里有
{
if(boo[mid].NowNum>0) //看现库存是否大于0
{
boo[mid].NowNum--;//借出一本，少1
if(boo[mid].next==NULL) //若该书信息下显示该种书还没被人借过
{
m=(LinkList *)malloc(sizeof(LNode));//分配
boo[mid].next=m;//该图书信息中的链表的第一个结点
strcpy(m->CardNum,CaNum);
m->next=NULL;//后一个结点为空
}
else //如果已经有人在借这书了
{
m=boo[mid].next;
while(m->next) //遍历到最后一个结点
m=m->next;
n=(LinkList *)malloc(sizeof(LNode));//分配空间，增加1个结点
m->next=n;
strcpy(n->CardNum,CaNum);//记录证号
n->next=NULL;
}
int i=0;
for(i=0;i<Retotal;i++)//
{
if(!strcmp(Lin[i].CNum,CaNum))//如果已经有该图书证的信息
{
p=Lin[i].next;
while(p->next)p=p->next;//遍历到最后一个结点
q=(Bor *)malloc(sizeof(Boro));//分配空间
p->next=q;
strcpy(q->BNum,BorrowNum); //记录书号
printf("输入归还日期:");
scanf("%s",&q->RetDate);
q->next=NULL;
printf("借阅成功.\n");
break; //找到证了就跳出循环
}
}
if(i==Retotal)//如果没有这张证的信息
{
strcpy(Lin[i].CNum,CaNum); //记录证号
p=(Bor *)malloc(sizeof(Boro)); //分配空间
Lin[i].next=p;
strcpy(p->BNum,BorrowNum);
printf("输入归还日期:");
scanf(" %s",&p->RetDate);
p->next=NULL;
Retotal++; //借阅证号信息总数加1
printf("借阅成功.\n");
}
}
else printf("借阅失败.该书现在库存为0.\n");
}
}
void Return(ook &boo,lend &Lin,char ReturnNum[],char BorrowerNum[])
{//4、 归还：注销对借阅者的登记，改变该书的现存量。
Bor *p,*q;
LinkList *m,*n;
int flag=0;//设置一个参数
if(!BinarySearch(boo,ReturnNum)||!total) //没书
printf("书库中无此书.\n");
if(BinarySearch(boo,ReturnNum)) //有书
{
m=boo[mid].next;
if(!strcmp(m->CardNum,BorrowerNum)) //如果是第一个借的人还的
{
boo[mid].NowNum++; //现库存加1
boo[mid].next=m->next; //删除结点
free(m); //释放该结点的空间空间
}
else
{
while(m->next) //查找归还者的借阅者结点
{
if(!strcmp(m->next->CardNum,BorrowerNum)) //如果找到
{
n=m->next; //n为归还者的借阅结点
m->next=n->next; //m指向归还者的借阅结点的下一结点
free(n); //释放空间
boo[mid].NowNum++; //现库存加1
break;
}
m=m->next;
}
}
}
//在借阅者表里查找借阅者信息
for(int i=0;i<Retotal;i++)
{
if(!strcmp(Lin[i].CNum,BorrowerNum)) //如果找到借阅者
{
p=Lin[i].next;
if(!strcmp(p->BNum,ReturnNum)) //如果是归还的是借的第一本书
{
Lin[i].next=p->next; //指向下一借书结点
free(p); //释放结点空间
printf("成功归还该书.\n");
flag=1;
break;
}
else //找不到
{
while(p->next) //找到归还书的借书结点
{
if(!strcmp(p->next->BNum,ReturnNum)) //如果找到
{
q=p->next; //q为归还书的借书结点
p->next=q->next; //p指向下一借书结点
free(q); //释放空间
printf("成功归还该书.\n");
flag=1;
break;
}
p=p->next;
}
}
}
}
for(int k=0;k<Retotal;k++)
if(!Lin[k].next)
{
int j;
for(j=k;j<Retotal;j++)
Lin[j]=Lin[j+1]; //其后都往前移一位，覆盖掉当前信息
strcpy(Lin[j].CNum," "); //删除图书证号
Retotal--; //图书证数减1
} //删除当前状态下没借书的图书证的信息，节省空间
if(flag==0) printf("无该证信息.\n");
}
//5、 查找：实现按三种查询条件之一查找：按书号查找、
//按书名查找、按作者查找。注：可不实现组合查找，即几个条件组合查找。
void SearchByNum(ook &boo,char SeaNum[])
{//BY NUM 根据书号查找
LinkList *p;
p=boo[mid].next;
if(BinarySearch(boo,SeaNum)==false)printf("对不起，未找到您想查找的书。\n");//二分查找 没找到
else//找到了的话
{
{
printf("┏━━━━━━━┳━━━━━━━┳━━━━━━━━┳━━━━━━━━┳━━━━━┳━━━━━┓\n");
printf("┃ 书号 ┃ 书名 ┃ 作者 ┃ 出版社 ┃ 现库存 ┃ 总库存 ┃\n");
printf("┣━━━━━━━╋━━━━━━━╋━━━━━━━━╋━━━━━━━━╋━━━━━╋━━━━━┫\n");
printf("┃%14s┃%14s┃%16s┃%16s┃%10d┃%10d┃\n",boo[mid].num,boo[mid].name,boo[mid].auth,boo[mid].pub,boo[mid].NowNum,boo[mid].TotNum);
printf("┗━━━━━━━┻━━━━━━━┻━━━━━━━━┻━━━━━━━━┻━━━━━┻━━━━━┛\n");
if(boo[mid].next!=NULL)
{
printf("┏━━━━━━━┓\n");
printf("┃ 已借该书的 ┃\n");
printf("┃ 图书证号 ┃\n");
while(p)
{
printf("┣━━━━━━━┫\n");
printf("┃%14s┃\n",p->CardNum);
p=p->next;
}
printf("┗━━━━━━━┛\n");
}
}
while(p)
{
printf(" %s ",p->CardNum);//在按书号查找的函数里也显示借了这本书的借阅者的证号
p=p->next;
}
printf(" \n");
}//显示查找的书籍的信息
}
void SearchByName(ook &boo)
{//BY NAME 根据书名查找
char SeaName[20];
printf("输入想查找的书的书名:\n");
scanf(" %s",&SeaName);
printf("找到符合该书名的书的详细信息如下：\n");
for(int i=0;i<total;i++)
{
if(strcmp(SeaName,boo[i].name)==0)//如果书名一样
{
printf("书号：%s\n书名：%s\n作者：%s\n出版社：%s\n总库存量：%d\n现库存量：%d\n\n",boo[i].num,boo[i].name,boo[i].auth,boo[i].pub,boo[i].TotNum,boo[i].NowNum);
}//显示符合信息的所有书籍的信息
}
}
void SearchByAuth(ook &boo)
{// BY AUTH 根据作者查找
char SeaAuth[20];
printf("输入想查找的书的作者:\n");
scanf(" %s",&SeaAuth);
printf("找到符合该作者的书的详细信息如下：\n");
for(int i=0;i<total;i++)
{
if(strcmp(SeaAuth,boo[i].auth)==0)//如果作者一样
{
printf("书号：%s\n书名：%s\n作者：%s\n出版社：%s\n总库存量：%d\n现库存量：%d\n\n",boo[i].num,boo[i].name,boo[i].auth,boo[i].pub,boo[i].TotNum,boo[i].NowNum);
}//显示符合信息的所有书籍的信息
}
}
//6、 查看：可查看某图书证号的借阅者借阅的全部图书，可查看全部超期未还的图书。
void ViewCard(ook &boo,lend &Lin)
{//查看某图书证号的借阅者借阅的全部图书
char Num[20];
printf("请输入您所想要查看的图书证号:\n");
scanf(" %s",&Num);
Bor *p;
int qqq=0;
for(int i=0;i<Retotal;i++)
{
if(strcmp(Lin[i].CNum,Num)==0) //找到该证
{
printf("这个证借的书有：\n");
p=Lin[i].next;
while(p)
{
printf(" %s ",p->BNum); //书号
p=p->next;
}
printf("\n");
qqq=1;
break;
}
}
if(qqq==0)
printf("该证不存在.\n");
}
void ViewBook(ook &boo,lend &Lin)
{//查看全部超期未还的图书
char date[8];
Bor *p;
printf("请输入日期（请按格式20060605输入）:\n");
scanf(" %s",&date);
printf("所有超期未还的书有:\n");
for(int i=0;i<Retotal;i++)
{
p=Lin[i].next;
while(p)//当p不空时
{
if(strcmp(p->RetDate,date)<0) //超过日期
{
printf("书号为 %s 证号为 %s 应归还日期为 %s \n",p->BNum,Lin[i].CNum,p->RetDate);
}//显示所有超期未还的书的信息
p=p->next;
}
}
}
void Menu() //菜单
{
printf("┏—————————————————M E N U————————————————┓\n");
printf("│ │\n");
printf("│ 1. 采编入库：新购入一种书，如果该书在图书账目中已经存在， │\n");
printf("│ 则将其库存量增加(包括总库存量和现库存量)。 │\n");
printf("│ 如果该书不存在，则在图书账目中增加一种书， │\n");
printf("│ 总库存量和现库存量均为输入的数字。 │\n");
printf("│ 2. 清空库存：某一种书已无保留价值，将它从图书账目中注销。 │\n");
printf("│ 3. 借阅：如果一种书的现库存量大于零，则借出一本书，将现库存量减1， │\n");
printf("│ 并登记借阅者的图书证号和归还期限。 │\n");
printf("│ 4. 归还：注销对借阅者的登记，改变该书的现存量。 │\n");
printf("│ 5. 按书号查找。 │\n");
printf("│ 6. 按书名查找。 │\n");
printf("│ 7. 按作者查找。 │\n");
printf("│ 8. 查看某图书证号的借阅者借阅的全部图书。 │\n");
printf("│ 9. 查看全部超期未还的图书。 │\n");
printf("│ 0. 退出图书管理系统。 │\n");
printf("│ │\n");
printf("┗—————————————请 选 择 你 需 要 的 操 作————————————┛\n");
}
void main()
{
ook Bo;
lend Lin;
char BNum[20];
char CNum[20];
printf("-----------------------欢 迎 进 入 图 书 管 理 系 统!---------------------------\n\n");
int choice=10;
int SearchCho=10,ViewCho=10;
while(choice!=0)
{
Menu();//显示菜单
scanf(" %d",&choice);
switch(choice)
{
case 1://采编入库
printf("请输入入库的书的书号:");
scanf(" %s",BNum);
Buy(Bo,BNum);
break;
case 2://清空库存
printf("请输入想要清除的书的书号:");
scanf(" %s",BNum);
Delete(Bo,BNum);
break;
case 3://借阅
printf("请输入想要借阅的书的书号:\n");
scanf(" %s",&BNum);
printf("请输入图书证号:");
scanf(" %s",&CNum);
Borrow(Bo,Lin,BNum,CNum);
break;
case 4://归还
printf("请输入想要归还的书的书号:\n");
scanf(" %s",&BNum);
printf("请输入图书证号:");
scanf(" %s",&CNum);
Return(Bo,Lin,BNum,CNum);
break;
case 5://查找//根据书号查找
printf("请输入书号:");//输入书号查找
scanf(" %s",&BNum);
SearchByNum(Bo,BNum);
break;
case 6://根据书名查找
SearchByName(Bo);
break;
case 7://根据作者查找
SearchByAuth(Bo);
break;
case 8://查看某图书证所借的所有书
ViewCard(Bo,Lin);
break;
case 9: //查看全部超期未还的书
ViewBook(Bo,Lin);
break;
case 0://退出系统
exit(0);break;
default:printf("输入错误!\n");exit(0);break;
}
}
}
『伍』 数据结构课程设计(基于C) 图书管理系统
头文件:
============
#ifndef _DATA_STRUCT_H_
#define _DATA_STRUCT_H_
/*图书结构*/
struct Book
{
unsigned long BookID;/*图书编号*/
char BookName[512];/*书名*/
char Writer[512];/*作者*/
int CurrentNumber;/*现存量*/
Book *pNext;/*下一个图书信息*/
};
/*图书索引结构*/
struct Index
{
unsigned long BookID;/*图书编号*/
Index *pNext;/*下一个索引指针*/
};
/*借阅信息结构*/
struct Borrow
{
unsigned long BookID;/*借阅图书编号*/
char BookName[512];/*书名*/
unsigned long StuID;/*图书证号*/
char ReturnTime[512];/*归还日期*/
Borrow *pNext;/*下一个借阅信息*/
};
#endif/*_DATA_STRUCT_H_*/
实现文件:
===============
// BookManage.cpp : 定义控制台应用程序的入口点。
//
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "DataStruct.h"
/*
数据结构课程设计(基于C) 图书管理系统
悬赏分：100 - 离问题结束还有 14 天 23 小时
【问题描述】
图书管理基本业务活动包括，对一本书的采编入库、清楚库存、借阅和归还等等。试设计一个图书管理系统，将上述业务活动借助于计算机系统完成。
【基本要求】
（1） 每种书的登记至少包括书号书名作者现存量总库存量5项
（2）对书号建立索引表（线性表）以提高查找效率
（3） 系统要实现的操作及其功能定义如下：
1 采编入库：新购入一种书，经分类和确定数好之后登记到图书馆账目中去。如果这种书在账户中已有，则只将总库存量增加。
2借阅：如果一本书的现存量大于零，则借出一本，登出借阅者的图书证号和归还日期
3归还：注销对借阅者的登记，改变该书的现存量
*/
/*获取输入字符串*/
void GetInput(char *pInOutStr,int StrLen,bool OnlyGetNumber = false);
/*显示主菜单 并返回选择*/
int ShowMainMenu();
/*图书入库操作,传入参数为图书列表头指针的指针和索引信息的头指针的指针,因为在此函数内部可能会改变头指针的值*/
void PutBookInLib(Book **pHead,Index **pIndex);
/*查询图书馆库存,查询不改变数据,故传入指针即可*/
void QueryBookLib(Book *pHead);
/*借阅图书*/
void BorrowBook(Borrow **pBorrow,Book *pHead);
/*查询借阅*/
void QueryBorrow(Borrow *pBorrow);
/*归还图书*/
void ReturnBook(Borrow **pBorrow,Book *pHead);
/*释放图书链表及索引链表及借阅信息链表*/
void DeleteBookList(Book **pHead);
void DeleteIndexList(Index **pIndex);
void DeleteBorrowList(Borrow **pBorrow);
int main()
{
/*图书列表头指针*/
Book *pBookHead = NULL;
/*图书索引头指针*/
Index *pIndexHead = NULL;
/*借阅信息头指针*/
Borrow *pBorrowHead = NULL;
/*用来保存当前用户的输入*/
int ChoosedNum = -1;
while ( true )
{
ChoosedNum = ShowMainMenu();
switch(ChoosedNum)
{
case 0 :/*退出*/
{
return 0;
break;
}
case 1:/*图书入库*/
{
PutBookInLib(&pBookHead,&pIndexHead);
break;
}
case 2:/*查询库存*/
{
QueryBookLib(pBookHead);
printf("按回车键继续...");
fflush(stdin);
getchar();
system("cls");
break;
}
case 3:/*借阅图书*/
{
QueryBookLib(pBookHead);
BorrowBook(&pBorrowHead,pBookHead);
break;
}
case 4:/*查询借阅*/
{
QueryBorrow(pBorrowHead);
printf("按回车键继续...");
fflush(stdin);
getchar();
system("cls");
break;
}
case 5:/*归还图书*/
{
QueryBorrow(pBorrowHead);
ReturnBook(&pBorrowHead,pBookHead);
break;
}
}
}
DeleteBookList(&pBookHead);
DeleteIndexList(&pIndexHead);
DeleteBorrowList(&pBorrowHead);
fflush(stdin);
getchar();
return 0;
}
/*获取输入字符串*/
void GetInput(char *pInOutStr,int StrLen,bool OnlyGetNumber)
{
memset(pInOutStr,0x0,StrLen);
fflush(stdin);
int Count = 0;
while ( true )
{
char TmpC = 0;
fread(&TmpC,1,1,stdin);
if ( 10 == TmpC )
{
break;
}
if ( OnlyGetNumber && TmpC >= '0' && TmpC <= '9' )
{
pInOutStr[Count] = TmpC;
Count++;
}
else
{
pInOutStr[Count] = TmpC;
Count++;
}
}
}
/*显示主菜单 并返回选择*/
int ShowMainMenu()
{
char InPutStr[1024];
NO_INPUT:
printf("\n\n\n");
printf("******************************************************************\n");
printf("* 图书管理系统 *\n");
printf("******************************************************************\n");
printf("\n");
printf("请选择:\n");
printf("\t1.图书入库\n");
printf("\t2.查询库存\n");
printf("\t3.借阅图书\n");
printf("\t4.查询借阅\n");
printf("\t5.归还图书\n");
printf("\t0.退出\n");
printf("\n");
printf("\t输入 : ");
GetInput(InPutStr,1024,true);
if ( strlen(InPutStr) < 1 )
{
system("cls");
goto NO_INPUT;
}
return atoi(InPutStr);
}
/*图书入库操作*/
void PutBookInLib(Book **pHead,Index **pIndex)
{
Book *pWork = *pHead;
unsigned long BookID = 1;
char InPutStr[1024];
/*先计算处当前入库图书的ID号*/
if ( NULL == pWork )
{
BookID = 1;
}
else
{
while ( pWork->pNext != NULL )
{
pWork = pWork->pNext;
}
BookID = pWork->BookID + 1;
}
Book *pTmpNewBook = (Book *)(malloc(sizeof(Book)));
memset(pTmpNewBook,0x0,sizeof(Book));
Index *pTmpIndex = (Index *)(malloc(sizeof(Index)));
memset(pTmpIndex,0x0,sizeof(Index));
pTmpNewBook->BookID = BookID;
pTmpIndex->BookID = BookID;
system("cls");
printf("输入图书名称 : ");
GetInput(InPutStr,1024);
strcpy(pTmpNewBook->BookName,InPutStr);
system("cls");
printf("<<%s>>\n",pTmpNewBook->BookName);
printf("图书作者 : ");
GetInput(InPutStr,1024);
strcpy(pTmpNewBook->Writer,InPutStr);
system("cls");
printf("<<%s>>\n",pTmpNewBook->BookName);
printf("作者:%s\n",pTmpNewBook->Writer);
printf("入库数量 : ");
GetInput(InPutStr,1024,true);
pTmpNewBook->CurrentNumber = atoi(InPutStr);
if ( pTmpNewBook->CurrentNumber < 1 )
{
system("cls");
printf("入库数量错误!(按回车键继续...)");
fflush(stdin);
getchar();
system("cls");
return;
}
if ( NULL == *pHead )
{
*pHead = pTmpNewBook;
*pIndex = pTmpIndex;
}
else
{
Book *pWork = *pHead;
while ( pWork != NULL )
{
if ( strcmp(pWork->BookName,pTmpNewBook->BookName) == 0 && strcmp(pWork->Writer,pTmpNewBook->Writer) == 0 )
{
pWork->CurrentNumber += pTmpNewBook->CurrentNumber;
return;
}
pWork = pWork->pNext;
}
pWork = *pHead;
while ( pWork->pNext != NULL )
{
pWork = pWork->pNext;
}
pWork->pNext = pTmpNewBook;
Index *pWork2 = *pIndex;
while ( pWork2->pNext != NULL )
{
pWork2 = pWork2->pNext;
}
pWork2->pNext = pTmpIndex;
}
system("cls");
printf("图书:<<%s>>\n作者:%s\n入库数:%d\n\n入库操作成功!(按回车键继续...)",pTmpNewBook->BookName,pTmpNewBook->Writer,pTmpNewBook->CurrentNumber);
fflush(stdin);
getchar();
system("cls");
}
/*释放图书链表及索引链表*/
void DeleteBookList(Book **pHead)
{
Book *pWork = *pHead;
Book *pNext = pWork;
while ( NULL != pWork )
{
pNext = pWork->pNext;
free(pWork);
pWork = pNext;
}
}
void DeleteIndexList(Index **pIndex)
{
Index *pWork = *pIndex;
Index *pNext = pWork;
while ( NULL != pWork )
{
pNext = pWork->pNext;
free(pWork);
pWork = pNext;
}
}
void DeleteBorrowList(Borrow **pBorrow)
{
Borrow *pWork = *pBorrow;
Borrow *pNext = pWork;
while ( NULL != pWork )
{
pNext = pWork->pNext;
free(pWork);
pWork = pNext;
}
}
/*查询图书馆库存,查询不改变数据,故传入指针即可*/
void QueryBookLib(Book *pHead)
{
Book *pWork = pHead;
int TotalCount = 0;
while ( NULL != pWork )
{
TotalCount++;
pWork = pWork->pNext;
}
system("cls");
printf("当前库存共%d种图书,列表如下:\n=====================================================\n",TotalCount);
pWork = pHead;
while ( NULL != pWork )
{
printf("编号:[%d] 书名:<<%s>> 作者:%s 当前库存:%d\n",pWork->BookID,pWork->BookName,pWork->Writer,pWork->CurrentNumber);
pWork = pWork->pNext;
}
printf("=====================================================\n",TotalCount);
}
/*借阅图书*/
void BorrowBook(Borrow **pBorrow,Book *pHead)
{
char InPutStr[1024];
bool HadTheBook = false;
Borrow *pTmpBorrow = (Borrow *)(malloc(sizeof(Borrow)));
memset(pTmpBorrow,0x0,sizeof(Borrow));
printf("请输入你想借书的编号 : ");
GetInput(InPutStr,1024,true);
pTmpBorrow->BookID = atoi(InPutStr);
Book *pWorkBook = pHead;
while ( pWorkBook != NULL )
{
if ( pWorkBook->BookID == pTmpBorrow->BookID )
{
HadTheBook = true;
break;
}
pWorkBook = pWorkBook->pNext;
}
if ( HadTheBook )
{
if ( pWorkBook->CurrentNumber < 1 )
{
system("cls");
printf("图书<<%s>>当前无库存,无法借阅!\n(按回车键继续...)",pWorkBook->BookName);
fflush(stdin);
getchar();
system("cls");
free(pTmpBorrow);
return;
}
}
else
{
system("cls");
printf("图书编号%d不存在!\n(按回车键继续...)",pTmpBorrow->BookID);
fflush(stdin);
getchar();
system("cls");
free(pTmpBorrow);
return;
}
strcpy(pTmpBorrow->BookName,pWorkBook->BookName);
printf("请输入借书证号 : ");
GetInput(InPutStr,1024,true);
pTmpBorrow->StuID = atoi(InPutStr);
if ( 0 == pTmpBorrow->StuID )
{
system("cls");
printf("借书证号不存在(借书证号输入整数)!\n(按回车键继续...)");
fflush(stdin);
getchar();
system("cls");
free(pTmpBorrow);
return;
}
time_t ltime;
struct tm *today;
time(<ime);
ltime += 60 * 60 * 24 * 30;
today = localtime(<ime);
sprintf(pTmpBorrow->ReturnTime,"%d年%d月%d日", today->tm_year+1900,
today->tm_mon+1,
today->tm_mday);
if ( *pBorrow == NULL )
{
*pBorrow = pTmpBorrow;
}
else
{
Borrow *pWork = *pBorrow;
while ( NULL != pWork->pNext )
{
pWork = pWork->pNext;
}
pWork->pNext = pTmpBorrow;
}
pWorkBook->CurrentNumber--;
system("cls");
printf("借书证号:%d\n借阅图书:<<%s>>\n\n操作成功!(按回车键继续...)",pTmpBorrow->StuID,pTmpBorrow->BookName);
fflush(stdin);
getchar();
system("cls");
}
/*查询借阅*/
void QueryBorrow(Borrow *pBorrow)
{
Borrow *pWork = pBorrow;
int TotalCount = 0;
while ( NULL != pWork )
{
TotalCount++;
pWork = pWork->pNext;
}
system("cls");
printf("当前借阅信息共%d条,列表如下:\n=====================================================\n",TotalCount);
pWork = pBorrow;
while ( NULL != pWork )
{
printf("借数证号:[%d] 借书名:<<%s>> 图书编号:%d 归还日期:%s\n",pWork->StuID,pWork->BookName,pWork->BookID,pWork->ReturnTime);
pWork = pWork->pNext;
}
printf("=====================================================\n",TotalCount);
}
/*归还图书*/
void ReturnBook(Borrow **pBorrow,Book *pHead)
{
char InPutStr[1024];
Borrow TmpBorrow;
bool HasFindBorrwo = false;
memset(&TmpBorrow,0x0,sizeof(TmpBorrow));
printf("请输入借书证号 : ");
GetInput(InPutStr,1024,true);
TmpBorrow.StuID = atoi(InPutStr);
printf("请输入所还图书编号 : ");
GetInput(InPutStr,1024,true);
TmpBorrow.BookID = atoi(InPutStr);
Borrow *pWorkBorrow = *pBorrow;
Borrow *pDeletePre = NULL;
while ( NULL != pWorkBorrow )
{
if ( pWorkBorrow->BookID == TmpBorrow.BookID && pWorkBorrow->StuID == TmpBorrow.StuID )
{
HasFindBorrwo = true;
break;
}
pDeletePre = pWorkBorrow;
pWorkBorrow = pWorkBorrow->pNext;
}
if ( ! HasFindBorrwo )
{
system("cls");
printf("你输入的借书信息不存在!\n(按回车键继续...)");
fflush(stdin);
getchar();
system("cls");
return;
}
if ( NULL == pDeletePre )
{
*pBorrow = pWorkBorrow->pNext;
}
else
{
pDeletePre->pNext = pWorkBorrow->pNext;
}
Book *pWorkBook = pHead;
while ( NULL != pWorkBook )
{
if ( pWorkBook->BookID == pWorkBorrow->BookID )
{
pWorkBook->CurrentNumber ++;
}
pWorkBook = pWorkBook->pNext;
}
system("cls");
printf("借书证号:%d\n归还图书:<<%s>>\n\n操作成功!(按回车键继续...)",pWorkBorrow->StuID,pWorkBorrow->BookName);
fflush(stdin);
getchar();
system("cls");
free(pWorkBorrow);
}
『陆』 数据结构课程设计：小型图书管理系统
^^#include<stdio.h>
#include<string.h>
#include<conio.h>
#include<stdlib.h>
#define N sizeof(struct book)
#define PT "%-5d %10s %6s %6s %8s %3d \n",p->num,p->name,p->where,p->author,p->pub,p->count
struct book /*图书信息*/
{
int num; /*书号*/
char name[10]; /*书名*/
char where[10]; /*所在书库*/
char author[15]; /*作者*/
char pub[20]; /*出版社*/
int count; /*数量*/
struct book *next;
};
/*输出模块*/
void print(struct book *p0)
{
struct book *p;
p=p0->next;
printf("\n\n\t\t^^^^^^^^^^^^^^图书信息表^^^^^^^^^^^^^^");
printf("\n\n图书编号---图书名称---所在书库----作者----出版社---数量\n");
while(p!=NULL)
{
printf(PT);
p=p->next;
}
getch();
}
/*输入模块*/
struct book *creat()
{
struct book *head,*p1,*p2;
int i=0;
head=p2=(struct book *)malloc(N);
head->next=NULL;
printf("\n\n\t\t录入图书信息");
printf("\n\t---------------------------------------");
while(1)
{ p1=(struct book *)malloc(N);
printf("\n 请输入图书编号(书号为0结束): ");
scanf("%d",&p1->num);
if(p1->num!=0)
{
printf("\n\n书名 所在书库 作者 出版社 图书数量\n");
scanf("%s%s%s%s%d",p1->name,p1->where,p1->author,p1->pub,&p1->count);
p2->next=p1;
p2=p1;
i++;
}
else
break;
}
p2->next=NULL;
free(p1);
printf("\n\t\t----------------------------------------");
printf("\n\t\t %d 种书录入完毕",i);
getch();
return head;
}
/*查找模块*/
void find(struct book *p0)
{
char name[10];
int flag=1;
struct book *p;
p=p0->next;
printf("请输入要查找的书名：\n");
scanf("%s",name);
for(p=p0;p;p=p->next)
if(strcmp(p->name,name)==0)
{
printf("\n\n图书编号---图书名称---所在书库----作者----出版社---数量\n");
printf(PT);
flag=0;
break;
}
if(flag) printf("\n 暂无此图书信息\n");
getch();
}
/*删除模块*/
void del(struct book *p0)
{
char name[10];
int flag=1;
struct book *p;
p=p0;
printf("请输入要删除的书名：\n");
scanf("%s",name);
while(p!=NULL)
{
if(strcmp(p->name,name)==0)
{
p0->next=p->next; /*后续节点连接到前驱节点之后*/
free(p);
printf("\t该书资料已删除.");
flag=0;
break;
}
p0=p;
p=p->next;
}
if(flag) printf("\n\t无此图书信息。");
getch();
}
/*增加模块*/
void insert(struct book *p0)
{
struct book *p;
p=(struct book *)malloc(N);
while(1)
{
printf("\n 请输入要增加的图书编号(书号为0 退出): ");
scanf("%d",&p->num);
if(p->num!=0)
{
if(p0->next!=NULL&&p0->next->num==p->num) /*找到重号*/
{
p=p->next;
free(p);
printf("\t该书已存在");
}
else
{printf("\n\n书名 所在书库 作者 出版社 图书数量\n");
scanf("%s%s%s%s%d",p->name,p->where,p->author,p->pub,&p->count);
p->next=p0->next;
p0->next=p;
printf("\t已成功插入.");
}
}
else
break;
}
getch();
}
/*修改模块*/
void modify(struct book *p0)
{
char name[10];
int flag=1;
int choice;
struct book *p;
p=p0->next;
printf("请输入要修改的书名：\n");
scanf("%s",name);
while(p!=NULL&&flag==1)
{
if(strcmp(p->name,name)==0)
{
printf("\n\t请选择要修改的项：");
printf("\n\t 1.修改图书编号\n");
printf("\n\t 2.修改图书所在书库\n");
printf("\n\t 3.修改图书作者\n");
printf("\n\t 4.修改图书出版社\n");
printf("\n\t 5.修改图书库存量\n");
scanf("%d",&choice);
switch(choice)
{
case 1: { printf("\n 请输入新的图书编号:");
scanf("%d",p->num); break;
}
case 2: { printf("\n 请输入新的图书书库:");
scanf("%s",p->where); break;
}
case 3: { printf("\n 请输入新的图书作者:");
scanf("%s",p->author); break;
}
case 4: {printf("\n 请输入新的图书出版社:");
scanf("%s",p->pub); break;
}
case 5: {printf("\n 请输入新的图书库存量:");
scanf("%d",p->count); break;
}
}
printf("\n\t该项已成功修改。\n\t 新的图书信息：");
printf("\n\n图书编号---图书名称---所在书库----作者----出版社---数量\n");
printf(PT);
flag=0;
}
p0=p;
p=p0->next;
}
if(flag) printf("\n\t暂无此图书信息。");
getch();
}
/*读文件*/
struct book *read_file()
{
int i=0;
struct book *p,*p1,*head=NULL;
FILE *fp;
if((fp=fopen("library.txt","rb"))==NULL)
{printf("\n\n\n\n\n \t********库文件不存在，请创建！**********");
getch();
return NULL;
}
head=(struct book *)malloc(N);
p1=head;
head->next=NULL;
printf("\n 已有图书信息：");
printf("\n\n图书编号---图书名称---所在书库----作者----出版社---数量\n");
while(!feof(fp))
{
p=(struct book *)malloc(N); /*开辟空间以存放的取得信息*/
while(fscanf(fp,"%d%s%s%s%s%d",&p->num,p->name,p->where,p->author,p->pub,&p->count)!=EOF)
{
printf(PT);
i++;
}
p1->next=p;
p1=p;
}
p1->next=NULL;
fclose(fp);
printf("\n 共种%d 图书信息",i);
printf("\n\n\n 文件中的信息以正确读出。按任意键进入主菜单。");
getch();
return (head);
}
/*保存文件*/
void save(struct book *head)
{
FILE *fp;
struct book *p;
fp=fopen("library.txt","wb"); /*以只写方式打开二进制文件*/
if(fp==NULL) /*打开文件失败*/
{
printf("\n=====>打开文件失败!\n");
getch();
return ;
}
else
for(p=head->next;p!=NULL;p=p->next)
fprintf(fp,"%d %s %s %s %s %d\n",p->num,p->name,p->where,p->author,p->pub,p->count);
fclose(fp);
printf("\n\t保存文件成功!\n");
}
void main()
{
struct book *head=NULL;
int choice=1;
head=read_file();
if(head==NULL)
{
printf("\n\t\t**********");
getch();
head=creat();
}
do
{
system("cls");
printf("\t\t----------Welcome---------\n");
printf("\n\n\t欢迎您，图书管理员.\n");
printf("\n\n\n\n\n");
printf("\n\t 请选择：");
printf("\n\t 1.查询图书信息\n");
printf("\n\t 2.修改图书信息\n");
printf("\n\t 3.增加图书信息\n");
printf("\n\t 4.删除图书信息\n");
printf("\n\t 5.显示所有图书信息\n");
printf("\n\t 0.退出系统\n");
scanf("%d",&choice);
switch(choice)
{
case 1: find(head); break;
case 2: modify(head); break;
case 3: insert(head); break;
case 4: del(head); break;
case 5: print(head); break;
case 0: system("cls");
printf("\n\n\n\n\n\t^^^^^^^^^^谢谢使用，再见^^^^^^^^^^！\n\n");
break;
}
}while(choice!=0);
save(head);
}
『柒』 图书管理系统--数据结构课程设计
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
struct BOOK
{
int id,usr[10],total,store,days[10];
char name[30],author[20];
}books[100];
/*结构体，存放书籍及借书信息。*/
void page_title(char *menu_item)
{
printf(">>> 以下是图 书 管 理 系 统--请 按 要 求 操 作 <<<\n\n- %s -\n\n",menu_item);
}
/*页头函数，可以通过参数menu_item，显示当前状态。*/
void return_confirm(void)
{
printf("\n任意键返回……\n");
getch();
}
/*返回前请求确认函数，方便返回前观察结果*/
int search_book(void)
{
int n,i;
printf("请输入图书序号:");
scanf("%d",&i);
for(n=0;n<100;n++)
{
if(books[n].id==i)
{
printf("书名:%s\n",books[n].name);
printf("作者:%s\n",books[n].author);
printf("存数:%d\n",books[n].store);
printf("总数:%d\n",books[n].total);
return n;
}
}
printf("\n输入有错或图书序号不存在.\n");
return -1;
}
/*上面是在数组中找到图书号匹配的记录，显示其信息并返
回数组下标，如果找不到相应记录则提示错误并返回-1。*/
void book_out(void)
{
int n,s,l,d;
page_title("借书");
if((n=search_book())!=-1&&books[n].store>0)
{
printf("请输入借书证序号:");
scanf("%d",&s);
printf("请输入可借天数:");
scanf("%d",&d);
for(l=0;l<10;l++)
{
if(books[n].usr[l]==0)
{
books[n].usr[l]=s;
books[n].days[l]=d;
break;
}
}
books[n].store--;
}
if(n!=-1&&books[n].store==0) printf("此书已经全部借出.\n");
return_confirm();
}
/*借书的函数，首先调用找书函数*/
void book_in(void)
{
int n,s,l;
page_title("还书");
if((n=search_book())!=-1&&books[n].store<books[n].total)
{
printf("借阅者图书证列表:\n");
for(l=0;l<10;l++)
if (books[n].usr[l]!=0)
printf("[%d] - %d天\n",books[n].usr[l],books[n].days[l]);
printf("请输入借书证序号:");
scanf("%d",&s);
for(l=0;l<10;l++)
{
if(books[n].usr[l]==s)
{
books[n].usr[l]=0;
books[n].days[l]=0;
break;
}
}
books[n].store++;
}
if(n!=-1&&books[n].store==books[n].total)
printf("全部入藏.\n");
return_confirm();
}
void book_add(void)
{
int n;
page_title("注册书");
for(n=0;n<100;n++)
if(books[n].id==0) break;
printf("序号:");
scanf("%d",&books[n].id);
printf("书名:");
scanf("%s",&books[n].name);
printf("作者:");
scanf("%s",&books[n].author);
printf("数量:");
scanf("%d",&books[n].total);
books[n].store=books[n].total;
return_confirm();
}
void book_del(void)
{
int n;
page_title("注销书");
if((n=search_book())!=-1) books[n].id=0;
printf("该书已注销.\n");
return_confirm();
}
void main(void)
{
menu: page_title("操作选择单子");
printf("请按以上要求选择操作\n\n");
printf("1 借书\n2 还书\n\n");
printf("3 注册书\n4 注销书\n\n");
printf("\n0 退出\n");
switch(getch())
{
case '1' : book_out();break;
case '2' : book_in();break;
case '3' : book_add();break;
case '4' : book_del();break;
case '0' : exit(0);
}
goto menu;
}
『捌』 数据结构课程设计 图书借阅管理系统 C语言版 顺序存储
图书借阅管理要是明天给你还行
『玖』 数据结构课程设计（图书馆借阅管理系统）
图书借阅管理系统具有以下功能：
图书资料管理
图书资料管理主要完成图书资料的新增、修改和报废，并生成图书资料库的功能。按采购员的要求，供书商提供需要的书籍。进行分类新增修改处理。并对已报废图书进行处理。
读者资料管理
读者资料管理主要完成读者资料的新增、修改和撤消，并生成读者资料库。按读者要求进行读者资料的新增、修改和撤消。
借书操作
借书操作主要完成读者的借书、续借及预订处理，并生成读者借阅库。首先进行读者资格的审核，符合要求后查阅书库是否有书，如有则修改图书资料库，书库取书书交读者。书库无书则进行预订处理。用户续借则修改还书日期。并将借书信息汇总后交统计员。
还书操作
还书操作主要完成读者的还书及罚款处理，并修改读者借阅库。首先进行读者资格的审核，符合要求后则修改图书资料库，读者还书书还书库。书籍逾期或遗失则进行罚款处理。并将还书信息汇总后交统计员。
查询处理
查询处理主要完成读者对书是否逾期、书是否未借、书籍排行榜的查询处理。并及时地把查询结果反馈给读者，并将查询信息汇总给统计员。
系统维护
包括权限管理、数据恢复和数据备份。数据恢复和数据备份是对数据的有效保护。权限管理是对系统使用者规定相关的权限，以免系统数据被非法访问和使用。
(访问时需要密码，密码错误要有提示重输，登陆分为管理员登陆和用户登陆两项，用户只能进行查询操作，而管理员能进行所有操作)
#include <string.h>
#include <iostream.h>
class Book{ // 书籍基类
protected:
char Title[40]; // 书名
long Code; // 条码
int Type; // 0表示书，1表示杂志
public:
Book();
Book(char *title,long code);
void SetCode(long code){ Code = code; }
void SetTitle(char* tl){ strcpy(Title,tl); }
void SetType(bool type){Type = type; }
int GetType(){ return Type; }
long GetCode(){ return Code;}
virtual void Show(); // 显示书的信息
friend ostream& operator<<(ostream& , Book&); // 重载插入运算符
friend istream& operator>>(istream& is, Book&); // 重载提取运算符
Book *Next; // 为创建每个读者所借书链表而定义指针
};
class Item :public Book{ //书的款目
// char Title[40]; // 书名
char Author[20]; // 著者名
char IndexCode[10]; // 分类号
// long Code; // 条码
public:
Item();
Item(char *author,char *title,char *index,int code);
Item(Item &);
void SetAuthor(char*);
void SetIndexCode(char*);
virtual void Show(); // 显示书的信息
friend ostream& operator<<(ostream& os, Item&); // 重载插入运算符
friend istream& operator>>(istream& is, Item&); // 重载提取运算符
public:
};
class Magazine:public Book { //杂志类
int Volume;
enum LANG {CHINESE=1,ENGLISH} Lang; // 枚举变量，确定语言类别
public:
Magazine():Book(){Volume = 0; Lang = CHINESE; Type = 1; }
Magazine(char *title,int vol,LANG lang,int code);
Magazine(Magazine&);
void SetVolume(int vol){Volume = vol;}
void SetLang(int lang){Lang = (LANG)lang;}
virtual void Show(); // 显示杂志的信息
friend ostream& operator<<(ostream& os, Magazine&); // 重载插入运算符
friend istream& operator>>(istream& is, Magazine&); // 重载提取运算符
};
class Reader{ // 读者信息类
char Name[20]; // 姓名
char Position[20]; // 职务
int Age; // 年龄
long Code; // 借书证号
Book* items; // 所借书链表
public:
Reader();
Reader(char *name,char *posi,int age,int code);
// Reader(Reader&);
~Reader();
long GetCode(){return Code;}
void SetName(char*);
void SetPosition(char*);
void SetAge(int);
void SetCode(long);
void AddBook(Item); // 添加所借书
void AddBook(Magazine); // 添加所借杂志
void DelBook(Book it); // 还书后减少所借书
void ShowBooks(); // 显示所借书
void Show(); // 显示读者信息
friend ostream& operator<<(ostream& os, Reader&); // 重载插入运算符
friend istream& operator>>(istream& is, Reader&); // 重载提取运算符
public:
int Counter; //计数器，统计所借书数目
};
class Manager{ // 管理员类
char Name[20]; // 姓名
int Age; // 年龄
int Code; // 工号
friend class Library; // 将图书馆类声明为友元
public:
Manager(){}
Manager(char*,int,int);
long GetCode(){ return Code;}
void Show();
friend ostream& operator<<(ostream& os, Manager&); // 重载插入运算符
friend istream& operator>>(istream& is, Manager&); // 重载提取运算符
};
class Loan { // 借阅信息类
int Type; // 0表示书，1表示杂志
Item item; // 借阅书
Magazine mag; // 借阅杂志
Reader reader; // 借阅者
Manager manager; // 借书操作员
int Code;
friend class Library; // 将图书馆类声明为友元
public:
Loan(){ }
Loan(Loan & l);
int GetCode(){ return Code;}
void Show();
friend ostream& operator<<(ostream& os, Loan&); // 重载插入运算符
friend istream& operator>>(istream& is, Loan&); // 重载提取运算符
};
、、、、、、、、、、、、、、、、、、、、、、、
#include<iostream.h>
#include<string.h>
class Reader;
template<typename T> class DblList;
template<typename T> class DblNode{
public:
T Info;//数据域
DblNode<T> *llink,*rlink; //前驱（左链）、后继（右链）指针
public:
DblNode(T data);//一般结点
DblNode();//头结点
T GetInfo(){return Info;};
friend class DblList<T>;
friend class Library;
};
template<typename T>class DblList{
DblNode<T> *head,*current;
public:
DblList();
~DblList();
void Insert(const T& data);
DblNode<T>* Remove(DblNode<T>* p);
void Print();
int Length();//计算链表长度
DblNode<T> *Find(T data);//搜索数据与定值相同的结点
DblNode<T>* Find(int data);//按某个关键字查找
void MakeEmpty(); //清空链表
void ShowList(); //显示链表各结点
friend istream& operator>>(istream&, DblList<typename T>&); // 重载输入流运算符
friend ostream& operator<<(ostream& os, DblList<typename T>& dlist); // 重载输出流运算符
friend class Library;
//其它操作
};
template<typename T> DblNode<T>::DblNode(){
llink=rlink=NULL;
}
template<typename T> DblNode<T>::DblNode(T data){
info=data;
llink=NULL;
rlink=NULL;
}
template<typename T> DblList<T>::DblList(){//建立表头结点
head=new DblNode<T>();
head->rlink=head->llink=head;
current=NULL;
}
template<typename T> DblList<T>::~DblList(){
MakeEmpty();//清空链表
delete head;
}
template<typename T> void DblList<T>::MakeEmpty(){
DblNode<T> *tempP;
while(head->rlink!=head){
tempP=head->rlink;
head->rlink=tempP->rlink;//把头结点后的第一个节点从链中脱离
tempP->rlink->llink=head;//处理左指针
delete tempP; //删除(释放)脱离下来的结点
}
current=NULL; //current指针恢复
}
template<typename T> void DblList<T>::Insert(const T & data){//新节点在链尾
current=new DblNode<T>;
current->Info=data;
current->rlink=head;//注意次序
current->llink=head->llink;
head->llink->rlink=current;
head->llink=current;//最后做
}
template<typename T> DblNode<T>* DblList<T>::Remove(DblNode<T>* p){ // 删除结点
current=head->rlink;
while(current!=head&¤t!=p) current=current->rlink;
if(current==head) current=NULL;
else{//结点摘下
p->llink->rlink=p->rlink;
p->rlink->llink=p->llink;
p->rlink=p->llink=NULL;
}
return current;
}
template<typename T> DblNode<T>* DblList<T>::Find(T data){ // 按结点查找
current=head->rlink;
while(current!=head&¤t->Info!=data) current=current->rlink;
if(current==head) current=NULL;
return current;
}
template<typename T> DblNode<T>* DblList<T>::Find(int data){ // 按数据值查找结点
current=head->rlink;
int temp =current->Info.GetCode();
while(current!=head&&temp!=data){
current=current->rlink;
temp = current->Info.GetCode();
}
if(current==head) current=NULL;
return current;
}
template<typename T> void DblList<T>::Print(){ // 输出链表
current=head->rlink;
while(current!=head){
cout<<current->Info<<'\t';
current=current->rlink;
}
cout<<endl;
}
template<typename T> int DblList<T>::Length(){ // 取得链表长度
int count=0;
current=head->rlink;
while(current!=head){
count++;
current=current->rlink;
}
return count;
}
template<typename T> void DblList<T>::ShowList(){ // 输出链表各结点
int count=0;
current=head->rlink;
while(current!=head){
current->GetInfo().Show();
current=current->rlink;
}
return ;
}
template<typename T>
istream& operator>>(istream& is, DblList<typename T> &dlist){
int len;
T tt; // 定义局部变量读入一个结点
is>>len;
for(int i= 0 ;i<len; i++){ // 循环读入链表各结点
is>>tt;
dlist.Insert(tt);
}
return is;
}
template<typename T>
ostream& operator<<(ostream& os, DblList<typename T> &dlist){
DblNode<T> *tempP;
int len = dlist.Length();
os<<len<<' ';
tempP=dlist.head->rlink;
while(tempP!=dlist.head){ // 循环输出链表各结点
os<<tempP->Info;
tempP = tempP->rlink;
}
return os;
}
#include "class.h"
#include "dblist.h"
#include <fstream.h>
class Library{ // 封装图书馆流通业务的类
DblList<Item> item; // 在馆图书链表
DblList<Magazine> mag; // 在馆杂志链表
DblList<Reader> reader; // 读者链表
DblList<Loan> loan; // 借阅信息链表
DblList<Manager> manager; // 管理员信息链表
int itemNum; // 记录在馆图书数目
int magNum; // 记录在馆杂志数目
int readerNum; // 记录读者数目
int loanNum; // 记录借阅信息数目
int managerNum; // 记录管理员数目
ofstream itemFileOut; // 文件流对象，保存图书馆书籍数据
ifstream itemFileIn; // 文件流对象，读入图书馆书籍数据
ofstream magFileOut; // 文件流对象，保存图书馆杂志数据
ifstream magFileIn; // 文件流对象，读入图书馆杂志数据
ofstream readerFileOut; // 文件流对象，保存图书馆读者数据
ifstream readerFileIn; // 文件流对象，读入图书馆读者数据
ofstream loanFileOut; // 文件流对象，保存图书馆借阅信息数据
ifstream loanFileIn; // 文件流对象，读入图书馆借阅信息
ofstream managerFileOut; // 文件流对象，保存图书馆管理员数据
ifstream managerFileIn; // 文件流对象，读入图书馆管理员数据
public:
Library(); // 构造函数
~Library(); //析构函数
void Run(); // 图书馆类的运行函数
void CreateBibliotheca(); // 创建书目
void CreateReader(); // 创建读者库
void CreateManager(); // 创建管理员信息
int ShowMainMenu(); // 显示主菜单函数
void Borrow(); // 借书操作
void Return(); // 还书操作
void Require(); // 查询操作
void SaveInfo(); // 保存图书馆信息
void OpenInfo(); // 读入图书馆信息
};
多给点分吧