实验一 基于线性表的图书信息管理

仅供参考学习，C语言书写

严蔚敏老师数据结构第二版C语言版实验一，可复制直接运行

以下是输入的数据（严老师课本提供的数据）

欢迎大家私信，一起讨论

1、基于顺序表存储结构的图书信息表的创建和输出
9787302257646 程序设计基础 25.00
9787302164340 程序设计基础(第2版) 20.00
9787302219972 单片机技术及应用 32.00
9787302203513 单片机原理与应用技术 26.00
9787810827430 工业计算机控制技术——原理与应用 29.00
9787811234923 汇编语言程序设计教程 21.00
0 0 0

2、基于顺序表存储结构的图书信息表的排序
9787302257646 程序设计基础 25.00
9787302164340 程序设计基础(第2版) 20.00
9787302219972 单片机技术及应用 32.00
9787302203513 单片机原理与应用技术 26.00
9787810827430 工业计算机控制技术——原理与应用 29.00
9787811234923 汇编语言程序设计教程 21.00
0 0 0

3、基于顺序表存储结构的图书信息表的修改
9787302257646 程序设计基础 25.00
9787302164340 程序设计基础(第2版) 20.00
9787302219972 单片机技术及应用 32.00
9787302203513 单片机原理与应用技术 26.00
9787810827430 工业计算机控制技术——原理与应用 29.00
9787811234923 汇编语言程序设计教程 21.00
0 0 0

4、基于顺序表存储结构的图书信息表的逆序存储
6
9787302257646 程序设计基础 25.00
9787302164340 程序设计基础(第 2 版) 20.00
9787302219972 单片机技术及应用 32.00
9787302203513 单片机原理与应用技术 26.00
9787810827430 工业计算机控制技术——原理与应用 29.00
9787811234923 汇编语言程序设计教程 21.00

5、基于顺序表存储结构的图书信息表的最贵图书的查找
6
9787302257646 程序设计基础 25.00
9787302164340 程序设计基础(第2版) 20.00
9787302219972 单片机技术及应用 32.00
9787302203513 单片机原理与应用技术 26.00
9787810827430 工业计算机控制技术——原理与应用 29.00
9787811230710 C#程序设计易懂易会教程 32.00

6、基于顺序表存储结构的图书信息表的最爱图书的查找
6
9787302257646 程序设计基础 25.00
9787302164340 程序设计基础(第2版) 20.00
9787302219972 单片机技术及应用 32.00
9787302203513 单片机原理与应用技术 26.00
9787810827430 工业计算机控制技术——原理与应用 29.00
9787811234923 汇编语言程序设计教程 21.00
2
数据结构
程序设计基础

7、基于顺序表存储结构的图书信息表的最佳位置图书的查找
6
9787302257646 程序设计基础 25.00
9787302164340 程序设计基础(第2版) 20.00
9787302219972 单片机技术及应用 32.00
9787302203513 单片机原理与应用技术 26.00
9787810827430 工业计算机控制技术——原理与应用 29.00
9787811234923 汇编语言程序设计教程 21.00
2
2
0

8、基于顺序表存储结构的图书信息表的新图书的入库
6
9787302257646 程序设计基础 25.00
9787302164340 程序设计基础(第2版) 20.00
9787302219972 单片机技术及应用 32.00
9787302203513 单片机原理与应用技术 26.00
9787810827430 工业计算机控制技术——原理与应用 29.00
9787811234923 汇编语言程序设计教程 21.00
2
9787302265436 计算机导论实验指导 18.00

9、基于顺序表存储结构的图书信息表的旧图书的出库
6
9787302257646 程序设计基础 25.00
9787302164340 程序设计基础(第2版) 20.00
9787302219972 单片机技术及应用 32.00
9787302203513 单片机原理与应用技术 26.00
9787810827430 工业计算机控制技术——原理与应用 29.00
9787811234923 汇编语言程序设计教程 21.00
2

10、基于顺序表存储结构的图书信息表的图书去重
6
9787302257646 程序设计基础 25.00
9787302164340 程序设计基础(第2版) 20.00
9787302219972 单片机技术及应用 32.00
9787302257646 程序设计基础 25.00
9787810827430 工业计算机控制技术——原理与应用 29.00
9787302219972 单片机技术及应用 32.00

11、基于链式存储结构的图书信息表的创建和输出
9787302257646 程序设计基础 25.00
9787302164340 程序设计基础(第2版) 20.00
9787302219972 单片机技术及应用 32.00
9787302203513 单片机原理与应用技术 26.00
9787810827430 工业计算机控制技术——原理与应用 29.00
9787811234923 汇编语言程序设计教程 21.00
0 0 0

