烽麒网

2011
03.07
程序设计实践课作业–图书管理系统

分类: 原创软件 / 标签: C, 图书管理, 程序设计实践 / 添加回复
作业要求：
设计完成图书管理系统，要求要有界面设计，具有增删改查功能，使用结构体和链表实现，结构清晰，代码明确，符合程序设计风格规范，符合人性化设计，并具有一定的使用价值。
单本图书信息（属性）包括：书名，ISBN，英文名，作者名，出版社，价格
整个程序可以模仿例子程序（学生成绩管理系统）。
教师: 中国人民大学信息学院杨刚
示例程序：
学生成绩管理程序
作业程序:
图书管理系统
#include <stdio.h>
 
#include <string.h>
 
#include <ctype.h>
 
#include <stdlib.h>
 
 
 
struct book
 
{
 
    int				intNumber;			    //图书编号
 
    char			chrName[100];           //图书名称
 
    char            chrEngName[100];        //英文名称
 
    char			chrISBN[17];            //ISBN
 
    char            chrAuthor[100];         //作者
 
    char            chrConcern[100];        //出版社
 
    float           floPrice;               //价格
 
    struct book	*next;
 
};
 
typedef struct book BOK;
 
 
 
char Menu(void);
 
BOK *AddData(BOK *head);
 
BOK *AddNode(BOK *head,BOK **pNew);
 
void InputNodeData(BOK *pNew);
 
void PrintData(BOK *head);
 
BOK *DelData(BOK *head);
 
BOK *DelNode(BOK *head,int intNodeNum);
 
void ModifyData(BOK *head);
 
BOK *ModifyNode(BOK *head,int nodeNum);
 
BOK *SearchNode(BOK *head,int nodeNum);
 
void PrintNode(BOK *pNode);
 
void Search(BOK *head);
 
BOK *SearchISBN(BOK *head,char * chrSearchISBN);
 
BOK *SearchPrice(BOK *head,float floSearchPrice);
 
BOK *SearchNodeString(BOK *head,char * chrSearchString);
 
int SearchString(BOK *head);
 
void SortData(BOK *head,int (*compare)(int a ,int b));
 
void IntSwap(int *pt1,int *pt2);
 
void FloSwap(float *pt1,float *pt2);
 
void CharSwap(char *pt1,char *pt2);
 
int ascending(int a, int b);
 
int descending(int a,int b);
 
void DeleteMemory(STU *head);
 
 
 
 
 
int main()
 
{
 
    char ch;
 
    int m;
 
    BOK *head=NULL;
 
    while(1)
 
    {
 
        ch=Menu();               //显示菜单，获取输入
 
        switch (ch)
 
        {
 
            case '1':
 
                head=AddData(head);   //输入数据
 
                break;
 
            case '2':
 
                PrintData(head);      //显示数据
 
                break;
 
            case '3':
 
                head=DelData(head);   //删除数据
 
                break;
 
            case '4':
 
                ModifyData(head);     //修改数据
 
                printf("\n修改后数据\n");
 
                break;
 
            case '5':
 
                Search(head);     //搜索数据
 
                break;
 
            case '6':
 
                SortData(head,descending);  //按图书编号降序排序
 
                printf("\n按图书编号降序排列:\n");
 
                PrintData(head);
 
                break;
 
            case '7':
 
                SortData(head,ascending);   //按图书编号升序排序
 
                printf("\n按图书编号升序排列:\n");
 
                PrintData(head);
 
                break;
 
            case '0':
 
                exit(0);
 
                DeleteMemory(head);
 
                printf("\n退出程序\n");
 
                break;
 
            default:
 
                printf("\n代码错误，请重新输入\n");
 
                break;
 
        }
 
    }
 
    return 0;
 
}
 
 
 
 
 
/*
 
函数功能:  显示菜单并获取用户输入的选项
 
函数参数:  无
 
函数返回值:用户输入的选项
 
*/
 
