详解
第1关：基于链式存储结构的图书信息表的创建和输出
任务描述
本关任务：定义一个包含图书信息（书号、书名、价格）的链表，读入相应的图书数据来完成图书信息表的创建，然后统计图书表中的图书个数，同时逐行输出每本图书的信息。
编程要求
输入
输入n+1行，其中前n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。最后第n+1行是输入结束标志：0 0 0（空格分隔的三个0）。其中书号和书名为字符串类型，价格为浮点数类型。
输出
总计n+1行，第1行是所创建的图书表中的图书个数，后n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔。其中价格输出保留两位小数
#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;
//LinkList是一个指向LNode类型的指针,围绕指针展开
int InitList_L(LinkList &L)
{//构造一个空的单链表L
L=new LNode;
L->next=NULL;
return OK;
}
int Input_L(LinkList &L)
{//链表的输入 1.接收数据 2.插入数据（1. 给编号（新节点）2.传数据 3.理关系 4.赋结点）
LinkList p=L; //初始化p指向链表的头结点
char no[20];
char name[50];
float price;
while(cin>>no>>name>>price)
{
if(strcmp(no,"0")==0&&strcmp(name,"0")==0&&price==0)//输入结束标志
break;
else
{//后插法创建单链表
//strcpy是C语言中的一个标准库函数，它用于将一个字符串（包括 '\0'）从源复制到目标。
LinkList q = new LNode; //生成新结点*q
strcpy(q->data.no, no); //将结点*q数据域的no部分置为no
strcpy(q->data.name, name); //将结点*q数据域的name部分置为name
//在 C 或 C++ 中，不同的数据类型需要不同的赋值方式。当你需要赋值一个字符串时，你需要使用 strcpy 或 strncpy；当你需要赋值一个浮点数或其他数值类型时，你只需要直接赋值。因此，这三句赋值的语句不同，因为它们正在赋值的对象类型不同。
q->data.price=price; //将结点*q数据域的price部分置为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，指向下一个结点
}
cout<<L->length<<endl; //输出表长
return OK;
}
int Output_L(LinkList L)
{//链表的输出
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); //输入链表数据
Length_L(L); //求链表的表长并输出
Output_L(L); //输出链表数据
return 0;
}第2关：基于链式存储结构的图书信息表的排序
任务描述
本关任务：定义一个包含图书信息（书号、书名、价格）的链表，读入相应的图书数据完成图书信息表的创建，然后将图书按照价格降序排序，逐行输出排序后每本图书的信息。
编程要求
输入
输入n+1行，前n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。最后第n+1行是输入结束标志：0 0 0（空格分隔的三个0）。其中书号和书名为字符串类型，价格为浮点数类型。
输出
总计n行，每行是一本图书的信息（书号、书名、价格），书号、书名、价格用空格分隔。其中价格输出保留两位小数。
#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指向链表的头结点
char no[20];
char name[50];
float price;
while(cin>>no>>name>>price)
{
if(strcmp(no,"0")==0&&strcmp(name,"0")==0&&price==0)//输入结束标志
break;
else
{//后插法创建单链表
LinkList q=new LNode; //生成新结点*q
strcpy(q->data.no, no); //将结点*q数据域的no部分置为no
strcpy(q->data.name, name); //将结点*q数据域的name部分置为name
q->data.price=price; //将结点*q数据域的price部分置为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 Output_L(LinkList L)
{//链表的输出
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 Sort_L(LinkList &L)
{//将图书按照价格降序排序
/**************begin************/
//和非链表的思路一样，不同的是数据以 p->data 来表示
for(int i=0;i<L->length-1;i++)
{
LinkList p=L->next; //每轮冒泡排序从首元结点开始
for(int j=0;j<L->length-1-i;j++)
{
if(p->data.price<p->next->data.price)//降序排序
{
Book t=p->data;
p->data=p->next->data;
p->next->data=t;
}
p=p->next;
}
}
return OK;
/**************end************/
}
int main()
{
LinkList L; //定义一个LinkList类型的变量L
InitList_L(L); //初始化一个空的链表L
Input_L(L); //输入数据
Length_L(L); //先求链表L的表长L->length
Sort_L(L); //降序排序
Output_L(L); //输出链表
return 0;
}第3关：基于链式存储结构的图书信息表的修改
任务描述
本关任务：定义一个包含图书信息（书号、书名、价格）的链表，读入相应的图书数据完成图书信息表的创建，然后计算所有图书的平均价格，将所有低于平均价格的图书价格提高20%，所有高于或等于平均价格的图书价格提高10%，最后逐行输出价格修改后的图书信息。
编程要求
输入
输入n+1行，前n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。最后第n+1行是输入结束标志：0 0 0（空格分隔的三个0）。其中书号和书名为字符串类型，价格为浮点数类型。
输出
总计n+1行，第1行是修改前所有图书的平均价格，后n行是价格修改后n本图书的信息，每本图书信息占一行，书号、书名、价格用空格分隔。其中价格输出保留两位小数。
#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指向链表的头结点
char no[20];
char name[50];
float price;
while(cin>>no>>name>>price)
{
if(strcmp(no,"0")==0&&strcmp(name,"0")==0&&price==0)
break; //输入结束标志
else
{//后插法创建单链表
LinkList q=new LNode; //生成新结点*q
strcpy(q->data.no, no); //将结点*q的no部分置为no
strcpy(q->data.name, name); //将结点*q的name部分置为name
q->data.price=price; //将结点*q的price部分置为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 Output_L(LinkList L)
{//链表的输出
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 AveRevise_L(LinkList &L)
{//计算所有图书的平均价格并修改价格
/**************begin************/
LinkList p=L->next; //p指向链表的首元结点
float sum; //总价，累加之前一定记住sum赋值为0
float avg_price; //均价
while(p) //若结点存在
{
sum+=p->data.price; //累加
p=p->next; //更新p指针，指向下一个结点
}
avg_price=sum/L->length; //求均值并输出
cout<<fixed<<setprecision(2)<<avg_price<<endl;
p=L->next; //p指向链表的首元结点
while(p) //若结点存在
{
if(p->data.price<avg_price) //与均价比较
p->data.price=p->data.price*1.2;
else
p->data.price=p->data.price*1.1;
p=p->next; //更新p指针，指向下一个结点
}
return OK;
/**************end************/
}
int main()
{
LinkList L; //定义一个LinkList类型的变量L
InitList_L(L); //初始化一个空的链表L
Input_L(L); //输入链表数据
Length_L(L); //求链表L的表长L->length
AveRevise_L(L); //计算所有图书的平均价格并修改价格
Output_L(L); //输出链表L
return 0;
}第4关：基于链式存储结构的图书信息表的逆序存储
任务描述
本关任务：定义一个包含图书信息（书号、书名、价格）的链表，读入相应的图书数据来完成图书信息表的创建，然后将读入的图书逆序存储，逐行输出逆序存储后每本图书的信息。
编程要求
输入
输入n+1行，第一行是图书数目n，后n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。其中书号和书名为字符串类型，价格为浮点数类型。
输出
总计n行，第i行是原有图书表中第n-i+1行的图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔。其中价格输出保留两位小数。
#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;
}
void Reverse_L(LinkList &L)
{//逆置带头结点的单链表L
/**************begin************/
//做的工作是将一个链表的每个节点插入到链表的开始
LinkList p=L->next; //p指向首元结点
LinkList q;
L->next=NULL; //这意味着原始链表的连接被断开，或者我们可以在之后添加或删除元素。
while( p!=NULL ) { //p指向的元素为空（即链表的结尾），结束
q=p->next;
p->next=L->next; //p的下一个元素设置为原始链表的下一个元素。
L->next=p; //将原链表的每个元素都移到链表的开始位置。
p=q;
}
/**************end************/
}
int Output_L(LinkList L)
{//链表的输出
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); //输入数据
Reverse_L(L); //逆序存储链表
Output_L(L); //输出链表L数据
return 0;
} 
不理解，强推看以下视频
【【数据结构】头插法实现单链表逆序问题】https://www.bilibili.com/video/BV1mK411P764?vd_source=e5ae86967d67e092b8271c512dce1ddc
【数据结构】头插法实现单链表逆序问题
第5关：基于链式存储结构的图书信息表的最贵图书的查找
任务描述
本关任务：定义一个包含图书信息（书号、书名、价格）的链表，读入相应的图书数据来完成图书信息表的创建，然后查找价格最高的图书，输出相应图书的信息。
编程要求
输入
总计输入n+1行，其中，第一行是图书数目n，后n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。其中书号和书名为字符串类型，价格为浮点数类型。
输出
总计输出m+1行，其中，第一行是最贵图书数目（价格最高的图书可能有多本），后m行是最贵图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，其中价格输出保留两位小数。
#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 HighestPrice_L(LinkList L)
{//查找价格最高的图书
/**************begin************/
//最贵图书可能不止一本
//思路：1.找出最贵(maxPrice)图书有多少(count)本 2.输出最贵图书的信息
LinkList p = L->next;
float maxPrice = 0;
int count = 0;
while(p)
{
if(p->data.price > maxPrice)
{
maxPrice = p->data.price;
count = 1;
}
else if(p->data.price == maxPrice)
{
count++;
}
p = p->next;
}
cout<<count<<endl; //输出最高价书的总数
p=L->next; //p指向首元结点
while(p) //若结点存在，则与max比较
{
if(p->data.price==maxPrice){ //若为最高价书,则输出相关信息
cout<<p->data.no<<" "<<p->data.name<<" "<<fixed<<setprecision(2)<<p->data.price<<endl; }
p=p->next; //更新指针p，指向下一个结点
}
return OK;
/**************end************/
}
int main()
{
LinkList L; //定义一个LinkList类型的变量L
InitList_L(L); //初始化一个空的链表L
Input_L(L); //输入链表数据
HighestPrice_L(L); //查找价格最高的图书并输出相关信息
return 0;
}第6关：基于链式存储结构的图书信息表的最爱图书的查找
任务描述
本关任务：定义一个包含图书信息（书号、书名、价格）的链表，读入相应的图书数据来完成图书信息表的创建，然后根据指定的最爱图书的名字，查找最爱的图书，输出相应图书的信息。
编程要求
输入
总计n+m+2行。首先输入n+1行，其中，第一行是图书数目n，后n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。其中书号和书名为字符串类型，价格为浮点数类型。然后输入m+1行，其中，第一行是一个整数m，代表查找m次，后m行是每次待查找的最爱图书名字。
输出
若查找成功： 总计输出m*（k+1）行，对于每一次查找，第一行是最爱图书数目（同一书名的图书可能有多本），后k行是最爱图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，其中价格输出保留两位小数。 若查找失败： 只输出以下提示：抱歉，没有你的最爱！
#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************/
//1.看是否有最爱图书bookname[]2.输出(1.几本最爱图书（count） 2.对应信息)
LinkList favouritebooks[5];
string bookname[10];
int n; //最爱的书的数量
cin>>n;
for(int i=0;i<n;i++){
cin>>bookname[i];
}
LinkList p;
int k=0;
for(int j=0;j<n;j++)
{
//初始化查找到的书的数目
k=0;
//跳过头节点开始遍历
p=L->next;
while(p)
{
if(p->data.name==bookname[j])
{
favouritebooks[k]=p;//成功比对，查找到的目标元素的地址存在favouritebooks数组中
k++;
}
p=p->next;
}
if(k==0)
cout<<"Sorry，there is no your favourite!"<<endl;
else
{
cout<<k<<endl;
for(int i=0;i<k;i++)
cout<<favouritebooks[i]->data.no<<" "<<favouritebooks[i]->data.name<<" "<<setiosflags(ios::fixed)<<setprecision(2)<<favouritebooks[i]->data.price<<endl;
}
}
/**************end************/
}
int main()
{
LinkList L; //定义一个LinkList类型的变量L
InitList_L(L); //初始化一个空的链表L
Input_L(L); //输入链表数据
FindFavorite_L(L); //查找的最爱图书并输出数据
return 0;
}第7关：基于链式存储结构的图书信息表的最佳位置图书的查找
任务描述
本关任务：定义一个包含图书信息（书号、书名、价格）的链表，读入相应的图书数据来完成图书信息表的创建，然后根据指定的最佳位置的序号，查找该位置上的图书，输出相应图书的信息。
编程要求
输入
总计n+m+2行。首先输入n+1行，其中，第一行是图书数目n，后n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。其中书号和书名为字符串类型，价格为浮点数类型。然后输入m+1行，其中，第一行是一个整数m，代表查找m次，后m行每行内容为一个整数，代表待查找的图书的位置序号。
输出
输出m行 若查找成功： 输出内容为第i次查询的指定位置上的一本图书的信息（书号、书名、价格），书号、书名、价格用空格分隔，其中价格输出保留两位小数。 若查找失败： 只输出以下提示：抱歉，最佳位置上的图书不存在！
#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 Locate_L(LinkList L)
{//查找最佳位置的图书并输出数据
//感觉题目有点难懂，第一行为要查几本书
//第二行为待查找的图书的位置序号。
/**************begin************/
int n;
cin >> n;
int location[100]; // 存储用户输入的位置序号
for(int i=0; i<n; i++){
cin >> location[i];
}
for(int i = 0; i < n; i++) { // 对每个用户要求的位置进行遍历
LinkList p = L;
if(location[i] >= 1 && location[i] <= L->length) { // 检查位置是否在链表范围内
location[i]--; // 从1开始计数
while(location[i]--) { // 循环到达指定位置
if(p->next == NULL) { // 检查是否到达链表末尾
cout << "Sorry, the book at the specified position does not exist!" << endl;
break;
}
p = p->next;
}
if(p->next != NULL) { // 检查是否找到图书
cout << p->next->data.no << " " << p->next->data.name << " " << fixed << setprecision(2) << p->next->data.price << endl;
}
} else {
cout << "Sorry，the book on the best position doesn't exist!" << endl;
}
}
return OK;
/**************end************/
}
int main()
{
LinkList L; //定义一个LinkList类型的变量L
InitList_L(L); //初始化一个空的链表L
Input_L(L); //输入链表数据
Length_L(L); //求链表的表长
Locate_L(L); //查找最佳位置的图书并输出数据
return 0;
}第8关：基于链式存储结构的图书信息表的新图书的入库
任务描述
本关任务：定义一个包含图书信息（书号、书名、价格）的链表，读入相应的图书数据来完成图书信息表的创建，然后根据指定的待入库的新图书的位置和图书的信息，将新图书插入到图书表中指定的位置上，最后输出新图书入库后的所有图书的信息。
编程要求
输入
总计n+3行。首先输入n+1行，其中，第一行是图书数目n，后n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。其中书号和书名为字符串类型，价格为浮点数类型。之后输入第n+2行，内容仅为一个整数，代表待入库的新图书的位置序号。最后输入第n+3行，内容为新图书的信息，书号、书名、价格用空格分隔。
输出
若插入成功： 输出新图书入库后所有图书的信息（书号、书名、价格），总计n+1行，每行是一本图书的信息，书号、书名、价格用空格分隔。其中价格输出保留两位小数。 若插入失败： 只输出以下一行提示：抱歉，入库位置非法！
#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; //插在第n个位置
LinkList p,b=new LNode; //用结点b存储新书的信息
cin>>n>>b->data.no>>b->data.name>>b->data.price;//存储该书的信息
if(1<=n&&n<=1+L->length) //插入位置合理，有1+L->length个位置可插入
{
p=L; //p指向链表的头结点，指向位置0
n--; //为了下面循环n-1次
while(n--){ //定位到位置n-1
p=p->next; } //循环结束时，p->next指向位置n
b->next=p->next; //将结点p->next插在结点b后面
p->next=b; //将结点b插在结点p后面
p=L->next; //p指向链表的首元结点
while(p) //若结点p存在，则输出相关信息
{
cout<<p->data.no<<" "<<p->data.name<<" "<<fixed<<setprecision(2)<<p->data.price<<endl;
p=p->next; //更新结点p，指向下一个结点
}
}
else //插入位置非法
cout<<"Sorry，the position to be inserted is invalid!"<<endl;
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行，每行是一本图书的信息，书号、书名、价格用空格分隔。其中价格输出保留两位小数。 若删除失败： 只输出以下一行提示：抱歉，出库位置非法！
#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;
}
void Delete_L(LinkList &L)
{//出库旧图书并输出
/**************begin************/
//接收待删除的旧图书的位置序号
int position;
cin >> position;
// 检查位置序号的有效性
if (position < 1 || position > L->length) {
cout << "Sorry，the position to be deleted is invalid!" << endl;
return; // 提前返回，不再执行后续操作
}
LinkList q, p;
p = L;
// 找到要删除的节点
position--;
while (position--){ //如果position等于2，那么这个循环会执行两次。第一次执行时，position为2，第二次执行时，position为1，然后循环结束
p = p->next;
}
// 要删除的节点是p->next
q = p->next;
p->next = q->next;
// 释放节点的内存
delete q;
// 遍历链表并输出节点数据
p = L->next;
while (p) {
cout << p->data.no << " " << p->data.name << " ";
cout << fixed << setprecision(2) << p->data.price << endl; // 保存小数点后两位
p = p->next;
}
/**************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行是去重后图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，其中价格输出保留两位小数。
#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; //初始化p指向首元结点
while(p) //结点存在时
{
LinkList q=p; //每次将q指向p结点
while(q->next) //当q->next存在时，与p比较
{
if(strcmp(q->next->data.no,p->data.no)==0)//如果重复
{
LinkList s=q->next; //保存待删除结点
q->next=q->next->next;
delete s; //删除结点，释放内存
}
else
q=q->next; //更新指针q，指向下一个结点
}
p=p->next; //更新指针p，指向下一个结点
}
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;
}文章出处登录后可见！
已经登录？立即刷新