12、基于链式存储结构的图书信息表的排序
9787302257646 程序设计基础 25.00
9787302164340 程序设计基础(第2版) 20.00
9787302219972 单片机技术及应用 32.00
9787302203513 单片机原理与应用技术 26.00
9787810827430 工业计算机控制技术——原理与应用 29.00
9787811234923 汇编语言程序设计教程 21.00
0 0 0

13、基于链式存储结构的图书信息表的修改
9787302257646 程序设计基础 25.00
9787302164340 程序设计基础(第2版) 20.00
9787302219972 单片机技术及应用 32.00
9787302203513 单片机原理与应用技术 26.00
9787810827430 工业计算机控制技术——原理与应用 29.00
9787811234923 汇编语言程序设计教程 21.00
0 0 0

14、基于链式存储结构的图书信息表的逆序存储
6
9787302257646 程序设计基础 25.00
9787302164340 程序设计基础(第 2 版) 20.00
9787302219972 单片机技术及应用 32.00
9787302203513 单片机原理与应用技术 26.00
9787810827430 工业计算机控制技术——原理与应用 29.00
9787811234923 汇编语言程序设计教程 21.00

15、基于链式存储结构的图书信息表的最贵图书的查找
6
9787302257646 程序设计基础 25.00
9787302164340 程序设计基础(第2版) 20.00
9787302219972 单片机技术及应用 32.00
9787302203513 单片机原理与应用技术 26.00
9787810827430 工业计算机控制技术——原理与应用 29.00
9787811230710 C#程序设计易懂易会教程 32.00

16、基于链式存储结构的图书信息图书信息表的最爱图书的查找
6
9787302257646 程序设计基础 25.00
9787302164340 程序设计基础(第2版) 20.00
9787302219972 单片机技术及应用 32.00
9787302203513 单片机原理与应用技术 26.00
9787810827430 工业计算机控制技术——原理与应用 29.00
9787811234923 汇编语言程序设计教程 21.00
2
数据结构
程序设计基础

17、基于链式存储结构的图书信息表的最佳位置图书的查找
6
9787302257646 程序设计基础 25.00
9787302164340 程序设计基础(第2版) 20.00
9787302219972 单片机技术及应用 32.00
9787302203513 单片机原理与应用技术 26.00
9787810827430 工业计算机控制技术——原理与应用 29.00
9787811234923 汇编语言程序设计教程 21.00
2
2
0

18、基于链式存储结构的图书信息表的新图书的入库
6
9787302257646 程序设计基础 25.00
9787302164340 程序设计基础(第2版) 20.00
9787302219972 单片机技术及应用 32.00
9787302203513 单片机原理与应用技术 26.00
9787810827430 工业计算机控制技术——原理与应用 29.00
9787811234923 汇编语言程序设计教程 21.00
2
9787302265436 计算机导论实验指导 18.00

19、基于链式存储结构的图书信息表的旧图书的出库
6
9787302257646 程序设计基础 25.00
9787302164340 程序设计基础(第2版) 20.00
9787302219972 单片机技术及应用 32.00
9787302203513 单片机原理与应用技术 26.00
9787810827430 工业计算机控制技术——原理与应用 29.00
9787811234923 汇编语言程序设计教程 21.00
2

20、基于链式存储结构的图书信息表的图书去重
6
9787302257646 程序设计基础 25.00
9787302164340 程序设计基础(第2版) 20.00
9787302219972 单片机技术及应用 32.00
9787302257646 程序设计基础 25.00
9787810827430 工业计算机控制技术——原理与应用 29.00
9787302219972 单片机技术及应用 32.00

#define _CRT_SECURE_NO_WARNINGS

#include<stdio.h>
#include <stdlib.h>
#include<string.h>
#include <algorithm>

using namespace std;//排序函数
#define TURE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
#define LIST_MAXSIZE 1000//定义图表的最大长度

//定义图书表的顺序储存结构
//定义图书信息
typedef struct {
    char no[20];//ISBN
    char name[50];//书名
    float price;//价格
} Book;

typedef struct node//用于链表去重
{
    long long int no;
    char name[50];
    double price;
    struct node *next;
} Book1, *BookList;

//定义顺序储存结构类型
typedef struct {
    Book *elem;//储存空间基地址
    int length;//当前图书个数
} SqList;
typedef int ElemType;

//初始化一个顺序表
ElemType InitList_SqList(SqList &L) {
    L.elem = (Book *) malloc(LIST_MAXSIZE * sizeof(Book));//分配空间
    if (!L.elem)//分配失败
    {
        exit(OVERFLOW);
    }
    L.length = 0;//空表长度为0
    return OK;
}

