C语言实现_模拟飞机票订票和退票系统

数据结构第一次大作业，学校使用的是C语言来讲解数据结构，所以本博文以C语言来完成，对于所需要的相关数据结构均采用手写方式完成。

---

具体问题

问题描述：

假定某民航有M个航次的班机，每个航次都只到达一个地方。试为该机场售票处设计一个自动订票和退票系统，要求系统具有以下功能：

1. 订票：若该航次余票大于等于乘客订票数，则在该航次的乘客表中，插入订票乘客的信息项，并修改该航次有关数据，否则给出相应信息。
2. 退票：若该航次当前退票数小于等于乘客原订票数，则在相应的乘客表中找到该乘客项，修改该航次及乘客表中有关数据；当某乘客由于退票使订票数为零时，则从乘客表中撤消该数据项。

问题要求：

1. 描述对航次表和乘客表选用的数据结构。
2. 编程实现飞机票订票和退票系统。

---

解决方案

分析数据结构:

主要数据有两种，一是乘客及其信息，二是航班及其信息。

Passenger:

Type	名称	name
char[]	名字	name
char[]	证件号	id
int	购票数量	numberOfTicket

Passenger以双向循环链表形式储存
LinkedList< Passenger >(PassengerNode)：

Type	名称	name
Passenger	当前乘客	data
int	是否是头节点	isHeader
PassengerNode*	下一节点	next
PassengerNode*	上一节点	pre

Airplane:

Type	名称	name
char[]	航班名称	id
int[2]	出发时间(时、分)	startTime
int[3]	到达时间(时、分、第二天)	arrivalTime
char[]	起飞地点	startPlace
char[]	到达地点	arrivalPlace
int	限载人数	maxNumberOfPassengers
int	已订票人数	numberOfPassenger
PassengerNode*	订票乘客链表	linkOfPassengers

Airplane以优先链式队列形式储存，以出发时间为优先级
PriorityQueue< Airplane >(PriqueueNode)：

Type	名称	name
Airplane	当前航班	data
int	是否是头文件	isHeader
PriqueueNode*	下一结点	next
PriqueueNode*	上一结点	pre

实现函数:

Passenger：

参数	函数名	作用	返回值
int, Passenger	ChangeNumTicket	修改购票数量	Passenger

LinkedList< Passenger >：

参数	函数名	作用	返回值
PassengerNode*, Passenger	InitPassenger	构造乘客数据	void
PassengerNode*, PassengerNode*	InsertPassenger2Link	向链表中插入某一乘客	void
PassengerNode*, char[]	FindPassenger	查找某一乘客	PassengerNode*
PassengerNode*	DeletePassengerInLink	删除某一乘客	PassengerNode*
PassengerNode*	FreePassenger	释放该节点空间	void
PassengerNode*	GetNumberOfTicket	返回该乘客购票数量	int

扫描二维码关注公众号，回复： 11794061 查看本文章

Airplane：

参数	函数名	作用	返回值
void	InitAirplane	随机创建航班信息	Airplane
int, Airplane*	ChangeNumOfPassenger	修改已订票乘客数	Airplane*
Airplane*, PassengerNode*	InsertPassenger2Air	向航班中插入某一乘客	Airplane*
Airplane, Airplane	CmpAirplane	比较两个航班优先级	bool
Airplane*, int	GetArrivalTime	获取航班到达时间	void

PriorityQueue< Airplane >:

参数	函数名	作用	返回值
Airplane,PriqueueNode*	InitAirplaneQueue	创建一个队列	void
PriqueueNode*	IsEmptyQueue	判断是否为空	bool
PriqueueNode*	TopQueue	获取首位元素	Airplane
PriqueueNode*	PopQueue	删除首位元素	void
PriqueueNode*,Airplane	InsertAirplane2PriqueueNode	向队列中插入某一航班	int
char[], PriqueueNode*	FindAirplane	查找队列中的某一航班	PriqueueNode*
PriqueueNode	ShowAirplane	展示某一航班信息	void
PriqueueNode*	ShowAllAirplane	展示所有航班信息	void
char[], PriqueueNode*	ShowAirplane2Place	展示到某地航班信息	void
PriqueueNode*	ShowPassengers	展示航班乘客信息	void
char[], PriqueueNode*	ShowPassengerInQueue	展示乘客的所有航班信息	int