char Menu(void)
 
{
 
    char ch;
 
    printf("\n图书管理系统\n");
 
    printf("1.添加数据\n");
 
    printf("2.显示数据\n");
 
    printf("3.删除数据\n");
 
    printf("4.修改数据\n");
 
    printf("5.搜索数据\n");
 
    printf("6.按图书编号降序排列\n");
 
    printf("7.按图书编号升序排列\n");
 
    printf("0.退出程序\n");
 
    printf("\n请输入您的选择:\n");
 
    scanf(" %c",&ch);
 
    return ch;
 
}
 
 
 
 
 
/*
 
函数功能:   向链表中添加从键盘输入的图书信息
 
函数参数:   结构体指针head
 
函数返回值: 无
 
*/
 
BOK *AddData(BOK *head)
 
{
 
    int i=0;
 
    char c;
 
    BOK *pNew;
 
 
 
    do
 
    {
 
        head=AddNode(head,&pNew);
 
        InputNodeData(pNew);
 
        printf("是否继续添加新数据(Y/N)?\n");
 
        scanf(" %c",&c);
 
        i++;
 
    }while (c=='Y'||c=='y');
 
    printf("已添加%d个新数据\n",i);
 
    return head;
 
}
 
 
 
 
 
/*
 
函数功能:    新建一个结点，并将该结点添加至链表末尾
 
函数入口参数: 结构体指针变量head，指向原链表头
 
函数出口参数: 结构体指针的指针变量pNew，表示指向新添加节点指针的指针
 
函数返回值:   添加节点后的链表头节点指针
 
*/
 
BOK *AddNode(BOK *head,BOK **pNew)
 
{
 
    BOK *p=NULL;
 
    BOK *pr=head;
 
    p=(BOK *)malloc(sizeof(BOK));
 
    if (p==NULL)                  //分配内存失败
 
    {
 
        printf("内存不足\n");
 
        exit(0);
 
        return head;
 
    }
 
    if (head==NULL)        //头指针为空，添加首节点
 
    {
 
        head=p;
 
    }
 
    else
 
    {
 
        while(pr->next !=NULL) //移动指针pr到表尾
 
        {
 
            pr = pr->next;
 
        }
 
        pr->next=p;       //添加新节点到表尾巴
 
    }
 
    pr=p;
 
    pr->next=NULL;
 
    *pNew=p;
 
    return head;
 
}
 
 
 
 
 
/*
 
函数功能: 输入一个节点的数据
 
函数参数: 结构体指针变量pNew,表示链表新添加节点的指针
 
返回参数: 无
 
*/
 
void InputNodeData(BOK *pNew)
 
{
 
    int intTmp;
 
    float floTmp;
 
    char chrTmp;
 
    printf("\n请输入新数据\n");
 
    printf("\n请输入图书编号\n");
 
    scanf("%d",&pNew->intNumber);
 
    chrTmp=getchar();
 
    printf("请输入书名\n");
 
    memset(pNew->chrName,'\0',100);
 
    gets(pNew->chrName);
 
    printf("请输入英文名\n");
 
    memset(pNew->chrEngName,'\0',100);
 
    gets(pNew->chrEngName);
 
    printf("请输入作者\n");
 
    memset(pNew->chrAuthor,'\0',100);
 
    gets(pNew->chrAuthor);
 
    printf("请输入ISBN\n");
 
    memset(pNew->chrISBN,'\0',17);
 
    gets(pNew->chrISBN);
 
    printf("请输入出版社\n");
 
    memset(pNew->chrConcern,'\0',100);
 
    gets(pNew->chrConcern);
 
    printf("请输入价格\n");
 
    scanf("%f",&pNew->floPrice);
 
    return;
 
}
 
 
 
 
 
/*
 
函数功能: 显示所有已经建立好的节点的节点号和数据
 
函数参数: 结构体指针变量head，表示链表头结点指针
 
函数返回值: 无
 
*/
 
