编程题实训-基于顺序表的图书信息管理（头歌）

已于 2023-10-10 20:28:17 修改
阅读量9k 收藏 169
点赞数 47
分类专栏： 数据结构--头歌 文章标签： 算法
于 2023-10-09 21:23:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a61233/article/details/133716337
版权

非常之详细

第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
#define MAXSIZE 1000    //图书表可能达到的最大长度
//"	iostream：用于处理标准输入输出流，例如cin和cout。
//"	string.h：这个头文件包含一系列操作字符串的函数，但在C++中，您通常会使用string头文件而不是string.h。
//"	iomanip：这个头文件包含一系列控制输入/输出格式的类和函数。
// 在C++中，'using namespace std;' 是一个命名空间声明。这是告诉编译器，后续的代码可以在不需要std::前缀的情况下使用标准命名空间中定义的所有元素。
using namespace std;
//定义了两个结构体，一个是“Book”用来存储图书的信息，
//另一个是“SqList”用来存储一个图书表的顺序存储结构。
typedef struct{
	char no[20];
	char name[50];
	float price;
}Book; 
typedef struct{
	Book *elem; //存储空间的基地址 
	int length;
}SqList;
// //构造一个空的顺序表L
int InitList_Sq(SqList &L)
{//构造一个空的顺序表L
    L.elem=new Book[MAXSIZE];     //为顺序表分配一个大小为MAXSIZE的数组空间
    if(!L.elem)exit(OVERFLOW);    //存储分配失败退出
    L.length=0;                   //空表长度为0
    return OK;
}
//这部分定义了一个函数InitList_Sq，该函数接受一个SqList类型的引用作为参数，并返回一个整型。
//从函数名来看，这个函数可能是用来初始化SqList的。在C++中，使用引用参数（&L）可以在函数内部修改原始参数的值。
int Input_Sq(SqList &L){
	for (int i=0;i<MAXSIZE;i++){
		cin>>L.elem[i].no>>L.elem[i].name>>L.elem[i].price;
		if(strcmp(L.elem[i].no,"0")==0&&strcmp(L.elem[i].name,"0")==0&&L.elem[i].price==0)
            return OK;            //输入结束标志
        else
            L.length++;           //合法输入时，图书个数+1
    }
    return OK;
	}