定票退票操作：

参数	函数名	作用	返回值
void	GetAirplane	随机创建航班信息	PriqueueNode*
void	BookTickets	乘客定票	void
void	GetRefund	乘客退票	void

实现思路:

将乘客链表函数作为一个单独头文件 link_passenger.h ，文件包含LinkedList< Passenger >的所有函数。

将优先队列函数也作为一个单独的头文件 priorityqueue_airplane.h ，文件包含PriorityQueue< Airplane >的所有函数。

将有关乘订票退票的操作作为另一个头文件 airplane_reservation_sys.h ，文件包含Airplane、Passenger和乘客订票退票的函数。

在文件 AirReservationSys.c 中完成所有其他操作(main部分)。

---

代码注释：

Part1:   link_passenger.h:

/*
 * @Description: Big_homework1_AirReservationSys;
 * A header file of 2way_cycle_link， is for the Passengers Link.
 * @Autor: G_Rampart
 * @Date: 2019-10-01 21:25:24
 * @LastEditTime: 2019-10-05 23:25:16
 */
#ifndef LINK_PASSENGER_H
#define LINK_PASSENGER_H
#define nameSize 50
#define idSize 20
#define maxnTime 1440
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

struct passenger
{
    
    
    char name[nameSize];
    char id[idSize];
    int numberOfTicket;
};
//乘客数据结构
typedef struct passenger Passenger;

struct passengerNode
{
    
    
    int isHeader;
    Passenger data;
    struct passengerNode *next;
    struct passengerNode *pre;
};
// 双向循环链表结点结构
typedef struct passengerNode PassengerNode;

// 获取（int）[a,b]之间的随机数
int getRandom(int a, int b);
// 改变乘客（Passenger *）p的购票数量，改变成（int）n.
Passenger *ChangeNumTicket(int n, Passenger *p);
// 初始化乘客信息链表结点（PassengerNode *）p，信息为（Passenger）data.
void InitPassengerNode(PassengerNode *p, Passenger data);
//在链表中结点（Passenger *）pre后插入结点（PassnegerNode *）n.
void InsertPassenger2Link(PassengerNode *pre, PassengerNode *n);
/**
 * 在链表中（以first为首结点）寻找名字（char[]）为name的结点.
 * 成功后返回该结点指针，否则返回NNULL.
**/
PassengerNode *FindPassenger(PassengerNode *first, char id[]);
// 在链表中删除结点（PassengerNode *）p，并返回该结点.
PassengerNode *DeletePassenger(PassengerNode *p);
// 释放某一乘客结点（PassengerNode *） p的数据空间.
void FreePassenger(PassengerNode *p);
// 返回乘客结点（PassengerNode *）p购票数量(int)
int GetNumberOfTicket(PassengerNode *p);

int getRandom(int a, int b)
{
    
    
    return rand() % (b - a + 1) + a;
}

Passenger *ChangeNumTicket(int n, Passenger *p)
{
    
    
    p->numberOfTicket = n;
    return p;
}

void InitPassengerNode(PassengerNode *p, Passenger data)
{
    
    
    p->isHeader = 0;
    p->data = data;
    p->next = p;
    p->pre = p;
    return;
}

void InsertPassenger2Link(PassengerNode *pre, PassengerNode *n)
{
    
    
    n->next = pre->next;
    n->pre = pre;
    pre->next->pre = n;
    pre->next = n;
    return;
}

PassengerNode *FindPassenger(PassengerNode *first, char id[])
{
    
    
    PassengerNode *temp = (PassengerNode *)malloc(sizeof(PassengerNode));
    temp = first;
    int sign = 1;
    while (temp != first || sign == 1)
    {
    
    
        sign = 0;
        if (temp->isHeader)
        {
    
    
            temp = temp->next;
            continue;
        }
        if (strcmp(temp->data.id, id) == 0)
            return temp;
        temp = temp->next;
    }
    return NULL;
}

PassengerNode *DeletePassenger(PassengerNode *p)
{
    
    
    p->pre->next = p->next;
    p->next->pre = p->pre;
    return p;
}

