编程题实训-基于链表的图书信息管理

原创 于 2024-01-15 21:13:22 发布 · 2.1k 阅读 · 40 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#链表 #数据结构 #c++

博客围绕基于链式存储结构的图书信息表展开，包含创建输出、查找、入库、出库、去重等操作。介绍了各操作的任务描述、编程要求，给出输入输出示例及测试说明，使用C++语言结合链表数据结构完成相关功能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

第1关：基于链式存储结构的图书信息表的创建和输出

任务描述
本关任务：定义一个包含图书信息（书号、书名、价格）的链表，读入相应的图书数据来完成图书信息表的创建，然后统计图书表中的图书个数，同时逐行输出每本图书的信息。

编程要求
输入
输入n+1行，其中前n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。最后第n+1行是输入结束标志：0 0 0（空格分隔的三个0）。其中书号和书名为字符串类型，价格为浮点数类型。

输出
总计n+1行，第1行是所创建的图书表中的图书个数，后n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔。其中价格输出保留两位小数。

测试说明
平台会对你编写的代码进行测试：

测试输入：
9787302257646 Data-Structure 35.00
9787302164340 Operating-System 50.00
9787302219972 Software-Engineer 32.00
9787302203513 Database-Principles 36.00
9787810827430 Discrete-Mathematics 36.00
9787302257800 Data-Structure 62.00
9787811234923 Compiler-Principles 62.00
9787822234110 The-C-Programming-Language 38.00
0 0 0
预期输出：
8
9787302257646 Data-Structure 35.00
9787302164340 Operating-System 50.00
9787302219972 Software-Engineer 32.00
9787302203513 Database-Principles 36.00
9787810827430 Discrete-Mathematics 36.00
9787302257800 Data-Structure 62.00
9787811234923 Compiler-Principles 62.00
9787822234110 The-C-Programming-Language 38.008

#include<iostream>
#include<string.h>
#include<iomanip>
#define OK 1
#define ERROR 0
#define OVERFLOW -2
using namespace std;
typedef struct
{//图书信息定义
    char no[20];    //图书ISBN
    char name[50];   //图书名字
    float price;   //图书价格
}Book;
typedef struct LNode
{//图书信息表的链式存储结构
    Book data;    	   //结点的数据域
    int length;       //链表的表长，即图书表中图书个数
    struct LNode *next; //指针域
}LNode,*LinkList;
int InitList_L(LinkList &L)
{//构造一个空的单链表L
    L=new LNode;
    L->next=NULL;
    return OK;
}
int Input_L(LinkList &L)
{//链表的输入
/**************begin************/
LNode *p=L;
int count =0;
while(true)
{
    Book book;
    cin>>book.no>>book.name>>book.price;
    if(strcmp(book.no,"0")==0&&strcmp(book.name,"0")==0&&book.price==0)
    {
        break;
    }
    LNode *newNode=new LNode;
    newNode->data=book;
    p->next=newNode;
    p=p->next;
    count++;
}
p->next=NULL;
L->length=count;
return OK;



    /**************end************/
}
int  Length_L(LinkList &L)
{//求链表的表长，即图书表中图书个数
/**************begin************/
return L->length;


    /**************end************/
}
int Output_L(LinkList L)
{//链表的输出
/**************begin************/
LNode *p=L->next;
cout<<L->length<<endl;
while(p)
{
    cout<<p->data.no<<" "<<p->data.name<<" "<<fixed<<setprecision(2)<<p->data.price<<endl;
    p=p->next;

}
return OK;

    /**************end************/
}
int main()
{
    LinkList L;        		//定义一个LinkList类型的变量L
    InitList_L(L);    		//初始化一个空的链表L
    Input_L(L);        		//输入链表数据
    Length_L(L);    		//求链表的表长并输出
    Output_L(L);    		//输出链表数据
    return 0;
}

第6关：基于链式存储结构的图书信息表的最爱图书的查找

任务描述
本关任务：定义一个包含图书信息（书号、书名、价格）的链表，读入相应的图书数据来完成图书信息表的创建，然后根据指定的最爱图书的名字，查找最爱的图书，输出相应图书的信息。

编程要求
输入
总计n+m+2行。首先输入n+1行，其中，第一行是图书数目n，后n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。其中书号和书名为字符串类型，价格为浮点数类型。然后输入m+1行，其中，第一行是一个整数m，代表查找m次，后m行是每次待查找的最爱图书名字。