//顺序表输入
ElemType ListInsert(SqList &L) {
    int i = 1;
    while (1) {
        if (i > LIST_MAXSIZE)//输入图书信息数超过最大值，退出	
        {
            exit(OVERFLOW);
        }
        scanf("%s %s %f", L.elem[i].no, L.elem[i].name, &L.elem[i].price);//输入图书数据 		
        if (!strcmp(L.elem[i].no, "0") && !strcmp(L.elem[i].name, "0") && L.elem[i].price == 0) {
            break;//输入结束标志0 0 0，表示停止输入
        }
        i++;
    }
    L.length = i - 1;
    return i - 1;
}

//顺序表逆序输入
ElemType NListInsert(SqList &L) {
    int i, t;
    scanf("%d", &i);
    t = i;
    while (1) {
        if (i > LIST_MAXSIZE)//输入图书信息数超过最大值，退出	
        {
            exit(OVERFLOW);
        }
        if (i == 0)//结束输入
        {
            break;
        }
        scanf("%s %s %f", L.elem[i].no, L.elem[i].name, &L.elem[i].price);//输入图书数据 		
        i--;
    }
    L.length = t;
    return L.length;
}

//顺序表输出
ElemType ListOutput(SqList &L) {
    for (int i = 1; i <= L.length; i++) {
        printf("%s %s %.2f\n", L.elem[i].no, L.elem[i].name, L.elem[i].price);//输出图书信息表 		
    }
    return OK;
}

//顺序表排序
bool cmp(Book L1, Book L2) {//按照价格降序排序
    if (L1.price > L2.price)
        return true;
    else
        return false;
}

ElemType SqSort(SqList &L) {//排序（顺序存储）
    sort(&(L.elem[1]), &(L.elem[L.length + 1]), cmp);
    return OK;
}

//顺序表修改价格
ElemType SqList_Price(SqList &L) {
    float avg = 0;//平均价格 
    for (int i = 1; i <= L.length; i++) {
        avg += L.elem[i].price;//计算所有书的总价格 
    }
    avg /= L.length;//所有书的平均价格=总价/书本数量 
    for (int i = 1; i <= L.length; i++) {
        if (L.elem[i].price >= avg)//高于或等于平均价格的图书价格提高 10%
        {
            L.elem[i].price *= 1.1;
        } else if (L.elem[i].price < avg)//低于平均价格的图书价格提高20%
        {
            L.elem[i].price *= 1.2;
        }
    }
    printf("%.2f\n", avg);//输出平均价格 
    return OK;
}

//顺序表找最贵的书
ElemType SqList_Max(SqList &L) {
    int n;//图书数目 
    printf("请输入数据：\n");
    scanf("%d", &n);//输入图书数目 
    InitList_SqList(L); //初始化线性表 	
    L.length = n;//给线性表中的图书数目赋值 
    if (n < 1 || n > LIST_MAXSIZE)
        return OK;
    int i = 1;
    while (i <= n) {
        scanf("%s %s %f", L.elem[i].no, L.elem[i].name, &L.elem[i].price);//输入图书信息表 
        i++;
    }
    int maxprice[LIST_MAXSIZE];//最贵图书在线性表中的编号 
    int len = 0, max = 0;//len:最贵图书的数目  max：最贵图书价格
    printf("\n");
    printf("--------------------------------------------\n");
    printf("\n");
    printf("输出的结果为：\n");
    for (int i = 1; i <= n; i++)//查找最贵图书并记录其在线性表中的编号 
    {
        if (L.elem[i].price > max)//找到更贵的图书 
        {
            len = 1;//更贵图书的数目记为1 
            maxprice[len] = i;//记录更贵图书在线性表中的编号 
            max = L.elem[i].price;//修改最贵图书价格 
        } else if (max == L.elem[i].price)//找到下一本最贵图书
        {
            len++;//最贵图书的数目加1 
            maxprice[len] = i;//记录更贵图书在线性表中的编号			
        }
    }
    printf("%d\n", len);//输出最贵图书的数目
    for (int i = 1; i <= len; i++)//输出最贵图书的信息 
    {
        int j;
        j = maxprice[i];
        printf("%s %s %.2f\n", L.elem[j].no, L.elem[j].name, L.elem[j].price);//根据编号输出最贵图书的信息 
    }
    return OK;
    //也可以采用顺序表删除
}

//顺序表找出最喜爱的书
ElemType SqList_Favor(SqList &L) {
    int n;//图书数量
    int i, j;
    Book b[LIST_MAXSIZE];
    printf("请输入数据\n");
    scanf("%d", &n);
    for (i = 0; i < n; i++) {
        scanf("%s %s %f", &b[i].no, &b[i].name, &b[i].price);
    }
    int m, t;//查找m次
    scanf("%d", &m);
    Book b_1[LIST_MAXSIZE];
    for (int k = 0; k < m; k++) {
        scanf("%s", &b_1[k].name);
    }
    printf("\n");
    printf("--------------------------------------------\n");
    printf("\n");
    printf("输出的结果为：\n");
    for (int k = 0; k < m; k++) {
        t = 0;
        for (j = 0; j < i; j++) {
            if (!strcmp(b_1[k].name, b[j].name)) {
                t++;
            }
        }
        if (t == 0) {
            printf("抱歉，这里没有你的最爱！\n");
        } else {
            printf("%d\n", t);
            for (j = 0; j < i; j++) {
                if (!strcmp(b_1[k].name, b[j].name)) {
                    printf("%s %s %.2f\n", b[j].no, b[j].name, b[j].price);
                }
            }
        }
    }
    return OK;
}