void FreePassenger(PassengerNode *p)
{
    
    
    free(p);
    return;
}

int GetNumberOfTicket(PassengerNode *p)
{
    
    
    return p->data.numberOfTicket;
}

#endif /*LINK_PASSENGER_H*/

Part2:   priorityqueue_airplane.h:

/*
 * @Description:  Big_homework1_AirReservationSys;
 * A header file of 2way_cycle_link，is for the AirPlane Priority Queue .
 * @Autor: G_Rampart
 * @Date: 2019-10-01 21:25:30
 * @LastEditTime: 2019-10-06 00:43:02
 */
#ifndef PRIORITYQUEUE_AIRPLANE_H
#define PRIORITYQUEUE_AIRPLANE_H
#define placeSize 50
#include <stdio.h>
#include "link_passenger.h"

struct airplane
{
    
    
    char id[idSize];
    char startPlace[placeSize];
    char ArrivalPlace[placeSize];
    int startTime[2];
    int arrivalTime[3];
    int maxNumberOfPassengers;
    int numberOfPassengers;
    PassengerNode *linkOfPassengers;
};
// 航班数据结构
typedef struct airplane Airplane;

struct priqueueNode
{
    
    
    Airplane data;
    int isHead;
    struct priqueueNode *pre;
    struct priqueueNode *next;
};
// 优先链式队列结点结构
typedef struct priqueueNode PriqueueNode;
char place[20][placeSize] = {
    
    "xxxx", "北京", "天津", "上海", "长春", "沈阳", "郑州", "长沙", "太原", "济南", "西安", "南京", "杭州", "福州", "广州", "合肥", "成都", "香港", "澳门", "台北"};

//初始化航班信息
Airplane InitAirplane();
// 修改航班（Airplane *）ap的已定票乘客数为（int）n.
Airplane *ChangeNumOfPassenger(Airplane *ap, int n);
// 在航班（Airplane *）ap中插入乘客结点（PassengerNode *）p.
void InsertPassenger2Air(PassengerNode *p, Airplane *ap);
// 比较航班（Airplane）a与航班（Airplane）b优先级，若a先于b返回1，否则返回0.
int CmpAirplane(Airplane a, Airplane b);
// 由航班总航行时间（int）t计算并修改航班（Airplane）a到达时间
void GetArrivalTime(Airplane *a, int t);
// 初始化航班队列结点（PriqueueNode *）p，信息为（Airplane）data.
void InitAirplaneQueue(PriqueueNode *pq, Airplane data);
// 判断航班队列（PriqueueNode *）pq是否为空，空返回1，否则返回0.
int isEmptyQueue(PriqueueNode *pq);
// 获取航班队列（PriqueueNode *）pq首位元素，返回航班（Airplane）ap.
Airplane TopQueue(PriqueueNode *pq);
// 删除航班队列（PriqueueNode *）pq首位元素.
void PopQueue(PriqueueNode *pq);
// 向航班队列（PriqueueNode *）pq中插入航班（Airplane）ap，成功插入返回0，否则返回-1.
int InsertAirplane2PriqueueNode(PriqueueNode *pq, Airplane ap);
/**
 * 在链表队列中（PriqueueNode *）pq 寻找航班号（char[]）为id的结点.
 * 成功后返回该结点指针，否则返回NNULL.
**/
PriqueueNode *FindAirplane(PriqueueNode *pq, char id[]);
// 展示航班结点（PriqueueNode *）pq的航班信息.
void ShowAirplane(PriqueueNode *pq);
// 展示优先队列（PriqueueNode *）pq中的所有航班信息.
void ShowAllAirplane(PriqueueNode *pq);
// 显示优先队列（PriqueueNode *）pq中到达地方（char[]）a的所有航班信息，返回航班信息个数.
int ShowAirplane2Place(PriqueueNode *pq, char place[]);
// 展示航班结点（PriqueueNode *）pq的乘客信息.
void ShowPassengers(PriqueueNode *pq);
// 展示证件号（char[]）id的乘客的所有订票信息，存在乘客返回1，否则返回0
int ShowPassengerInQueue(PriqueueNode *pq, char id[]);