void PrintData(BOK *head)
 
{
 
    BOK *p= head;
 
    if(p==NULL)
 
    {
 
        printf("无数据，请先增加数据\n");
 
        return ;
 
    }
 
    printf("\n编号\t     书名\t英文名\t\t作者\tISBN\t出版社\t价格\t\n");
 
    while(p!=NULL)   //不是表尾
 
    {
 
        printf("No.%.3d %10s %10s %10s %s %15s %3f\n",p->intNumber,p->chrName,p->chrEngName,p->chrAuthor,p->chrISBN,p->chrConcern,p->floPrice);
 
        p=p->next;
 
    }
 
    return ;
 
}
 
 
 
 
 
/*
 
函数功能: 删除指定编号的记录
 
函数参数: 结构体指针head，指向链表首地址
 
函数返回值: 删除后新链表头指针
 
*/
 
BOK *DelData(BOK *head)
 
{
 
    int intNodeNum;
 
    char c;
 
    int i;
 
 
 
    do
 
    {
 
        printf("请输入您要删除的图书编码:\n");
 
        scanf("%d",&intNodeNum);
 
        head=DelNode(head,intNodeNum);
 
        PrintData(head);
 
        printf("是否继续删除数据(Y/N)?\n");
 
        scanf(" %c",&c);
 
        i++;
 
    }while(c=='Y'||c=='y');
 
    printf("共删除%d个数据\n",i);
 
    return head;
 
}
 
 
 
 
 
/*
 
函数功能: 删除一个结点数据为nodeNum的节点
 
函数参数: 结构体指针变量head，原节点头指针
 
         整型变量intNodeNum,表示待删除节点数据值
 
返回值:   删除后新链表头指针
 
*/
 
BOK *DelNode(BOK *head,int intNodeNum)
 
{
 
    BOK *p=head,*pr=head;
 
    if(head=NULL)
 
    {
 
        printf("无数据\n");
 
        return head;
 
    }
 
 
 
    while(intNodeNum != p->intNumber && p->next !=NULL)
 
    {
 
        pr=p;
 
        p=p->next;
 
    }
 
    if(intNodeNum == p->intNumber) //找到节点，删除
 
    {
 
        if(p==head) //首节点
 
        {
 
            head=p->next;
 
        }
 
        else
 
        {
 
            pr->next=p->next;
 
        }
 
        free(p);
 
    }
 
    else
 
    {
 
        printf("没有找到待删除数据\n");
 
    }
 
    return head;
 
}
 
 
 
 
 
/*
 
函数功能: 修改制定图书编号的数据
 
函数参数: 结构体指针head指向链表首地址
 
返回值: 修改后链表的头指针
 
*/
 
void ModifyData(BOK *head)
 
{
 
    int i=0,nodeNum;
 
    char c;
 
 
 
    do
 
    {
 
        printf("请输入你要修改的数据编号:\n");
 
        scanf("%d",&nodeNum);
 
        head=ModifyNode(head,nodeNum);
 
        printf("是否还要继续修改数据(Y/N)?\n");
 
        scanf(" %c",&c);
 
        i++;
 
    }while (c=='Y'||c=='y');
 
    printf("共修改%d个数据\n",i);
 
    return ;
 
}
 
 
 
 
 
/*
 
函数功能: 按图书编号查找并修改一个节点数据
 
函数参数: 结构体指针head指向链表头地址，整型变量nodeNum表示待修改图书编号
 
返回值:   修改后节点的头指针
 
*/
 
BOK *ModifyNode(BOK *head,int nodeNum)
 