输出
若查找成功： 总计输出m*（k+1）行，对于每一次查找，第一行是最爱图书数目（同一书名的图书可能有多本），后k行是最爱图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，其中价格输出保留两位小数。 若查找失败： 只输出以下提示：抱歉，没有你的最爱！

测试说明
平台会对你编写的代码进行测试：

测试输入：
8
9787302257646 Data-Structure 35.00
9787302164340 Operating-System 50.00
9787302219972 Software-Engineer 32.00
9787302203513 Database-Principles 36.00
9787810827430 Discrete-Mathematics 36.00
9787302257800 Data-Structure 62.00
9787811234923 Compiler-Principles 62.00
9787822234110 The-C-Programming-Language 38.00
2
Java-Programming-Language
Data-Structure
预期输出：
Sorry，there is no your favourite!
2
9787302257646 Data-Structure 35.00
9787302257800 Data-Structure 62.00

#include<iostream>
#include<string.h>
#include<iomanip>
#define OK 1
#define ERROR 0
#define OVERFLOW -2
using namespace std;
typedef struct
{//图书信息定义
    char no[20];    //图书ISBN
    char name[50];   //图书名字
    float price;   //图书价格
}Book;
typedef struct LNode
{//图书信息表的链式存储结构
    Book data;    	   //结点的数据域
    int length;       //链表的表长，即图书表中图书个数
    struct LNode *next; //指针域
}LNode,*LinkList;
int InitList_L(LinkList &L)
{//构造一个空的单链表L
    L=new LNode;
    L->next=NULL;
    return OK;
}
int Input_L(LinkList &L)
{//链表的输入
    LinkList p=L;      //初始化p指向链表的头结点
    int n;
    cin>>n;
    while(n--)             	     //后插法创建链表
    {
        LinkList q=new LNode;        //生成新结点*q
        cin>>q->data.no>>q->data.name>>q->data.price;//输入数据
        q->next=NULL;                                 //尾指针置为NULL
        p->next=q;                   //将新结点*q插入尾结点*p之后
        p=q;                         //更新指针p，将p指向新的尾结点*q
    }
    return OK;
}
int FindFavorite_L(LinkList &L)
{//查找的最爱图书并输出数据
/**************begin************/
int m;
cin>>m;
while(m--)
{
    char favorite[50];
    cin>>favorite;
    int count=0;
    LinkList p=L->next;
    while(p!=NULL)
    {
        if(strcmp(p->data.name,favorite)==0)
        {
            count++;
        }
        p=p->next;
    }
    if(count>0)
    {
        cout<<count<<endl;
        p=L->next;
        while(p!=NULL)
        {
            if(strcmp(p->data.name,favorite)==0)
            {
                cout<<p->data.no<<" "<<p->data.name<<" "<<fixed<<setprecision(2)<<p->data.price<<endl;
            }
            p=p->next;
        }
    }
    else
    {
        cout<<"Sorry，there is no your favourite!"<<endl;
    }
}

return OK;






    /**************end************/
}
int main()
{
    LinkList L;                         //定义一个LinkList类型的变量L
    InitList_L(L);                    	//初始化一个空的链表L
    Input_L(L);                        	//输入链表数据
    FindFavorite_L(L);                	//查找的最爱图书并输出数据
    return 0;
}

第8关：基于链式存储结构的图书信息表的新图书的入库

任务描述
本关任务：定义一个包含图书信息（书号、书名、价格）的链表，读入相应的图书数据来完成图书信息表的创建，然后根据指定的待入库的新图书的位置和图书的信息，将新图书插入到图书表中指定的位置上，最后输出新图书入库后的所有图书的信息。

编程要求
输入
总计n+3行。首先输入n+1行，其中，第一行是图书数目n，后n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。其中书号和书名为字符串类型，价格为浮点数类型。之后输入第n+2行，内容仅为一个整数，代表待入库的新图书的位置序号。最后输入第n+3行，内容为新图书的信息，书号、书名、价格用空格分隔。

输出
若插入成功： 输出新图书入库后所有图书的信息（书号、书名、价格），总计n+1行，每行是一本图书的信息，书号、书名、价格用空格分隔。其中价格输出保留两位小数。 若插入失败： 只输出以下一行提示：抱歉，入库位置非法！

测试说明
平台会对你编写的代码进行测试：