int Output_Sq(SqList L)
{//顺序表的输出
    cout<<L.length<<endl;        //图书表中的图书个数
    for(int i=0;i<L.length;i++)    //图书的信息（书号、书名、价格）
        cout<<L.elem[i].no<<" "<< L.elem[i].name<<" "<<fixed<<setprecision(2)<<L.elem[i].price<<endl;
    return OK;
}
int main()
{
    SqList L;                   //定义一个SqList类型的变量L
    InitList_Sq(L);             //初始化一个空的顺序表L
    Input_Sq(L);                //输入数据
    Output_Sq(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
#define MAXSIZE 1000    //图书表可能达到的最大长度
using namespace std;
typedef struct
{//图书信息定义
    char no[20];    //图书ISBN
    char name[50];   //图书名字
    float price;   //图书价格
}Book;
typedef struct
{//图书表的顺序存储结构类型为SqList
    Book *elem;                   //存储空间的基地址
    int length;                   //图书表中当前图书个数
}SqList;
int InitList_Sq(SqList &L)
{//构造一个空的顺序表L
    L.elem=new Book[MAXSIZE];     //为顺序表分配一个大小为MAXSIZE的数组空间
    if(!L.elem)exit(OVERFLOW);    //存储分配失败退出
    L.length=0;                   //空表长度为0
    return OK;
}
int Input_Sq(SqList &L)
{//顺序表的输入
    for (int i=0;i<MAXSIZE;i++)
    {
        cin>>L.elem[i].no>>L.elem[i].name>>L.elem[i].price;
        if(strcmp(L.elem[i].no,"0")==0&&strcmp(L.elem[i].name,"0")==0&&L.elem[i].price==0)
            return OK;            //输入结束
        else
            L.length++;           //合法输入时，图书个数+1
    }
    return OK;
}
int BubbleSort_Sq(SqList L)
{//图书顺序表按照价格降序冒泡排序
    /**************begin************/
    for(int i=0;i<L.length-1;i++){
        for(int j=i+1;j<=L.length-1;j++){
            if(L.elem[i].price < L.elem[j].price){
                // 注意，temp类型应与L.elem[j].price相同
                Book temp = L.elem[i];
                L.elem[i] = L.elem[j];
                L.elem[j] = temp; 
            }
        }
    }


    /**************end************/
}
int Output_Sq(SqList L)
{//顺序表的输出
    for(int i=0;i<L.length;i++) //图书的信息（书号、书名、价格）
        cout<<L.elem[i].no<<" "<< L.elem[i].name<<" "<<fixed<<setprecision(2)<<L.elem[i].price<<endl;
    return OK;
}
int main()
{
    SqList L;            //定义一个SqList类型的变量
    InitList_Sq(L);      //初始化一个空的顺序表L
    Input_Sq(L);         //输入数据
    BubbleSort_Sq(L);     //按照价格降序排序
    Output_Sq(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
#define MAXSIZE 1000    //图书表可能达到的最大长度
using namespace std;
typedef struct
{//图书信息定义
    char no[20];    //图书ISBN
    char name[50];   //图书名字
    float price;   //图书价格
}Book;
typedef struct
{//图书表的顺序存储结构类型为SqList
    Book *elem;                   //存储空间的基地址
    int length;                   //图书表中当前图书个数
}SqList;
int InitList_Sq(SqList &L)
{//构造一个空的顺序表L
    L.elem=new Book[MAXSIZE];     //为顺序表分配一个大小为MAXSIZE的数组空间
    if(!L.elem)exit(OVERFLOW);    //存储分配失败退出
    L.length=0;                   //空表长度为0
    return OK;
}
int Input_Sq(SqList &L)
{//顺序表的输入
    for (int i=0;i<MAXSIZE;i++)
    {
        cin>>L.elem[i].no>>L.elem[i].name>>L.elem[i].price;
        if(strcmp(L.elem[i].no,"0")==0&&strcmp(L.elem[i].name,"0")==0&&L.elem[i].price==0)
            return OK;            //输入结束
        else
            L.length++;           //合法输入时，图书个数+1
    }
    return OK;
}
int RevisePrice_Sq(SqList &L)
{//修改价格
    /**************begin************/
    int i;
    float sum=0.0,ave=0.0;         //初始化总价sum和平均价格ave为0
    for(i=0;i<L.length;i++)        //累加求总价sum
        sum=sum+L.elem[i].price;
    ave=sum/L.length;              //计算平均价格ave
    for(i=0;i<L.length;i++)
        if(L.elem[i].price<ave)    //与平均价格ave比较
            L.elem[i].price=L.elem[i].price*1.2;   //低于平均价格的图书价格提高20%
        else
            L.elem[i].price=L.elem[i].price*1.1;   //高于或等于平均价格的图书价格提高10%
            //'fixed'和'setprecision(2)'是设置输出浮点数的方式。'fixed'表示以固定小数点表示，而'setprecision(2)'设置小数点后的位数为2。'endl'是结束行，表示结束这一行的输出并换行。
    cout<<fixed<<setprecision(2)<<ave<<endl;     //输出修改前所有图书的平均价格ave
    return OK;


    /**************end************/
}
int Output_Sq(SqList L)
{//顺序表的输出
    for(int i=0;i<L.length;i++)  //图书的信息（书号、书名、价格）
        cout<<L.elem[i].no<<" "<< L.elem[i].name<<" "<<fixed<<setprecision(2)<<L.elem[i].price<<endl;
    return OK;
}
int main()
{
    SqList L;           //定义一个SqList类型的变量L
    InitList_Sq(L);     //初始化一个空的顺序表L
    Input_Sq(L);        //输入数据
    RevisePrice_Sq(L);    //修改价格
    Output_Sq(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
#define MAXSIZE 1000                                  //图书表可能达到的最大长度
using namespace std;
typedef struct
{//图书信息定义
    char no[20];                                        //图书ISBN
    char name[50];                                     //图书名字
    float price;                                       //图书价格
}Book;
typedef struct
{//图书表的顺序存储结构类型为SqList
    Book *elem;                                         //存储空间的基地址
    int length;                                        //图书表中当前图书个数
}SqList;
int InitList_Sq(SqList &L)
{//构造一个空的顺序表L
    L.elem=new Book[MAXSIZE];                       //为顺序表分配一个大小为MAXSIZE的数组空间
    if(!L.elem)exit(OVERFLOW);                      //存储分配失败退出
    L.length=0;                                        //空表长度为0
    return OK;
}
int Input_Sq(SqList &L)
{//顺序表的输入
    int n;
    cin>>n;                                                //图书数目n
    for(int i=0;i<n;i++)
    {
        cin>>L.elem[i].no>>L.elem[i].name>>L.elem[i].price;
        L.length++;
    }
    return OK;
}
int Reverse_Sq(SqList &L)
{//逆序存储顺序表
/**************begin************/
     int n=L.length;
     Book t; 
    for(int i=0;i<n/2;i++)
    {   t=L.elem[i];
        L.elem[i]=L.elem[n-i-1];
        L.elem[n-i-1]=t;
    }

/**************end************/
}
int Output_Sq(SqList L)
{//顺序表的输出
    for(int i=0;i<L.length;i++)                     //图书的信息（书号、书名、价格）
       cout<<L.elem[i].no<<" "<< L.elem[i].name<<" "<<fixed<<setprecision(2)<<L.elem[i].price<<endl;
    return OK;
}
int main()
{
    SqList L;                                           //定义一个SqList类型的变量L
    InitList_Sq(L);                                    //初始化一个空的顺序表L
    Input_Sq(L);                                       //输入数据
    Reverse_Sq (L);                                    //逆序存储数据
    Output_Sq(L);                                      //输出数据
    return 0;
}

第5关：基于顺序存储结构的图书信息表的最贵图书的查找

入

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

输出

总计输出m+1行，其中，第一行是最贵图书的数目（价格最高的图书可能有多本），后m行是最贵图书的信息，每本图书信息占一行，书号、书名、价格用空格分隔，其中价格输出保留两位小数。

#include<iostream>
#include<iomanip>
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define MAXSIZE 1000    //图书表可能达到的最大长度
using namespace std;
typedef struct
{//图书信息定义
    char no[20];    //图书ISBN
    char name[50];   //图书名字
    float price;   //图书价格
}Book;
typedef struct
{//图书表的顺序存储结构类型为SqList
    Book *elem;                   //存储空间的基地址
    int length;                   //图书表中当前图书个数
}SqList;
int InitList_Sq(SqList &L)
{//构造一个空的顺序表L
    L.elem=new Book[MAXSIZE];     //为顺序表分配一个大小为MAXSIZE的数组空间
    if(!L.elem)exit(OVERFLOW);    //存储分配失败退出
    L.length=0;                   //空表长度为0
    return OK;
}
int Input_Sq(SqList &L)
{//顺序表的输入
    int n;
    cin>>n;    //图书数目n
    for(int i=0;i<n;i++)
    {
        cin>>L.elem[i].no>>L.elem[i].name>>L.elem[i].price;
        L.length++;
    }
    return OK;
}
int HighestPrice_Sq(SqList L)
{//查找价格最高的图书并输出相应图书的信息
/**************begin************/
   
    // Book max = L.elem[0];  
    // for (int i = 1; i < L.length; i++) {  
    //     if (L.elem[i].price > max.price) {  
    //         max = L.elem[i];  
    //     }  
    // }  
    // cout << max.no << " " << max.name << " " <<fixed<<setprecision(2)<< max.price << endl;  
    // return OK; 
    //需要注意的是，有可能不知一本书为最高价格，思路就不能单纯的找到并输出，题目也有要求
    //而应1.找到最高价 2.找到书 3.输出
    int i;
    float hp=L.elem[0].price;          //辅助变量hp存储最高价格
    for(i=0;i<=L.length-1;i++)        //第一趟遍历：求出最高价格hp
        if(hp<L.elem[i+1].price)
            hp=L.elem[i+1].price;
    int n=0;                         //辅助变量n存储最高价格的书的数目
    for(i=0;i<=L.length-1;i++)        //第二趟遍历：求出最高价格的书的数目n
        if(hp==L.elem[i].price)
            n++;
    cout<<n<<endl;
    for(i=0;i<=L.length-1;i++)        //输出这n本最高价格的书的信息
        if(hp==L.elem[i].price)
            cout<<L.elem[i].no<<" "<<L.elem[i].name<<" "<<fixed<<setprecision(2)<<L.elem[i].price<<endl;
    return OK;
    /**************end************/
}
int main()
{
    SqList L;               //定义一个SqList类型的变量L
    InitList_Sq(L);         //初始化一个空的顺序表L
    Input_Sq(L);            //输入数据
    HighestPrice_Sq(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
#define MAXSIZE 1000    //图书表可能达到的最大长度
using namespace std;
typedef struct
{//图书信息定义
    char no[20];    //图书ISBN
    char name[50];   //图书名字
    float price;   //图书价格
}Book;
typedef struct
{//图书表的顺序存储结构类型为SqList
    Book *elem;                   //存储空间的基地址
    int length;                   //图书表中当前图书个数
}SqList;
int InitList_Sq(SqList &L)
{//构造一个空的顺序表L
    L.elem=new Book[MAXSIZE];     //为顺序表分配一个大小为MAXSIZE的数组空间
    if(!L.elem)exit(OVERFLOW);    //存储分配失败退出
    L.length=0;                   //空表长度为0
    return OK;
}
int Input_Sq(SqList &L)
{//顺序表的输入
    int n;
    cin>>n;    //图书数目n
    for(int i=0;i<n;i++)
    {
        cin>>L.elem[i].no>>L.elem[i].name>>L.elem[i].price;
        L.length++;
    }
    return OK;
}
int FindFavorite_Sq(SqList L)
{//最爱图书的查找并输出数据
    int m;    //查找m次
    cin>>m;
    Book s[m];
    int i,j;
    for(i=0;i<m;i++)
        cin>>s[i].name;              //输入待查的书名
    for(i=0;i<m;i++)            //依次查找m本书
    {
        int num=0;                //查询第i本书，初始化num为0
        for(j=0;j<L.length;j++)
            if(strcmp(L.elem[j].name,s[i].name)==0)      //计算同名书的数目num
                    num++;
        if(num==0)                          //num为0，即未查找到该书
            cout<<"Sorry，there is no your favourite!"<<endl;
        else
        {
            cout<<num<<endl;                 //输出同名书的数目
                for(j=0;j<L.length;j++)          //一趟遍历：输出同名书的信息
                    if(strcmp(L.elem[j].name,s[i].name)==0)
                        cout<<L.elem[j].no<<" "<<L.elem[j].name<<" "<<fixed<<setprecision(2)<<L.elem[j].price<<endl;
        }
    }
    return OK;
}
int main()
{
    SqList L;              //定义一个SqList类型的变量L
    InitList_Sq(L);        //初始化一个空的顺序表L
    Input_Sq(L);           //输入数据
    FindFavorite_Sq(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
#define MAXSIZE 1000    //图书表可能达到的最大长度
using namespace std;
typedef struct
{//图书信息定义
    char no[20];    //图书ISBN
    char name[50];   //图书名字
    float price;   //图书价格
}Book;
typedef struct
{//图书表的顺序存储结构类型为SqList
    Book *elem;                   //存储空间的基地址
    int length;                   //图书表中当前图书个数
}SqList;
int InitList_Sq(SqList &L)
{//构造一个空的顺序表L
    L.elem=new Book[MAXSIZE];     //为顺序表分配一个大小为MAXSIZE的数组空间
    if(!L.elem)exit(OVERFLOW);    //存储分配失败退出
    L.length=0;                   //空表长度为0
    return OK;
}
int Input_Sq(SqList &L)
{//顺序表的输入
    int n;
    cin>>n;    //图书数目n
    for(int i=0;i<n;i++)
    {
        cin>>L.elem[i].no>>L.elem[i].name>>L.elem[i].price;
        L.length++;
    }
    return OK;
}
int FindLocate_Sq(SqList L)
{//查找最佳位置图书并输出数据
//感觉题目有点难懂，第一行为要查几本书
//第二行为待查找的图书的位置序号。
/**************begin************/
    int i,m;
    cin>>m;
    int s[m];
    for(i=0;i<m;i++)
        cin>>s[i]; 
    for(i=0;i<m;i++){
        //注意有可能输入0
        if (s[i] < 1 || s[i] > L.length) {  
            cout << "Sorry，the book on the best position doesn't exist!"<< endl;  
        }else{  
    cout << L.elem[s[i] - 1].no << " " << L.elem[s[i] - 1].name << " " << fixed << setprecision(2) << L.elem[s[i] - 1].price << endl; }
    }
    return OK;

    /**************end************/
}
int main()
{
    SqList L;            //定义一个SqList类型的变量L
    InitList_Sq(L);      //初始化一个空的顺序表L
    Input_Sq(L);         //输入数据
    FindLocate_Sq(L);    //查找最佳位置图书并输出数据
    return 0;
}

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

任务描述

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

编程要求

输入

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

输出

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

#include<iostream>
#include <string.h>
#include<iomanip>
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define MAXSIZE 1000    //图书表可能达到的最大长度
using namespace std;
typedef struct
{//图书信息定义
    char no[20];    //图书ISBN
    char name[50];   //图书名字
    float price;   //图书价格
}Book;
typedef struct
{//图书表的顺序存储结构类型为SqList
    Book *elem;                   //存储空间的基地址
    int length;                   //图书表中当前图书个数
}SqList;
int InitList_Sq(SqList &L)
{//构造一个空的顺序表L
    L.elem=new Book[MAXSIZE];     //为顺序表分配一个大小为MAXSIZE的数组空间
    if(!L.elem)exit(OVERFLOW);    //存储分配失败退出
    L.length=0;                   //空表长度为0
    return OK;
}
int Input_Sq(SqList &L)
{//顺序表的输入
    int n;
    cin>>n;    //图书数目n
    for(int i=0;i<n;i++)
    {
        cin>>L.elem[i].no>>L.elem[i].name>>L.elem[i].price;
        L.length++;
    }
    return OK;
}
int Insert_Sq(SqList &L)
{//新图书的入库和输出.
/**************begin************/
    // 1.存（给个名分 -->容身之处）2.放

    int i,n;
    // mo.price.name 需要重新定义的原因是： typedef struct定义的实际上是一个类型别名，而不是全局变量。你创建了一个名为Book的类型，它是一个结构体，
    //使用例子int main() {  
    // Book myBook;  
    // strcpy(myBook.no, "1234567890");  
    // strcpy(myBook.name, "Example Book");  
    // myBook.price = 19.99;  
    char no[20];    //图书ISBN
    char name[50];   //图书名字
    float price;   //图书价格
    cin>>n>>no>>name>>price;      //输入待插入书籍的信息
    if(n<1||n>L.length)      //若插入失败： 只输出以下提示：抱歉，入库位置非法！
        cout<<"Sorry，the position to be inserted is invalid!"<<endl;
    else
    {
        for(i=L.length;i>n-1;i--)      //全部后移，留出空位
            L.elem[i]=L.elem[i-1];
        strcpy(L.elem[n-1].no,no);  //strcpy是一个标准库函数，用于在C语言中复制字符串。strcpy(L.elem[n-1].no, no);这行代码的意思是将no指向的字符串复制到L.elem[n-1].no所指向的位置。需要注意的是，no必须是一个以空字符('\0')结尾的字符串，否则可能会导致未定义的行为。
        strcpy(L.elem[n-1].name,name);
        L.elem[n-1].price=price;
        L.length++;            //插入完成，图书个数+1
        for(int i=0;i<L.length;i++)
            cout<<L.elem[i].no<<" "<<L.elem[i].name<<" "<<fixed<<setprecision(2)<<L.elem[i].price<<endl;
    }
    return OK;


    /**************end************/
}
int main()
{
    SqList L;           //定义一个SqList类型的变量L
    InitList_Sq(L);     //初始化一个空的顺序表L
    Input_Sq(L);        //输入数据
    Insert_Sq(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
#define MAXSIZE 1000    //图书表可能达到的最大长度
using namespace std;
typedef struct
{//图书信息定义
    char no[20];    //图书ISBN
    char name[50];   //图书名字
    float price;   //图书价格
}Book;
typedef struct
{//图书表的顺序存储结构类型为SqList
    Book *elem;                   //存储空间的基地址
    int length;                   //图书表中当前图书个数
}SqList;
int InitList_Sq(SqList &L)
{//构造一个空的顺序表L
    L.elem=new Book[MAXSIZE];     //为顺序表分配一个大小为MAXSIZE的数组空间
    if(!L.elem)exit(OVERFLOW);    //存储分配失败退出
    L.length=0;                   //空表长度为0
    return OK;
}
int Input_Sq(SqList &L)
{//顺序表的输入
    int n;
    cin>>n;    //图书数目n
    for(int i=0;i<n;i++)
    {
        cin>>L.elem[i].no>>L.elem[i].name>>L.elem[i].price;
        L.length++;//图书个数+1
    }
    return OK;
}
int Delete_Sq(SqList &L)
{//旧图书的出库和输出
/**************begin************/
    //注意位序和数组之间一定有个减一的关系
    int m;
    cin>>m;
    if(m<1 || m>L.length){
        cout<<"Sorry，the position to be deleted is invalid!";
    }else {
        for(int i=m-1;i<L.length-1;i++)  {   
                L.elem[i]=L.elem[i+1];
            }
            L.length--;  
        //删除完成，图书个数-1
        for(int i=0;i<L.length;i++){
            cout<<L.elem[i].no<<" "<<L.elem[i].name<<" "<<fixed<<setprecision(2)<<L.elem[i].price<<endl;
    }
        }
return OK;

 

    /**************end************/
}
int main()
{
    SqList L;            //定义一个SqList类型的变量L
    InitList_Sq(L);      //初始化一个空的顺序表L
    Input_Sq(L);         //输入数据
    Delete_Sq(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
#define MAXSIZE 1000    //图书表可能达到的最大长度
using namespace std;
typedef struct
{//图书信息定义
    char no[20];    //图书ISBN
    char name[50];   //图书名字
    float price;   //图书价格
}Book;
typedef struct
{//图书表的顺序存储结构类型为SqList
    Book *elem;                   //存储空间的基地址
    int length;                   //图书表中当前图书个数
}SqList;
int InitList_Sq(SqList &L)
{//构造一个空的顺序表L
    L.elem=new Book[MAXSIZE];     //为顺序表分配一个大小为MAXSIZE的数组空间
    if(!L.elem)exit(OVERFLOW);    //存储分配失败退出
    L.length=0;                   //空表长度为0
    return OK;
}
int Input_Sq(SqList &L)
{//顺序表的输入
    int n;
    cin>>n;    //图书数目n
    for(int i=0;i<n;i++)
    {
        cin>>L.elem[i].no>>L.elem[i].name>>L.elem[i].price;
        L.length++;//图书个数+1
    }
    return OK;
}
int SearchList(SqList L,char no[20])
{//查找书号是否在图书信息表L中
	int i;
	for(i=0;i<L.length;i++)
		if(strcmp(L.elem[i].no,no)==0)
			return OK;
	return ERROR;
}
int DupRemoval_Sq(SqList L1,SqList &L2)
{//图书去重
/**************begin************/
    int i;
    for(i=0;i<L1.length;i++)
    {
        if(!SearchList(L2,L1.elem[i].no))  //如果当前书号没有出现在L2中，则将该图书信息插入L2中
        {
            L2.elem[L2.length]=L1.elem[i];
            L2.length++;
        }
    }
    cout<<L2.length<<endl;
     for(i=0;i<L2.length;i++)
        cout<<L2.elem[i].no<<" "<<L2.elem[i].name<<" "<<fixed<<setprecision(2)<<L2.elem[i].price<<endl;
    return OK;



    /**************end************/
}
int main()
{
    SqList L1,L2;            	 //定义SqList类型的变量L1,L2
    InitList_Sq(L1);        	 //初始化一个空的顺序表L1
    InitList_Sq(L2);       	 //初始化一个空的顺序表L2
    Input_Sq(L1);          	 //输入数据到L1
    DupRemoval_Sq(L1,L2);       //图书去重并输出结果
    return 0;
}

 

 

 

 

 

 

 

JAVA郑
关注
  • 47
    点赞
  • 踩
  • 169
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
编程题实训-基于顺序表的图书信息管理Python版
Junds0的博客
04-11 168
任务描述 本关任务：定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据来完成图书信息表的创建，然后统计图书表中的图书个数，同时逐行输出每本图书的信息。编程要求 输入 输入n+1行，其中前n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。最后第n+1行是输入结束标志：0 0 0（空格分隔的三个0）。其中书号和书名为字符串类型，价格为浮点数类型。输出 总计n+1行，第1行是所创建的图书表中的图书个数，后n行是n本图书的信息（书号、书名、
编程题实训-基于顺序表的图书信息管理
Junds0的博客
04-07 824
最后第n+1行是输入结束标志：0 0 0（空格分隔的三个0）。本关任务：定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据来完成图书信息表的创建，然后根据指定的待入库的新图书的位置和信息，将新图书插入到图书表中指定的位置上，最后输出新图书入库后所有图书的信息。本关任务：定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据来完成图书信息表的创建，然后根据指定的待出库的旧图书的位置，将该图书从图书表中删除，最后输出该图书出库后的所有图书的信息。其中价格输出保留两位小数。
数据结构实验报告2线性表的链式存储结构.doc
07-11
学院： 专业： 班级： "姓名 " "学号 " "实验组" " "实验时间 "2011-11-11 "指导教师" "成绩 " " "实验项目名称"线性表的链式存储结构 " "实"了解和掌握线性表的逻辑结构和链式存储结构，掌握单链表的基本算法" "验"。 " "目" " "的" " "实"运行Visual c++的微机一台 " "验" " "条" " "件" " "实"根据实验内容编程，上机调试、得出正确的运行程序。 " "验"2. 编译运行程序，观察运行情况和输出结果。 " "原"3. 写出实验报告（包括源程序和运行结果）。 " "理" " "方" " "法" " "和" " "手" " "段" " "实"#include <> " "验"#include <> " "步"#include <> " "骤"typedef int ElemType; " "程"struct list { " "序"ElemType *elem ; " "清"int size; " "单"int maxsize; " " "}; " " "/* 初始化 ,构造一个新的线性表 */ " " "void In
基于python顺序表和链表的图书管理系统
qingbeng的博客
09-11 2257
.........
编程题实训-顺序表应用
最新发布
a61233的博客
09-16 2562
多组数据，每组数据有三行，第一行为顺序表的长度n，第二行为顺序表的n个元素（元素之间用空格分隔），第三行为待删除的元素的值item。当n=0时输入结束。本关任务：利用顺序表表示一个包括n个整数的序列，请实现一个时间复杂度为O(n)，空间复杂度为O(1)的算法，该算法可以删除表中所有值为item的元素。对于每组数据分别输出一行，依次输出删除值为item的元素后顺序表中的剩余元素，元素之间用空格分隔。
二十四点问题
qq_45670253的博客
08-16 870
【题目背景】 二十四点是一款著名的纸牌游戏，其游戏的目标是使用3个加减乘除运算使得4张纸牌上数字的运算结果为24. 【题目描述】 定义每一个游戏由4个从1-9的数字和3个四则运算符组成，保证四则运算符将数字两两隔开，不存在括号和其他字符，运算顺序按照四则运算顺序进行。加法用+表示，减法用-表示，乘法用小写字母x表示，除法用/表示。在游戏里除法为整除。 老师给了你n个游戏的解，请你编写程序验证每个游戏的结果是否为24. 【输入格式】 从标准输入读入数据。 第一行输入一个整数n，从第二行开始到第n+1行中，每一
基于顺序表的图书管理系统
qq_43575301的博客
10-07 5629
#include #include #include #include <string.h> #define MAXSIZE 100 using namespace std; char s0[20],s1[20],s2[20],s3[20],s4[30]; int num; typedef struct //图书类型Book定义 { char no[20]; //书号 cha...
第6关：基于顺序存储结构的图书信息表的最爱图书的查找
m0_63759457的博客
12-02 2690
基于顺序存储结构的图书信息表的最爱图书的查找
数据结构实验1必做部分OJ版-配套实验
06-12
书名：数据结构（C语言版）（第2版） ISBN：9787115379504 作者：严蔚敏 李冬梅 吴伟民
1_顺序表_
10-02
基于顺序存储结构的图书信息表的创建和输出描述定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据来完成图书信息表的创建，然后统计图书表中的图书个数，同时逐行输出每本图书的信息。输入输入n+1行，其中前n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。最后第n+1行是输入结束标志：0 0 0（空格分隔的三个0）。其中书号和书名为字符串类型，价格为浮点数类型。输出总计n+1行，第1行是所创建的图书表中的图书个数，后n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔。其中价格输出保留两位小数。
顺序表实现的图书管理
06-19
定义图书类型结构，定义顺序表；完成功能：初始化构建空表、插入新记录到第i个位置、删除表中第i个记录、按图书名称进行查找、按作者进行查找、按价格区间进行查找。
顺序存储结构
03-06
线性表的资源存储结构 小甲鱼视频中的一部分线性表的资源存储结构 小甲鱼视频中的一部分线性表的资源存储结构 小甲鱼视频中的一部分线性表的资源存储结构 小甲鱼视频中的一部分
2_顺序表_
10-01
基于顺序存储结构的图书信息表的修改描述定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据完成图书信息表的创建，然后计算所有图书的平均价格，将所有低于平均价格的图书价格提高20%，所有高于或等于平均价格的图书价格提高10%，最后逐行输出价格修改后的图书信息。输入输入n+1行，前n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。最后第n+1行是输入结束标志：0 0 0（空格分隔的三个0）。其中书号和书名为字符串类型，价格为浮点数类型。输出总计n+1行，第1行是修改前所有图书的平均价格，后n行是价格修改后n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔。其中价格输出保留两位小数。
头歌数据结构单链表的基本操作
05-18
头歌数据结构单链表的基本操作 第1关单链表的插入操作 第2关单链表的删除操作 第3关单链表的按照序号查找值操作 第4关单链表的按照值查找结点位序的操作 第5关单链表的逆置操作 第6关两个有序单链表的合并操作 稳过 ...
头歌 顺序表，链表，循环队列的基本操作和应用答案。
05-03
这里我们讨论的是顺序表、链表以及循环队列，这些都是基本的数据结构，广泛应用于算法设计和程序实现中。 顺序表是一种线性数据结构，它在内存中按顺序连续存储元素。它的主要操作包括插入、删除和查找。在顺序表中...
头歌C++数据结构与算法 - 线性表
03-04
头歌C++数据结构与算法 - 线性表
200个经典C程序源码小游戏
05-05
053 顺序表插入和删除 054 链表操作（1） 055 链表操作（2） 056 单链表就地逆置 057 运动会分数统计 058 双链表 059 约瑟夫环 060 记录个人资料 061 二叉树遍利 062 浮点数转换为字符串...
顺序表实现图书信息管理系统
qq_62175345的博客
04-13 4255
设计一个图书信息管理系统，每本图书包含ISBN号、书名、定价信息， 要求实现取值、查找、插入、删除等功能 #include <cstring> #include <iostream> #include <stdlib.h> #define ok 1 #define error 0 #define overflow -2 #define MaxSize 100 using namespace std; typedef int status; //定义 t..
第9关：基于顺序存储结构的图书信息表的旧图书的出库
m0_63759457的博客
12-02 1997
基于顺序存储结构的图书信息表的旧图书的出库
本关任务:定义一个包含图书信息(书号、书名、价格)的顺序表,读入相应的图书数据完
04-05
成表格输出。 步骤： 1. 定义一个结构体Book，包含三个成员变量：书号、书名、价格。 2. 定义一个顺序表bookList，用于存放Book结构体类型的数据。 3. 读入图书数据，包括书号、书名、价格，并将数据存入bookList中。 4. 输出表格，表格包括三列：书号、书名、价格。可以使用printf函数格式化输出。 5. 完成程序编写并测试。 代码如下：

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值