Airplane InitAirplane()
{
    
    
    Airplane data;
    int sign;
    Airplane *datmp = (Airplane *)malloc(sizeof(Airplane));
    datmp = &data;
    data.startTime[0] = getRandom(0, 24);
    data.startTime[1] = getRandom(0, 60);
    int a1, a2;
    a1 = getRandom(0, 19);
    a2 = a1;
    while (a2 == a1)
        a1 = getRandom(0, 9);
    strcpy(data.startPlace, place[a1]);
    strcpy(data.ArrivalPlace, place[a2]);
    int time = getRandom(120, maxnTime);
    data.id[0] = getRandom(0, 25) + 'A';
    data.id[1] = getRandom(0, 25) + 'A';
    for (int i = 2; i < 6; ++i)
        data.id[i] = getRandom(0, 9) + '0';
    GetArrivalTime(datmp, time);
    data.maxNumberOfPassengers = getRandom(10, 20);
    data.numberOfPassengers = 0;
    PassengerNode *pasn = (PassengerNode *)malloc(sizeof(PassengerNode));
    pasn->isHeader = 1;
    pasn->pre = pasn->next = pasn;
    data.linkOfPassengers = pasn;
    return data;
}

Airplane *ChangeNumOfPassenger(Airplane *ap, int n)
{
    
    
    ap->numberOfPassengers = n;
    return ap;
}

void InsertPassenger2Air(PassengerNode *p, Airplane *ap)
{
    
    
    PassengerNode *pnode = (PassengerNode *)malloc(sizeof(PassengerNode));
    pnode = ap->linkOfPassengers->pre; // 航班乘客表表尾
    InsertPassenger2Link(pnode, p);
    return;
}

int CmpAirplane(Airplane a, Airplane b)
{
    
    
    if (a.startTime[0] != b.startTime[0])
    {
    
    
        if (a.startTime[0] < b.startTime[0])
            return 1;
        return 0;
    }
    else
    {
    
    
        if (a.startTime[1] < b.startTime[1])
            return 1;
        return 0;
    }
    return 0;
}

void GetArrivalTime(Airplane *a, int t)
{
    
    
    int tt[3];
    tt[0] = t / 60;
    tt[1] = t % 60;
    for (int i = 0; i < 2; ++i)
        a->arrivalTime[i] = a->startTime[i] + tt[i];
    a->arrivalTime[0] = a->arrivalTime[0] + a->arrivalTime[1] / 60;
    a->arrivalTime[2] = a->arrivalTime[0] / 24;
    a->arrivalTime[0] %= 24;
    a->arrivalTime[1] %= 60;

    return;
}

void InitAirplaneQueue(PriqueueNode *pq, Airplane data)
{
    
    
    pq->isHead = 0;
    pq->data = data;
    pq->pre = pq;
    pq->next = pq;
    return;
}

int isEmptyQueue(PriqueueNode *pq)
{
    
    
    if (pq->pre == pq->next)
        return 1;
    return 0;
}

Airplane TopQueue(PriqueueNode *pq)
{
    
    
    return pq->next->data;
}

void PopQueue(PriqueueNode *pq)
{
    
    
    PriqueueNode *temp;
    temp = pq->next;
    pq->next->next->pre = pq;
    pq->next = pq->next->next;
    free(temp);
    return;
}

int InsertAirplane2PriqueueNode(PriqueueNode *pq, Airplane ap)
{
    
    
    PriqueueNode *temp = (PriqueueNode *)malloc(sizeof(PriqueueNode));
    PriqueueNode *newap = (PriqueueNode *)malloc(sizeof(PriqueueNode));
    InitAirplaneQueue(newap, ap);
    temp = pq->next;
    if (temp->isHead)
    {
    
    
        newap->pre = temp;
        newap->next = temp->next;
        temp->next->pre = newap;
        temp->next = newap;
        return 0;
    }
    while (!temp->isHead)
    {
    
    
        int sign = CmpAirplane(newap->data, temp->data);
        if (sign)
        {
    
    
            temp->pre->next = newap;
            newap->pre = temp->pre;
            newap->next = temp;
            temp->pre = newap;
            return 0;
        }
        temp = temp->next;
    }
    temp->pre->next = newap;
    newap->pre = temp->pre;
    newap->next = temp;
    temp->pre = newap;
    return 0;
}