{
 
    int j;
 
    BOK *newNode;
 
    char c;
 
    char chrTmp;
 
 
 
    newNode= SearchNode(head,nodeNum);
 
    if(newNode==NULL)
 
    {
 
        printf("未找到数据\n");
 
    }
 
    else
 
    {
 
        while(1)
 
        {
 
            printf("请选择要修改的数据项\n");
 
            printf("\n1.图书编号\n");
 
            printf("2.书名\n");
 
            printf("3.英文名\n");
 
            printf("4.作者\n");
 
            printf("5.出版社\n");
 
            printf("6.ISBN\n");
 
            printf("7.价格\n");
 
            printf("\n0.完成修改，返回主菜单\n");
 
            scanf(" %c",&c);
 
 
 
            switch(c)
 
            {
 
                case '1':
 
                    printf("请输入新图书编号:\n");
 
                    scanf("%d",newNode->intNumber);
 
                    break;
 
                case '2':
 
                    printf("请输入新书名:\n");
 
                    chrTmp=getchar();
 
                    memset(newNode->chrName,'\0',100);
 
                    gets(newNode->chrName);
 
                    break;
 
                case '3':
 
                    printf("请输入新英文名:\n");
 
                    chrTmp=getchar();
 
                    memset(newNode->chrEngName,'\0',100);
 
                    gets(newNode->chrEngName);
 
                    break;
 
                case '4':
 
                    printf("请输入新作者:\n");
 
                    chrTmp=getchar();
 
                    memset(newNode->chrAuthor,'\0',100);
 
                    gets(newNode->chrAuthor);
 
                    break;
 
                case '5':
 
                    printf("请输入新出版社:\n");
 
                    chrTmp=getchar();
 
                    memset(newNode->chrConcern,'\0',100);
 
                    gets(newNode->chrConcern);
 
                    break;
 
                case '6':
 
                    printf("请输入新ISBN:\n");
 
                    chrTmp=getchar();
 
                    memset(newNode->chrISBN,'\0',17);
 
                    gets(newNode->chrISBN);
 
                    break;
 
                case '7':
 
                    printf("请输入新价格:\n");
 
                    scanf("%f",newNode->floPrice);
 
                    break;
 
                case '0':
 
                    return head;
 
                    break;
 
                default:
 
                    printf("输入错误，请重新输入\n");
 
                    break;
 
            }
 
            PrintNode(newNode);   //显示修改后信息
 
        }
 
    }
 
    return head;
 
}
 
 
 
 
 
/*
 
函数功能: 按图书编号查找一个节点数据
 
函数参数: 结构体指针变量head，表示头指针
 
         整型变量nodeNum表示待搜索的图书编号
 
返回值:   目标节点的指针
 
*/
 
BOK *SearchNode(BOK *head,int nodeNum)
 
{
 
    BOK *p=head;
 
    while(p!=NULL)
 
    {
 
        if(p->intNumber==nodeNum)
 
        {
 
            return p;
 
        }
 
        p=p->next;
 
    }
 
    return NULL;
 
}
 
 
 
 
 
/*
 
函数功能: 显示指定节点的数据
 
函数参数: 结构体指针变量pNode，表示目标结点指针
 
函数返回值: 无
 
*/
 
void PrintNode(BOK *pNode)
 
{
 
    if(pNode==NULL)
 
    {
 
        return;
 
    }
 
    printf("编号\t书名\t\t英文名\t\t作者\tISBN\t出版社\t价格\t\n");
 
    printf("No.%.3d%30s%15s%15s%s%15s%3f\n",pNode->intNumber,pNode->chrName,pNode->chrEngName,pNode->chrAuthor,pNode->chrISBN,pNode->chrConcern,pNode->floPrice);
 
    return ;
 
}
 
 
 
 
 
/*
 
函数功能: 显示搜索功能菜单
 
函数参数: 结构体指针变量head
 
返回值:  无
 
*/
 
void Search(BOK *head)
 