测试输入：
7
9787302257646 Data-Structure 35.00
9787302164340 Operating-System 50.00
9787302219972 Software-Engineer 32.00
9787302203513 Database-Principles 36.00
9787810827430 Discrete-Mathematics 36.00
9787302257800 Data-Structure 62.00
9787811234923 Compiler-Principles 62.00
2
9787822234110 The-C-Programming-Language 38.00
预期输出：
9787302257646 Data-Structure 35.00
9787822234110 The-C-Programming-Language 38.00
9787302164340 Operating-System 50.00
9787302219972 Software-Engineer 32.00
9787302203513 Database-Principles 36.00
9787810827430 Discrete-Mathematics 36.00
9787302257800 Data-Structure 62.00
9787811234923 Compiler-Principles 62.00

测试输入：
7
9787302257646 Data-Structure 35.00
9787302164340 Operating-System 50.00
9787302219972 Software-Engineer 32.00
9787302203513 Database-Principles 36.00
9787810827430 Discrete-Mathematics 36.00
9787302257800 Data-Structure 62.00
9787811234923 Compiler-Principles 62.00
9
9787822234110 The-C-Programming-Language 38.00
预期输出：
Sorry，the position to be inserted is invalid!

#include<iostream>
#include<iomanip>
#define OK 1
#define ERROR 0
#define OVERFLOW -2
using namespace std;
typedef struct
{//图书信息定义
    char no[20];    //图书ISBN
    char name[50];   //图书名字
    float price;   //图书价格
}Book;
typedef struct LNode
{//图书信息表的链式存储结构
    Book data;    	   //结点的数据域
    int length;       //链表的表长，即图书表中图书个数
    struct LNode *next; //指针域
}LNode,*LinkList;
int InitList_L(LinkList &L)
{//构造一个空的单链表L
    L=new LNode;
    L->next=NULL;
    return OK;
}
int Input_L(LinkList &L)
{//链表的输入
    LinkList p=L;      //初始化p指向链表的头结点
    int n;
    cin>>n;
    while(n--)             	     //后插法创建链表
    {
        LinkList q=new LNode;        //生成新结点*q
        cin>>q->data.no>>q->data.name>>q->data.price;//输入数据
        q->next=NULL;                                 //尾指针置为NULL
        p->next=q;                   //将新结点*q插入尾结点*p之后
        p=q;                         //更新指针p，将p指向新的尾结点*q
    }
    return OK;
}
int  Length_L(LinkList &L)
{//求链表的表长，即图书表中图书个数
    LinkList p=L;                 //初始化p指向链表的头结点
    L->length=0;                  //初始化链表的表长L->length为0
    while(p->next)                //下一个结点存在时
    {
        L->length++;              //链表的表长+1
        p=p->next;                //更新指针p，指向下一个结点
    }
    return OK;
}
int Insert_L(LinkList &L)
{//将新图书入库并输出
/**************begin************/
  int n;
  cin>>n;
  LinkList p=L;
  for(int i=0;i<n-1;i++)
  {
      p=p->next;
      if(p==NULL)
      {
          cout<<"Sorry，the position to be inserted is invalid!"<<endl;
          return ERROR;
      }
  }
LinkList q=new LNode;
cin>>q->data.no>>q->data.name>>q->data.price;
q->next=p->next;
p->next=q;
p=L->next;
while(p)
{
    cout<<p->data.no<<" "<<p->data.name<<" "<<fixed<<setprecision(2)<<p->data.price<<endl;
    p=p->next;
}

return OK;


    /**************end************/
}
int main()
{
    LinkList L;                         //定义一个LinkList类型的变量L
    InitList_L(L);                    	//初始化一个空的链表L
    Input_L(L);                        	//输入链表数据
    Length_L(L);                    	//求链表的表长
    Insert_L(L);                    	//将新图书入库并输出
    return 0;
}

第9关：基于链式存储结构的图书信息表的旧图书的出库

任务描述
本关任务：定义一个包含图书信息（书号、书名、价格）的链表，读入相应的图书数据来完成图书信息表的创建，然后根据指定的待出库的旧图书的位置，将该图书从图书表中删除，最后输出该图书出库后的所有图书的信息。

编程要求
输入
总计n+2行。首先输入n+1行，其中，第一行是图书数目n，后n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。其中书号和书名为字符串类型，价格为浮点数类型。之后输入第n+2行，内容仅为一个整数，代表待删除的旧图书的位置序号。