//顺序表图书位置查找
ElemType SqList_Place(SqList &L) {
    int n;//图书数量
    int i, j;
    Book b[LIST_MAXSIZE];
    printf("请输入数据\n");
    scanf("%d", &n);
    for (i = 1; i <= n; i++) {
        scanf("%s %s %f", &b[i].no, &b[i].name, &b[i].price);
    }
    int m;//查找m次
    scanf("%d", &m);
    int b_1[LIST_MAXSIZE];
    for (int k = 0; k < m; k++) {
        scanf("%d", &b_1[k]);
    }
    printf("\n");
    printf("--------------------------------------------\n");
    printf("\n");
    printf("输出的结果为：\n");
    for (int k = 0; k < m; k++) {
        for (j = 1; j <= n; j++) {
            if (b_1[k] == j)//对应位置并输出
            {
                printf("%s %s %.2f\n", b[j].no, b[j].name, b[j].price);
            }
        }
        if (b_1[k] > i || b_1[k] < 1)//位置不存在
        {
            printf("抱歉，最佳位置上的图书不存在！\n");
        }
    }
    return OK;
}

//顺序表新书入库
ElemType SqList_Enter(SqList &L) {
    int n, j, i;
    Book in_b;
    printf("请输入数据\n");
    scanf("%d", &n);
    for (j = 1; j <= n; j++) {
        scanf("%s %s %f", L.elem[j].no, L.elem[j].name, &L.elem[j].price);
    }
    L.length = n;
    scanf("%d", &i);
    if ((i < 1) || (i > L.length + 1) || (i == LIST_MAXSIZE)) {
        printf("\n");
        printf("--------------------------------------------\n");
        printf("\n");
        printf("抱歉，入库位置非法!\n");//i值不合法
        return ERROR;
    } else {
        scanf("%s %s %f", &in_b.no, &in_b.name, &in_b.price);
        printf("\n");
        printf("--------------------------------------------\n");
        printf("\n");
        printf("输出的结果为：\n");
        for (j = L.length; j >= i; j--) {
            L.elem[j + 1] = L.elem[j];//插入位置及之后的元素右移
        }
        L.elem[i] = in_b;//将新元素e放入第i个位置
        ++L.length;//表长加1
        for (j = 1; j <= L.length; j++) {
            printf("%s %s %.2f\n", L.elem[j].no, L.elem[j].name, L.elem[j].price);//输出图书信息表 		
        }
        return OK;
    }
}

//顺序表旧书出库
ElemType SqList_Output(SqList &L) {
    int n, j, i;
    printf("请输入数据\n");
    scanf("%d", &n);
    for (j = 1; j <= n; j++) {
        scanf("%s %s %f", L.elem[j].no, L.elem[j].name, &L.elem[j].price);
    }
    L.length = n;
    scanf("%d", &i);
    if ((i < 1) || (i > L.length)) {
        printf("\n");
        printf("--------------------------------------------\n");
        printf("\n");
        printf("抱歉，出库位置非法!\n");//i值不合法
        return ERROR;
    } else {
        printf("\n");
        printf("--------------------------------------------\n");
        printf("\n");
        printf("输出的结果为：\n");
        for (j = i + 1; j <= n; j++) {
            L.elem[j - 1] = L.elem[j];//删除位置及之后的元素左移
        }
        --L.length;//表长减1
        for (j = 1; j <= L.length; j++) {
            printf("%s %s %.2f\n", L.elem[j].no, L.elem[j].name, L.elem[j].price);//输出图书信息表 		
        }
        return OK;
    }
}

//顺序表去重
ElemType SqList_Repeat(SqList &L) {
    int n, j, i, t;
    printf("请输入数据\n");
    scanf("%d", &n);
    for (j = 1; j <= n; j++)//输入
    {
        scanf("%s %s %f", L.elem[j].no, L.elem[j].name, &L.elem[j].price);
    }
    L.length = n;
    for (i = 1; i <= n; i++)//书号循环对比
    {
        for (j = i + 1; j <= n; j++) {
            if (!strcmp(L.elem[i].no, L.elem[j].no))//重复删除
            {
                for (t = j + 1; t <= n; t++) {
                    L.elem[t - 1] = L.elem[t];//删除位置及之后的元素左移
                }
                --n;//表长减1
                --j;
            }
        }
    }
    printf("\n");
    printf("--------------------------------------------\n");
    printf("\n");
    printf("输出的结果为：\n");
    printf("%d\n", n);
    for (j = 1; j <= n; j++) {
        printf("%s %s %.2f\n", L.elem[j].no, L.elem[j].name, L.elem[j].price);//输出图书信息表 		
    }
    return OK;
}