{
 
    char c;
 
    int intSearchNum;
 
    char chrSearch[100];
 
    char chrSearchISBN[17];
 
    float floSearchPrice;
 
    BOK *findNode;
 
    char chrTmp;
 
    int intSearchResult;
 
 
 
    if(head==NULL)
 
    {
 
        printf("没有数据,请先增加数据\n");
 
        return;
 
    }
 
    while(1)
 
    {
 
        printf("\n请选择您要搜索的数据项:\n");
 
        printf("\n1.图书编号\n");
 
        printf("2.ISBN\n");
 
        printf("3.价格\n");
 
        printf("4.书名、英文名、作者、出版社\n");
 
        printf("\n0.完成搜索，返回主菜单\n");
 
        scanf(" %c",&c);
 
 
 
        switch (c)
 
        {
 
            case '1':
 
                printf("\n请输入您要搜索的图书编号:\n");
 
                scanf("%d",&intSearchNum);
 
                findNode=SearchNode(head,intSearchNum);
 
                if(findNode==NULL)
 
                {
 
                    printf("未找到\n");
 
                    break;
 
                }
 
                PrintNode(findNode);
 
                return;
 
                break;
 
            case '2':
 
                printf("请输入您要搜索的ISBN:\n");
 
                chrTmp=getchar();
 
                memset(chrSearchISBN,'\0',17);
 
                gets(chrSearchISBN);
 
                findNode=SearchISBN(head,chrSearchISBN);
 
                if(findNode==NULL)
 
                {
 
                    printf("未找到\n");
 
                    break;
 
                }
 
                PrintNode(findNode);
 
                return;
 
                break;
 
            case '3':
 
                printf("请输入您要搜索的价格:\n");
 
                scanf("%f",&floSearchPrice);
 
                findNode=SearchPrice(head,floSearchPrice);
 
                if(findNode==NULL)
 
                {
 
                    printf("未找到\n");
 
                    break;
 
                }
 
                PrintNode(findNode);
 
                return;
 
                break;
 
            case '4':
 
                printf("请输入您要搜索的关键词:\n");
 
                intSearchResult=SearchString(head);
 
                if(intSearchResult==1)  //找到，返回主菜单 
 
                {
 
                    return;
 
                }
 
                break;
 
            case '0':
 
                return;
 
                break;
 
            default:
 
                printf("输入错误，请重新输入:\n");
 
                break;
 
        }
 
    }
 
}
 
 
 
 
 
/*
 
函数功能: 按ISBN搜索数据
 
函数参数: 结构体指针变量head，要搜索的ISBN码
 
返回值: 找到的节点指针
 
*/
 
BOK *SearchISBN(BOK *head,char * chrSearchISBN)
 
{
 
    BOK *p=head;
 
    int intCmpResult;
 
    while(p!=NULL)
 
    {
 
        intCmpResult=strcmp(p->chrISBN,chrSearchISBN);
 
        if(intCmpResult==0)
 
        {
 
            return p;
 
        }
 
        p=p->next;
 
    }
 
    return NULL;
 
}
 
 
 
 
 
/*
 
函数功能: 按价格搜索数据
 
函数参数: 结构体指针变量head，要搜索的价格
 
返回值: 找到的节点指针
 
*/
 
BOK *SearchPrice(BOK *head,float floSearchPrice)
 
{
 
    BOK *p=head;
 
    while(p!=NULL)
 
    {
 
        if(p->floPrice==floSearchPrice)
 
        {
 
            return p;
 
        }
 
        p=p->next;
 
    }
 
    return NULL;
 
}
 
 
 
/*
 
函数功能: 按书名、英文名、作者、出版社搜索数据
 
函数参数: 结构体指针变量head，要搜索的字符串
 
返回值: 找到的节点指针
 
*/
 
BOK *SearchNodeString(BOK *head,char * chrSearchString)
 
{
 
    BOK *p=head;
 
    int intCmpResult;
 
    while(p!=NULL)
 
    {
 
        intCmpResult=strcmp(p->chrName,chrSearchString)*strcmp(p->chrEngName,chrSearchString)*strcmp(p->chrAuthor,chrSearchString)*strcmp(p->chrConcern,chrSearchString);  //有任意一项为0则整个结果为0 
 
        if(intCmpResult==0)
 
        {
 
            return p;
 
        }
 
        p=p->next;
 
    }
 
    return NULL;
 
}
 
 
 