输出
若删除成功： 输出旧图书出库后所有图书的信息（书号、书名、价格），总计n-1行，每行是一本图书的信息，书号、书名、价格用空格分隔。其中价格输出保留两位小数。 若删除失败： 只输出以下一行提示：抱歉，出库位置非法！

测试说明
平台会对你编写的代码进行测试：

测试输入：
8
9787302257646 Data-Structure 35.00
9787302164340 Operating-System 50.00
9787302219972 Software-Engineer 32.00
9787302203513 Database-Principles 36.00
9787810827430 Discrete-Mathematics 36.00
9787302257800 Data-Structure 62.00
9787811234923 Compiler-Principles 62.00
9787822234110 The-C-Programming-Language 38.00
2
预期输出：
9787302257646 Data-Structure 35.00
9787302219972 Software-Engineer 32.00
9787302203513 Database-Principles 36.00
9787810827430 Discrete-Mathematics 36.00
9787302257800 Data-Structure 62.00
9787811234923 Compiler-Principles 62.00
9787822234110 The-C-Programming-Language 38.00

测试输入：
8
9787302257646 Data-Structure 35.00
9787302164340 Operating-System 50.00
9787302219972 Software-Engineer 32.00
9787302203513 Database-Principles 36.00
9787810827430 Discrete-Mathematics 36.00
9787302257800 Data-Structure 62.00
9787811234923 Compiler-Principles 62.00
9787822234110 The-C-Programming-Language 38.00
9
预期输出：
Sorry，the position to be deleted is invalid!

#include<iostream>
#include<iomanip>
#define OK 1
#define ERROR 0
#define OVERFLOW -2
using namespace std;
typedef struct
{//图书信息定义
    char no[20];    //图书ISBN
    char name[50];   //图书名字
    float price;   //图书价格
}Book;
typedef struct LNode
{//图书信息表的链式存储结构
    Book data;    	   //结点的数据域
    int length;       //链表的表长，即图书表中图书个数
    struct LNode *next; //指针域
}LNode,*LinkList;
int InitList_L(LinkList &L)
{//构造一个空的单链表L
    L=new LNode;
    L->next=NULL;
    return OK;
}
int Input_L(LinkList &L)
{//链表的输入
    LinkList p=L;      //初始化p指向链表的头结点
    int n;
    cin>>n;
    while(n--)             	     //后插法创建链表
    {
        LinkList q=new LNode;        //生成新结点*q
        cin>>q->data.no>>q->data.name>>q->data.price;//输入数据
        q->next=NULL;                                 //尾指针置为NULL
        p->next=q;                   //将新结点*q插入尾结点*p之后
        p=q;                         //更新指针p，将p指向新的尾结点*q
    }
    return OK;
}
int  Length_L(LinkList &L)
{//求链表的表长，即图书表中图书个数
    LinkList p=L;                 //初始化p指向链表的头结点
    L->length=0;                  //初始化链表的表长L->length为0
    while(p->next)                //下一个结点存在时
    {
        L->length++;              //链表的表长+1
        p=p->next;                //更新指针p，指向下一个结点
    }
    return OK;
}
int Delete_L(LinkList &L)
{//出库旧图书并输出
/**************begin************/
    int deletePos;
    cin >> deletePos;
    if (deletePos < 1 || deletePos > L->length) {
        cout << "Sorry，the position to be deleted is invalid!" << endl;
        return ERROR;
    }
    
    LinkList p = L;
    for (int i = 1; i < deletePos; i++) {
        p = p->next;
    }
    
    LinkList q = p->next;
    p->next = q->next;
    delete q;
    
    LinkList temp = L->next;
    while (temp) {
        cout << temp->data.no << " " << temp->data.name << " " << fixed << setprecision(2) << temp->data.price << endl;
        temp = temp->next;
    }
    
   
    return OK;

    
    /**************end************/
}
int main()
{
    LinkList L;                         //定义一个LinkList类型的变量L
    InitList_L(L);                      //初始化一个空的链表L
    Input_L(L);                         //输入链表数据
    Length_L(L);                        //求链表的表长
    Delete_L(L);                        //出库旧图书并输出
    return 0;
}

第10关：基于链存储结构的图书信息表的图书去重