PriqueueNode *FindAirplane(PriqueueNode *pq, char id[])
{
    
    
    PriqueueNode *temp = (PriqueueNode *)malloc(sizeof(PriqueueNode));
    temp = pq;
    int sign = 1;
    while (temp != pq || sign == 1)
    {
    
    
        sign = 0;
        if (temp->isHead)
        {
    
    
            temp = temp->next;
            continue;
        }
        if (strcmp(temp->data.id, id) == 0)
            return temp;
        temp = temp->next;
    }
    return NULL;
}

void ShowAirplane(PriqueueNode *pq)
{
    
    
    Airplane data = pq->data;
    printf(" %s    %02d:%02d  ", data.id, data.startTime[0], data.startTime[1]);
    if (data.arrivalTime[2])
    {
    
    
        printf("   次日");
        printf("  %02d:%02d\t", data.arrivalTime[0], data.arrivalTime[1]);
    }
    else
    {
    
    
        printf("\t");
        printf("%02d:%02d\t\t", data.arrivalTime[0], data.arrivalTime[1]);
    }
    printf("%s       %s         ", data.startPlace, data.ArrivalPlace);
    printf("%02d\t   %02d\n", data.maxNumberOfPassengers, data.numberOfPassengers);
}

void ShowAllAirplane(PriqueueNode *pq)
{
    
    
    printf("航班序号  起飞时间     到达时间       起飞地点   到达地点    核载人数    订票人数\n");
    PriqueueNode *temp = (PriqueueNode *)malloc(sizeof(PriqueueNode));
    temp = pq;
    int cnt = 1;
    int sign = 0;
    while (temp != pq || sign == 0)
    {
    
    
        sign = 1;
        if (temp->isHead)
        {
    
    
            temp = temp->next;
            continue;
        }
        ShowAirplane(temp);
        temp = temp->next;
    }
    return;
}

int ShowAirplane2Place(PriqueueNode *pq, char p[50])
{
    
    
    printf("到达%s的航班有:\n", p);
    PriqueueNode *temp = (PriqueueNode *)malloc(sizeof(PriqueueNode));
    temp = pq;
    int cnt = 0;
    int sign = 0;
    while (temp != pq || sign == 0)
    {
    
    
        sign = 1;
        if (temp->isHead)
        {
    
    
            temp = temp->next;
            continue;
        }
        if (strcmp(temp->data.ArrivalPlace, p) == 0)
        {
    
    
            cnt++;
            ShowAirplane(temp);
        }
        temp = temp->next;
    }
    return cnt;
}

void ShowPassengers(PriqueueNode *pq)
{
    
    
    Airplane data = pq->data;
    PassengerNode *temp = (PassengerNode *)malloc(sizeof(PassengerNode));
    int sign = 0;
    temp = data.linkOfPassengers;
    while (sign == 0 || temp != data.linkOfPassengers)
    {
    
    
        sign++;
        Passenger pastemp = temp->data;
        printf("%s 购票数量:%d\n", pastemp.name, pastemp.numberOfTicket);
    }
    return;
}

int ShowPassengerInQueue(PriqueueNode *pq, char id[])
{
    
    
    PriqueueNode *temp = (PriqueueNode *)malloc(sizeof(PriqueueNode));
    temp = pq->next;
    int cnt = 0;
    printf("%s:", id);
    while (!temp->isHead)
    {
    
    
        PassengerNode *pan = (PassengerNode *)malloc(sizeof(PassengerNode));
        pan = FindPassenger(temp->data.linkOfPassengers, id);
        if (pan == NULL)
        {
    
    
            temp = temp->next;
            continue;
        }
        if (cnt)
            printf(" ");
        printf("航班%s   购票数量：%d\n", temp->data.id, pan->data.numberOfTicket);
        cnt++;
        temp = temp->next;
    }
    if (cnt == 0)
        printf("\t不存在购票信息\n");
    return cnt;
}

#endif /* PRIORITYQUEUE_AIRPLANE_H */