/*
 
函数功能: 按书名、英文名、作者、出版社搜索数据
 
函数参数: 结构体指针head
 
返回值:   找到返回1，未找到返回0 
 
*/
 
int SearchString(BOK *head)
 
{
 
    BOK *findNode;
 
    char chrSearch[100];
 
    char chrTmp;
 
    chrTmp=getchar();
 
    memset(chrSearch,'\0',17);
 
    gets(chrSearch);
 
    findNode=SearchNodeString(head,chrSearch);
 
    if(findNode==NULL)
 
    {
 
        printf("未找到\n");
 
        return 0;
 
    }
 
    PrintNode(findNode);
 
    return 1;
 
}
 
 
 
 
 
/*
 
函数功能: 用交换法按编码排序
 
函数参数: 结构体指针head，对比函数
 
返回值:   无
 
*/
 
void SortData(BOK *head,int (*compare)(int a ,int b))
 
{
 
    BOK *pt;
 
    int flag=0,i;
 
 
 
    do
 
    {
 
        flag=0;
 
        pt=head;
 
        while(pt->next != NULL)
 
        {
 
            if((*compare)(pt->next->intNumber,pt->intNumber))
 
            {
 
                IntSwap(&pt->intNumber,&pt->next->intNumber);
 
                CharSwap(pt->chrName,pt->next->chrName);
 
                CharSwap(pt->chrEngName,pt->next->chrEngName);
 
                CharSwap(pt->chrAuthor,pt->next->chrAuthor);
 
                CharSwap(pt->chrConcern,pt->next->chrConcern);
 
                FloSwap(&pt->floPrice,&pt->next->floPrice);
 
                CharSwap(pt->chrISBN,pt->next->chrISBN);
 
                flag=1;
 
            }
 
            pt=pt->next;
 
        }
 
    }while(flag);
 
}
 
 
 
 
 
//交换两个整型数
 
void IntSwap(int *pt1, int *pt2)
 
{
 
    int temp;
 
 
 
    temp = *pt1;
 
    *pt1 = *pt2;
 
    *pt2 = temp;
 
    return;
 
}
 
 
 
 
 
//交换两个实型数
 
void FloSwap(float *pt1, float *pt2)
 
{
 
    float temp;
 
 
 
    temp = *pt1;
 
    *pt1 = *pt2;
 
    *pt2 = temp;
 
    return;
 
}
 
 
 
 
 
//交换两个字符串
 
void CharSwap(char *pt1, char *pt2)
 
{
 
    char temp[15];
 
 
 
    strcpy(temp, pt1);
 
    strcpy(pt1, pt2);
 
    strcpy(pt2, temp);
 
    return;
 
}
 
 
 
 
 
//决定数据是否按升序排序,a<b为真,则按升序排序
 
int ascending(int a, int b)
 
{
 
    return a < b;
 
}
 
 
 
 
 
//决定数据是否按降序排序,a>b为真,则按降序排序
 
int descending(int a, int b)
 
{
 
    return a > b;
 
}
 
 
 
/*
 
函数功能：释放head指向的链表中所有节点占用的内存
 
输入参数：结构体指针变量head，表示链表的头节点指针
 
返回参数：无
 
*/
 
void DeleteMemory(STU *head)
 
{
 
	STU *p = head, *pr = NULL;
 
 
 
	while (p != NULL)           	/*若不是表尾，则释放节点占用的内存*/
 
	{	
 
		pr = p;                  	/*在pr中保存当前节点的指针*/
 
		p = p->next;            	/*让p指向下一个节点*/
 
		free(pr);                	/*释放pr指向的当前节点占用的内存*/
 
	}            
 
}
暂无回复

添加回复
程序设计实践课作业–图书管理系统

暂无回复

你的回复

分类目录

近期评论

友情链接

文章归档