//定义链式储存结构类型
typedef struct LNODE {
    Book elem;//数据域
    LNODE *next;//指针域
} LNODE, *LinkList;

//初始化链表
ElemType Init(LinkList L) {
    L = (LinkList) malloc(sizeof(LNODE));//分配结点空间
    if (!L) {
        exit(OVERFLOW);//空间分配失败，退出 
    }
    L->next = NULL;//下一本书的地址为空 
    return OK;//空间分配完成 	
}

//链表输出数目
ElemType LNum(LinkList L) {
    LinkList r = L;   //输入
    int i;
    for (i = 0; i < LIST_MAXSIZE; i++) {
        LinkList p = (LinkList) malloc(sizeof(LNODE));
        scanf("%s %s %f", &p->elem.no, &p->elem.name, &p->elem.price);
        if (!(strcmp(p->elem.no, "0")) && !(strcmp(p->elem.name, "0")) && p->elem.price == 0) {
            break;
        }
        p->next = NULL;
        r->next = p;
        r = p;
    }
    printf("\n");
    printf("--------------------------------------------\n");
    printf("\n");
    printf("输出的结果为：\n");
    if (i)
        printf("%d\n", i);
    else//异常
        return OK;
    LinkList p = L->next;//输出
    while (p != NULL) {
        printf("%s %s %.2f\n", p->elem.no, p->elem.name, p->elem.price);
        p = p->next;
    }
    return OK;
}

//链表输入 (后插）
ElemType LInsert(LinkList &L) {
    LinkList r = L;   //尾指针r指向头结点
    int i;
    for (i = 1; i <= LIST_MAXSIZE; i++) {
        LinkList p = (LinkList) malloc(sizeof(LNODE));
        scanf("%s %s %f", &p->elem.no, &p->elem.name, &p->elem.price);
        if (!(strcmp(p->elem.no, "0")) && !(strcmp(p->elem.name, "0")) && p->elem.price == 0) {
            break;
        }
        p->next = NULL;
        r->next = p;
        r = p;
    }
    return OK;
}

//链表输出
ElemType LOutput(LinkList L) {
    LinkList p = L->next;
    while (p != NULL) {
        printf("%s %s %.2f\n", p->elem.no, p->elem.name, p->elem.price);
        p = p->next;
    }
    return OK;
}

//链表排序
ElemType LSort(LinkList L) {
    if (L->next == NULL || L->next->next == NULL)//线性表无元素或只有一个元素，无需排序	
    {
        return OK;
    }
    LinkList pre = L;//操作结点的前一个结点 
    LinkList now = L->next;//操作结点 
    LinkList tail = NULL;    //尾结点 
    while (L->next != tail)//冒泡排序 
    {
        pre = L;
        now = L->next;
        int flag = 0;
        while (now->next != tail) {
            if (now->elem.price < now->next->elem.price) {
                flag = 1;
                pre->next = now->next;
                now->next = now->next->next;
                pre->next->next = now;
                pre = pre->next;
            } else {
                pre = pre->next;
                now = now->next;
            }
        }
        if (flag == 0) {
            break;
        } else {
            tail = now;
        }
    }
    return OK;
}

//链表提高图书价格
ElemType LPrice(LinkList &L) {
    int num = 0;//图书数量 
    float avg = 0;//图书平均价格 
    LinkList p = L->next;
    while (p != NULL)//遍历线性表 
    {
        avg += p->elem.price;//计算图书总价 
        num++;//统计图书数量 
        p = p->next;
    }
    avg /= num;//图书均价=总价/图书数量 
    p = L->next;
    while (p != NULL) {
        if (p->elem.price >= avg) {
            p->elem.price *= 1.1;//所有高于或等于平均价格的图书价格提高10%
        } else if (p->elem.price < avg) {
            p->elem.price *= 1.2;//所有低于平均价格的图书价格提高20%
        }
        p = p->next;
    }
    printf("%.2f\n", avg);//输出图书均价
    return OK;
}