任务描述
本关任务：出版社出版的任何一本图书的书号（ISBN）都是唯一的，即图书表中不允许包含书号重复的图书。定义一个包含图书信息（书号、书名、价格）的链表，读入相应的图书数据来完成图书信息表的创建（书号可能重复），然后进行图书的去重，即删除书号重复的图书（只保留第一本），最后输出去重后所有图书的信息。

编程要求
输入
总计输入n+1行，其中，第一行是图书数目n，后n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格（书号可能重复）。其中书号和书名为字符串类型，价格为浮点数类型。

输出
总计输出m+1行（m≤n），其中，第一行是去重后的图书数目，后m行是去重后图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，其中价格输出保留两位小数。

测试说明
平台会对你编写的代码进行测试：

测试输入：
9
9787302257646 Data-Structure 35.00
9787302164340 Operating-System 50.00
9787302219972 Software-Engineer 32.00
9787302203513 Database-Principles 36.00
9787810827430 Discrete-Mathematics 36.00
9787302257800 Data-Structure 62.00
9787811234923 Compiler-Principles 62.00
9787811234923 Compiler-Principles 62.00
9787822234110 The-C-Programming-Language 38.00
预期输出：
8
9787302257646 Data-Structure 35.00
9787302164340 Operating-System 50.00
9787302219972 Software-Engineer 32.00
9787302203513 Database-Principles 36.00
9787810827430 Discrete-Mathematics 36.00
9787302257800 Data-Structure 62.00
9787811234923 Compiler-Principles 62.00
9787822234110 The-C-Programming-Language 38.00

#include<iostream>
#include<string.h>
#include<iomanip>
#define OK 1
#define ERROR 0
#define OVERFLOW -2
using namespace std;
typedef struct
{//图书信息定义
    char no[20];    //图书ISBN
    char name[50];   //图书名字
    float price;   //图书价格
}Book;
typedef struct LNode
{//图书信息表的链式存储结构
    Book data;    	   //结点的数据域
    int length;       //链表的表长，即图书表中图书个数
    struct LNode *next; //指针域
}LNode,*LinkList;
int InitList_L(LinkList &L)
{//构造一个空的单链表L
    L=new LNode;
    L->next=NULL;
    return OK;
}
int Input_L(LinkList &L)
{//链表的输入
    LinkList p=L;      //初始化p指向链表的头结点
    int n;
    cin>>n;
    while(n--)             	     //后插法创建链表
    {
        LinkList q=new LNode;        //生成新结点*q
        cin>>q->data.no>>q->data.name>>q->data.price;//输入数据
        q->next=NULL;                                 //尾指针置为NULL
        p->next=q;                   //将新结点*q插入尾结点*p之后
        p=q;                         //更新指针p，将p指向新的尾结点*q
    }
    return OK;
}
int  Length_L(LinkList &L)
{//求链表的表长，即图书表中图书个数
    LinkList p=L;                 //初始化p指向链表的头结点
    L->length=0;                  //初始化链表的表长L->length为0
    while(p->next)                //下一个结点存在时
    {
        L->length++;              //链表的表长+1
        p=p->next;                //更新指针p，指向下一个结点
    }
    return OK;
}
int DupRemoval_L(LinkList &L)
{//图书去重
/**************begin************/
LinkList p = L->next;            

while (p)
{
    LinkList pre = p;           
    LinkList q = p->next;      

    while (q)
    {
        if (strcmp(p->data.no, q->data.no) == 0)
        {
            pre->next = q->next; 
            delete q;
            q = pre->next;
        }
        else
        {
            pre = q;
            q = q->next;
        }
    }

    p = p->next;    
}

Length_L(L);                       
return OK;








    /**************end************/
}
int Output_L(LinkList L)
{//链表的输出
    Length_L(L);
    cout<<L->length<<endl;   //去重后的图书数目
    LinkList p=L;           //初始化p指向链表的头结点
    while(p->next)                	//下一个结点存在时
    {
        cout<<p->next->data.no<<" "<<p->next->data.name<<" "<<fixed<<setprecision(2)<<p->next->data.price<<endl;
        p=p->next;    //更新指针p，指向下一个结点
    }
    return OK;
}
int main()
{
    LinkList L;                         //定义一个LinkList类型的变量L
    InitList_L(L);                      //初始化一个空的链表L
    Input_L(L);                         //输入链表数据
    DupRemoval_L(L);                   //查重删除
    Output_L(L);                        //链表的输出
    return 0;
}

评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值