Part3:   airplane_reservation_sys.h:

/*
 * @Description:  Big_homework1_AirReservationSys;
 * A header file of some operations, is for Booking and GetingRefund Tickets.
 * @Autor: G_Rampart
 * @Date: 2019-10-01 21:25:53
 * @LastEditTime: 2019-10-05 23:55:40
 */
#ifndef AIRPLANE_RESERVATION_SYS_H
#define AIRPLANE_RESERVATION_SYS_H
#include "link_passenger.h"
#include "priorityqueue_airplane.h"

// 随机建立航班信息，并创建一个优先队列.
PriqueueNode *GetAirplane();
// 乘客订票，在航班队列（PriqueueNode *）pq中订票，若成功返回1，否则返回0.
int BookTickets(PriqueueNode *pq);
// 乘客退票，在航班队列（PriqueueNode *）pq中退票，若成功返回1，否则返回0.
int GetRefund(PriqueueNode *pq);

PriqueueNode *GetAirplane()
{
    
    
    printf("请输入航班数量  ");
    int n;
    scanf("%d", &n);
    printf("\n");
    PriqueueNode *header = (PriqueueNode *)malloc(sizeof(PriqueueNode));
    Airplane temp;
    header->data = temp;
    header->isHead = n;
    header->next = header->pre = header;
    while (n--)
    {
    
    
        Airplane data = InitAirplane();
        int sign = InsertAirplane2PriqueueNode(header, data);
    }
    printf("本日航班信息如下:\n");
    ShowAllAirplane(header);
    return header;
}

int BookTickets(PriqueueNode *pq)
{
    
    
    char n1[idSize];
    Passenger pa;
    printf("正在进入订票系统......\n");
    printf("请输入您的名字:  ");
    scanf("%s", pa.name);
    printf("请输入您的证件号: ");
    scanf("%s", pa.id);
    printf("获取本日航班信息中......\n显示全部航班信息请按1，按到达地显示航班信息请按2:  ");
    int op1;
    scanf("%d", &op1);
    if (op1 == 1)
        ShowAllAirplane(pq);
    else if (op1 == 2)
    {
    
    
        char pla[placeSize];
        int sign;
        printf("请输入到达地名称： ");
        scanf("%s", pla);
        sign = ShowAirplane2Place(pq, pla);
        if (!sign)
        {
    
    
            printf("暂无到达%s的航班\n", pla);
            return 0;
        }
    }
    else
    {
    
    
        printf("输入非法操作符......\n");
        return 0;
    }
    printf("请输入您所订票的航班号：  ");
    scanf("%s", &n1);
    PriqueueNode *temp = (PriqueueNode *)malloc(sizeof(PriqueueNode));
    temp = FindAirplane(pq, n1);
    if (temp == NULL)
    {
    
    
        printf("抱歉，您所输入的航班号不存在\n");
        return 0;
    }
    printf("请输入您的订票数量:  ");
    scanf("%d", &pa.numberOfTicket);
    Airplane *aptr = (Airplane *)malloc(sizeof(Airplane));
    aptr = &(temp->data);

    if (temp->data.maxNumberOfPassengers == temp->data.numberOfPassengers)
    {
    
    
        printf("抱歉，该航班机票已售罄\n");
        return 0;
    }
    else if (temp->data.maxNumberOfPassengers < temp->data.numberOfPassengers + pa.numberOfTicket)
    {
    
    
        printf("抱歉，该航班余票不足%d张\n", pa.numberOfTicket);
        return 0;
    }

    temp->data.numberOfPassengers += pa.numberOfTicket;
    PassengerNode *pn = (PassengerNode *)malloc(sizeof(PassengerNode));
    if (FindPassenger(temp->data.linkOfPassengers, pa.name) != NULL)
    {
    
    
        pn = FindPassenger(temp->data.linkOfPassengers, pa.name);
        pn->data.numberOfTicket += pa.numberOfTicket;
        return 1;
    }
    InitPassengerNode(pn, pa);
    InsertPassenger2Air(pn, aptr);
    return 1;
}