//链表逆序输出(头插）
ElemType NInsert(LinkList &L) {
    int n, i;
    scanf("%d", &n);
    LinkList p = L;
    for (i = 1; i <= n; i++)//输入
    {
        LinkList r = (LinkList) malloc(sizeof(LNODE));
        scanf("%s %s %f", &r->elem.no, &r->elem.name, &r->elem.price);
        r->next = p->next;
        p->next = r;
    }
    p = p->next;
    printf("\n");
    printf("--------------------------------------------\n");
    printf("\n");
    printf("输出的结果为：\n");
    for (i = 1; i <= n; i++)//输出
    {
        printf("%s %s %.2f\n", p->elem.no, p->elem.name, p->elem.price);
        p = p->next;
    }
    return OK;
}

//链表最贵图书
ElemType LExpensive(LinkList &L) {
    int n, i, m, k;
    LinkList r = L;
    scanf("%d", &n);
    for (i = 0; i < n; i++) //后插输入
    {
        LinkList p = (LinkList) malloc(sizeof(LNODE));
        scanf("%s %s %f", &p->elem.no, &p->elem.name, &p->elem.price);
        p->next = NULL;
        r->next = p;
        r = p;
    }
    if (L->next == NULL || L->next->next == NULL)//线性表无元素或只有一个元素，无需排序	
    {
        return OK;
    }
    LinkList pre = L;//操作结点的前一个结点 
    LinkList now = L->next;//操作结点 
    LinkList tail = NULL;    //尾结点 
    while (L->next != tail)//冒泡排序 
    {
        pre = L;
        now = L->next;
        int flag = 0;
        while (now->next != tail) {
            if (now->elem.price < now->next->elem.price) {
                flag = 1;
                pre->next = now->next;
                now->next = now->next->next;
                pre->next->next = now;
                pre = pre->next;
            } else {
                pre = pre->next;
                now = now->next;
            }
        }
        if (flag == 0) {
            break;
        } else {
            tail = now;
        }
    }
    LinkList p = L->next;
    int max = p->elem.price;
    i = 0;
    printf("\n");
    printf("--------------------------------------------\n");
    printf("\n");
    printf("输出的结果为：\n");
    while (p->elem.price == max) {
        i++;
        p = p->next;
    }
    printf("%d\n", i);
    while (p)
        p = p->next;
    p = L->next;
    while (p->elem.price == max) {
        printf("%s %s %.2f\n", p->elem.no, p->elem.name, p->elem.price);
        p = p->next;
    }
    return OK;
}

//链表最爱图书
ElemType LFavor(LinkList &L) {
    int n, i, m, k, t;
    scanf("%d", &n);
    LinkList p = L;
    for (i = 1; i <= n; i++)//输入 
    {
        LinkList r = (LinkList) malloc(sizeof(LNODE));
        scanf("%s %s %f", &r->elem.no, &r->elem.name, &r->elem.price);
        r->next = NULL;
        p->next = r;
        p = r;
    }
    scanf("%d", &k);//输入查找数目
    //输入查找书名
    Book a[LIST_MAXSIZE];
    for (i = 0; i < k; i++) {
        scanf("%s", &a[i].name);
    }
    for (i = 0; i < k; i++) {//遍历查找计算符合条件的书数量
        m = 0;
        LinkList now = L->next;//操作结点
        while (now->next) {
            if (!strcmp(now->elem.name, a[i].name)) {
                m++;
                now = now->next;
            } else
                now = now->next;
        }
        //输出数量
        printf("\n");
        printf("--------------------------------------------\n");
        printf("\n");
        printf("输出的结果为：\n");
        if (m)
            printf("%d\n", m);
        else//未找到
            printf("抱歉，没有你的最爱！\n");
        //输出图书信息
        now = L->next;
        while (now->next) {
            if (!strcmp(now->elem.name, a[i].name)) {
                printf("%s %s %.2f\n", now->elem.no, now->elem.name, now->elem.price);
                break;
            } else
                now = now->next;
        }
    }
    return OK;
}

//链表最爱位置
ElemType LPlace(LinkList L) {
    int n, i, m, k;
    LinkList r = L;
    scanf("%d", &n);
    for (i = 0; i < n; i++) //后插输入
    {
        LinkList p = (LinkList) malloc(sizeof(LNODE));
        scanf("%s %s %f", &p->elem.no, &p->elem.name, &p->elem.price);
        p->next = NULL;
        r->next = p;
        r = p;
    }
    LinkList p = L->next;
    int b_1[LIST_MAXSIZE];
    scanf("%d", &m);//查找m次
    for (k = 0; k < m; k++)//输入位置
    {
        scanf("%d", &b_1[k]);
    }
    for (k = 0; k < m; k++)//分别查找位置
    {
        if (b_1[k] < 1 || b_1[k] > n) {
            printf("\n");
            printf("--------------------------------------------\n");
            printf("\n");
            printf("抱歉，最佳位置上的图书不存在！\n");
        }//位置不合法
        else {
            printf("\n");
            printf("--------------------------------------------\n");
            printf("\n");
            printf("输出的结果为：\n");
            for (i = 1; i < b_1[k]; i++) {
                p = p->next;
            }
            printf("%s %s %.2f\n", p->elem.no, p->elem.name, p->elem.price);
        }
    }
    return OK;
}

//链表新书入库
ElemType LNew(LinkList L) {
    int n, i, m, k;
    LinkList r = L;
    scanf("%d", &n);
    for (i = 0; i < n; i++) //后插输入
    {
        LinkList p = (LinkList) malloc(sizeof(LNODE));
        scanf("%s %s %f", &p->elem.no, &p->elem.name, &p->elem.price);
        p->next = NULL;
        r->next = p;
        r = p;
    }
    scanf("%d", &k);
    if (k > n + 1 || k < 1) {
        printf("\n");
        printf("--------------------------------------------\n");
        printf("\n");
        printf("抱歉，入库位置非法!\n");
    } else {
        LinkList p = (LinkList) malloc(sizeof(LNODE));
        scanf("%s %s %f", &p->elem.no, &p->elem.name, &p->elem.price);
        r = L->next;
        for (i = 1; i < k - 1; i++) {
            r = r->next;
        }
        p->next = r->next;
        r->next = p;
        printf("\n");
        printf("--------------------------------------------\n");
        printf("\n");
        printf("输出的结果为：\n");
        LOutput(L);
    }
    return OK;
}

//链表旧书出库
ElemType LOld(LinkList L) {
    int n, i, m, k;
    LinkList r = L;
    scanf("%d", &n);
    for (i = 0; i < n; i++) //后插输入
    {
        LinkList p = (LinkList) malloc(sizeof(LNODE));
        scanf("%s %s %f", &p->elem.no, &p->elem.name, &p->elem.price);
        p->next = NULL;
        r->next = p;
        r = p;
    }
    scanf("%d", &k);
    if (k > n || k < 1) {
        printf("\n");
        printf("--------------------------------------------\n");
        printf("\n");
        printf("抱歉，出库位置非法!\n");
    } else {
        r = L->next;
        for (i = 1; i < k - 1; i++) {
            r = r->next;
        }
        r->next = r->next->next;
        printf("\n");
        printf("--------------------------------------------\n");
        printf("\n");
        printf("输出的结果为：\n");
        LOutput(L);
    }
    return OK;
}