int GetRefund(PriqueueNode *pq)
{
    
    
    char n1[idSize];
    int op1;
    Passenger pa;
    printf("正在进入退票系统......\n");
    printf("请输入您的证件号:  ");
    scanf("%s", pa.id);
    printf("获取本日航班信息中......\n按乘客信息查询退票请按1，按航班号查询退票请按2  ");
    scanf("%d", &op1);
    if (op1 == 2)
        ShowAllAirplane(pq);
    else if (op1 == 1)
    {
    
    
        int signs;
        signs = ShowPassengerInQueue(pq, pa.id);
        if (signs == 0)
            return 0;
    }
    else
    {
    
    
        printf("输入非法操作符......\n");
        return 0;
    }
    printf("请输入您所退票的航班号：  ");
    scanf("%s", &n1);
    PriqueueNode *temp = (PriqueueNode *)malloc(sizeof(PriqueueNode));
    temp = FindAirplane(pq, n1);
    if (temp == NULL)
    {
    
    
        printf("抱歉，您所输入的航班号不存在\n");
        return 0;
    }
    PassengerNode *pn = (PassengerNode *)malloc(sizeof(PassengerNode));
    pn = temp->data.linkOfPassengers;
    pn = FindPassenger(pn, pa.id);
    if (pn == NULL)
    {
    
    
        printf("抱歉，您在本航班上未订票\n");
        return 0;
    }
    printf("您共计在本航班上订票%d张.\n", pn->data.numberOfTicket);
    printf("请输入您所需退票数量：  ");
    int nn;
    scanf("%d", &nn);
    if (nn > pn->data.numberOfTicket)
    {
    
    
        printf("抱歉，您订票数量少于%d张.", nn);
        return 0;
    }
    temp->data.numberOfPassengers -= nn;
    pn->data.numberOfTicket -= nn;
    if (pn->data.numberOfTicket == 0)
    {
    
    
        pn = DeletePassenger(pn);
        FreePassenger(pn);
    }
    return 1;
}

#endif /*AIRPLANE_RESERVATION_SYS_H*/

Part4:   AirReservationSys.c:

/*
 * @Description:  Big_homework1_AirReservationSys;
 * A source file that runs the relevant operations.
 * @Autor: G_Rampart
 * @Date: 2019-09-30 09:43:28
 * @LastEditTime: 2019-10-06 00:19:15
 */
#include "airplane_reservation_sys.h"

int main()
{
    
    
    srand((unsigned)time(NULL));
    printf("欢迎使用XXXX飞机服务系统\n");
    PriqueueNode *AirplaneQueue = (PriqueueNode *)malloc(sizeof(PriqueueNode));
    AirplaneQueue = GetAirplane();
    while (1)
    {
    
    
        
        printf("订票请输入1，退票请输入2，查询信息请按3，退出请输入0:  ");
        int op;
        scanf("%d", &op);
        if (op == 0)
            break;
        else if (op == 1)
        {
    
    
            int sign = 0;
            sign = BookTickets(AirplaneQueue);
            while (sign == 0)
            {
    
    
                printf("订票失败...\n继续订票请按1，退出订票请按0:  ");
                int q;
                scanf("%d", &q);
                if (q == 0)
                    break;
                else if (q == 1)
                    sign = BookTickets(AirplaneQueue);
                else
                {
    
    
                    printf("输入非法操作符......\n");
                    break;
                }
            }
            if (sign)
                printf("订票成功\n");
        }
        else if (op == 2)
        {
    
    
            int sign = 0;
            sign = GetRefund(AirplaneQueue);
            while (sign == 0)
            {
    
    
                printf("退票失败...\n继续退票请按1，退出退票请按0\n");
                int q;
                scanf("%d", &q);
                if (q == 0)
                    break;
                else if (q == 1)
                    sign = GetRefund(AirplaneQueue);
                else
                {
    
    
                    printf("输入非法操作符......\n");
                    break;
                }
            }
            if (sign)
                printf("退票成功\n");
        }
        else if (op == 3)
        {
    
    
            
            ShowAllAirplane(AirplaneQueue);
        }
        else
        {
    
    
            printf("输入非法操作符......\n");
            continue;
        }
    }
    printf("欢迎您下次使用XXXX飞机服务系统");
    return 0;
}