int main() {
    int a;
    printf("问题如下：\n");
    printf("1、基于顺序表存储结构的图书信息表的创建和输出？\n");
    printf("2、基于顺序表存储结构的图书信息表的排序？\n");
    printf("3、基于顺序表存储结构的图书信息表的修改？\n");
    printf("4、基于顺序表存储结构的图书信息表的逆序存储？\n");
    printf("5、基于顺序表存储结构的图书信息表的最贵图书的查找？\n");
    printf("6、基于顺序表存储结构的图书信息表的最爱图书的查找？\n");
    printf("7、基于顺序表存储结构的图书信息表的最佳位置图书的查找？\n");
    printf("8、基于顺序表存储结构的图书信息表的新图书的入库？\n");
    printf("9、基于顺序表存储结构的图书信息表的旧图书的出库？\n");
    printf("10、基于顺序表存储结构的图书信息表的图书去重？\n");
    printf("11、基于链式存储结构的图书信息表的创建和输出？\n");
    printf("12、基于链式存储结构的图书信息表的排序？\n");
    printf("13、基于链式存储结构的图书信息表的修改？\n");
    printf("14、基于链式存储结构的图书信息表的逆序存储？\n");
    printf("15、基于链式存储结构的图书信息表的最贵图书的查找？\n");
    printf("16、基于链式存储结构的图书信息表的最爱图书的查找？\n");
    printf("17、基于链式存储结构的图书信息表的最佳位置图书的查找？\n");
    printf("18、基于链式存储结构的图书信息表的新图书的入库？\n");
    printf("19、基于链式存储结构的图书信息表的旧图书的出库？\n");
    printf("20、基于链式存储结构的图书信息表的图书去重？\n");
    printf("请输入你想查看的问题（输入数字）:\n");
    scanf("%d", &a);
    if (a > 0 && a < 11) {//顺序表
        switch (a) {
            case 1: {//顺序表的创建和输出
                SqList L;
                InitList_SqList(L);
                printf("请输入数据：\n");
                int i;
                i = ListInsert(L);
                printf("\n");
                printf("--------------------------------------------\n");
                printf("\n");
                printf("输出的结果为：\n");
                printf("%d\n", i);
                ListOutput(L);
                break;
            }
            case 2: {//顺序表的排序(从高到低)
                SqList L;
                InitList_SqList(L);
                printf("请输入数据：\n");
                ListInsert(L);
                SqSort(L);
                printf("\n");
                printf("--------------------------------------------\n");
                printf("\n");
                printf("输出的结果为：\n");
                ListOutput(L);
                break;
            }
            case 3: {//顺序表修改价格
                SqList L;
                InitList_SqList(L);
                printf("请输入数据：\n");
                ListInsert(L);
                printf("\n");
                printf("--------------------------------------------\n");
                printf("\n");
                printf("输出的结果为：\n");
                SqList_Price(L);
                ListOutput(L);
                break;
            }
            case 4: {//顺序表逆序存储
                SqList L;
                InitList_SqList(L);
                printf("请输入数据：\n");
                NListInsert(L);
                printf("\n");
                printf("--------------------------------------------\n");
                printf("\n");
                printf("输出的结果为：\n");
                ListOutput(L);
                break;
            }
            case 5: {//找出最贵的书
                SqList L;
                SqList_Max(L);
                break;
            }
            case 6: {//最爱图书查找
                SqList L;
                SqList_Favor(L);
                break;
            }
            case 7: {//图书位置查找
                SqList L;
                InitList_SqList(L);
                SqList_Place(L);
                break;
            }
            case 8: {//新图书的入库
                SqList L;
                InitList_SqList(L);
                SqList_Enter(L);
                break;
            }
            case 9: {//旧书出库
                SqList L;
                InitList_SqList(L);
                SqList_Output(L);
                break;
            }
            case 10: {//去重
                SqList L;
                InitList_SqList(L);
                SqList_Repeat(L);
                break;
            }
        }
    }
    if (a > 10 && a < 21) {//链表
        printf("请输入数据：\n");
        switch (a) {//链表
            case 11: {//创建输出链表
                LinkList L;
                L = (LinkList) malloc(sizeof(LNODE));
                Init(L);
                LNum(L);
                break;
            }
            case 12: {//链表排序
                LinkList L;
                L = (LinkList) malloc(sizeof(LNODE));
                Init(L);
                LInsert(L);
                LSort(L);
                printf("\n");
                printf("--------------------------------------------\n");
                printf("\n");
                printf("输出的结果为：\n");
                LOutput(L);
                break;
            }
            case 13: {//链表修改价格
                LinkList L;
                L = (LinkList) malloc(sizeof(LNODE));
                Init(L);
                LInsert(L);
                printf("\n");
                printf("--------------------------------------------\n");
                printf("\n");
                printf("输出的结果为：\n");
                LPrice(L);
                LOutput(L);
                break;
            }
            case 14: {//链表逆序输出
                LinkList L;
                L = (LinkList) malloc(sizeof(LNODE));
                Init(L);
                NInsert(L);
                break;
            }
            case 15: {//链表最贵图书
                LinkList L;
                L = (LinkList) malloc(sizeof(LNODE));
                Init(L);
                LExpensive(L);
                break;
            }
            case 16: {//链表最爱图书
                LinkList L;
                L = (LinkList) malloc(sizeof(LNODE));
                Init(L);
                LFavor(L);
                break;
            }
            case 17: {//链表最爱位置
                LinkList L;
                L = (LinkList) malloc(sizeof(LNODE));
                Init(L);
                LPlace(L);
                break;
            }
            case 18: {//链表新书入库
                LinkList L;
                L = (LinkList) malloc(sizeof(LNODE));
                Init(L);
                LNew(L);
                break;
            }
            case 19: {//链表旧书出库
                LinkList L;
                L = (LinkList) malloc(sizeof(LNODE));
                Init(L);
                LOld(L);
                break;
            }
            case 20: {//链表去重
                int n;
                scanf("%d", &n);
                BookList L;
                Book1 *p, *q, *rear;
                L = (Book1 *) malloc(sizeof(Book));
                L->no = n;
                L->next = NULL;
                rear = L;
                while (n--)//输入
                {
                    p = (Book1 *) malloc(sizeof(Book));
                    scanf("%lld %s %lf", &p->no, p->name, &p->price);
                    rear->next = p;
                    rear = p;
                }
                rear->next = NULL;
                p = L;
                printf("\n");
                printf("--------------------------------------------\n");
                printf("\n");
                printf("输出的结果为：\n");
                while (p->next)//查找重复并删除
                {
                    int flag = 1;
                    q = L->next;
                    while (q != p->next) {
                        if (q->no == p->next->no) {
                            q = p->next;
                            p->next = q->next;
                            L->no--;
                            free(q);
                            flag = 0;
                            break;
                        }
                        q = q->next;
                    }
                    if (flag == 1)
                        p = p->next;
                }
                printf("%d\n", L->no);
                p = L->next;
                while (p)//输出
                {
                    printf("%lld %s %.2f\n", p->no, p->name, p->price);
                    p = p->next;
                }
                break;
            }
        }
    }
    system("pause");
    return 0;
}