停车场进出库系统（链表和队列）链表要按照VIP等级从大到小（简易版）

限定10辆车同时进入（链表）
{
车牌
车型
颜色
VIP等级（随机值，，，是否重复的问题）
}
【1】{调用一次函数可以给十个链表节点赋值，但链表的长度不一定就十个，再进需要在调用一次进入函数，接着原来额的后面，知道满，或者车不够}；创建一个足够长的表（定死了），进车就是修改哪些没有数据的节点的数据，（十层，每层可以停十辆车）
【2】根据VIP等级进行先后排序后进场（结构体里面可以定义一个等级）（两种排序算法）；
【3】出场次序要求先进先出（队列实现，在创建一个队列用来按先后输入顺序排，可以一开始就创建）；数据同步的问题；
【4】要求车在停车场期间，有查询车辆信息的功能（进入时间 VIP等级 车位号）；
【5】要求可以直接令一辆车消失（链表以及对应的队列数据清除）；

/*****************************************************
copyright (C), 2014-2015, Jinling Institute of Tecnology
File name：2.c
Author: Zhang.Y.F  Version:0.1    Date: 2018-01-16 20:25
Description：
Funcion List: 
*****************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
typedef struct
{
 char name[10];
 int vip;
 int xh; //车的入场序号
}Car;

Car cars[10];//用于存放暂时的是车辆，后面用于排序
typedef struct
{
 Car car[100];//100个车为，数组中的元素不用排序直接放入队列中
 int front;//对头
 int rear;
}GD;

typedef struct Node//定义一个结构体用来存放车辆信息，车牌号，进入时间等
{
 Car car;
 int flag;//用来辨别当前节点内有没有车
 int num;
 struct Node *next;
 
}Node,*LinkList;

void Create(LinkList L)//创建一个有100个元素的链表，长度限定了，后面也不再改变(传的是二极指针)
{
 char name[10]={'\0'};
 LinkList p,s;
 int i=0;
 p=L->next=(LinkList)malloc(sizeof(Node));//给第一个节点初始化
 p->flag=0;int j=0;
 strcpy(p->car.name,name);
 p->car.xh=0;
 p->car.vip=0;
 p->num=1;
 i=1;
 while(i<=100)
 {
  s=(LinkList)malloc(sizeof(Node));//给接下来的99个节点初始化
  strcpy(L->car.name,name);//对车的操作
  s->car.xh=0;
  s->car.vip=0;
  s->flag=0;//用来辨别当前节点内有没有车
  (s->num)++;
  s->next=p->next;//尾插
  p->next=s;
  p=s;
  i++;//地I个节点
 }
}


void IntCar(Car cars[],int ci)//先把所有车的信息输入数组当中，然后数组中的元素挨个拷贝到队列中去
{
 int i;//第i层
 for(i=0;i<10;i++)
 {
  printf("请输入车牌号\n");
  scanf("%s",cars[i].name);//车牌号
  cars[i].vip=rand()%(10-1)+1;//随机的VIP等级0-9
  cars[i].xh=ci*10+i+1;
 }
 return;
}
void copy(Car *A,Car *B)//将B车的信息完全复制给A车；址传递
{
 strcpy(A->name,B->name);
 A->vip=B->vip;
 A->xh=B->xh;
 return;
}
void EnQueue(GD *Q,Car C[])//队列上面已经创建好，用来自然顺序存放进来的车
{
 if((Q->rear+1)%100==Q->front)
 {
  printf("停车场已满\n");
  return;
 }
 
 else{
 int j=0;
 while(j<10)//从当前的队尾依次存放测车辆的信息
 {
  copy(&(Q->car[Q->rear]),&(C[j]));
  Q->rear=(Q->rear+1)%100;//尾指针指向下一个
  j++;
 }
 }
 return;
}
void swap(Car *A,Car *B)//交换A，B车的内容
{
 Car* temp=(Car *)malloc(sizeof(Car));//中间变量
 copy(temp,A);
 copy(A,B);
 copy(B,temp);
 return;
}
void BubbleSort(Car C[],int n/*数组长度*/)//冒泡排序，大的在前
{
 int i,j,flag;
 flag=1;
 for(i=0;i<n-1&&flag;i++)
 {
  flag=0;//标志着是否排过序了
  for(j=n-2;j>=i;j--)//先把所有车的信息输入数组当中，然后数组中的元素挨个拷贝到队列中去
  {
   if(C[j].vip<C[j+1].vip)
    {
     swap(&(C[j]),&(C[j+1]));
     flag=1;
    }
  }
 }
}
void SelectSort(Car C[],int n)//选择排序，派出vip等级大小排序
{
 int i,j,max;
 for(i=0;i<n-1;i++)
 {
  max=i;
  for(j=i+1;j<=n-1;j++)//找出i到n-1中最大元素所在位置
  {
   if(C[max].vip<C[j].vip)
    max=j;
  }
  if(i!=max)//如果i不是最大元素所在位置，则将他们的值交换
   swap(&C[i],&C[max]);
 }
}

void ruku(LinkList L,Car C[])//将已排序的数组按照顺序一个个的复制内容到链表中去
{
 LinkList p;
 p=L->next;
 int i=0;
 while(p->flag!=0&&p!=NULL)//遍历到第一个空车位，或者车库满
 {
  p=p->next;
 }//思考一个问题，后来有车出库了，可是他还是要10个一起进来
 if(p==NULL)
 {
  printf("车库满了\n");
  return;
 }
 while(p&&p->flag==0&&p->num%10!=1)//遍历到10的整数倍后一个
 {
  p=p->next;
 }
 if(p==NULL)
 {
  printf("车库满了\n");
  return;
 }
 if(p&&p->flag==0&&p->num%10==1)//用来从10的整数倍后一个开始
 {
   while(i<10&&p!=NULL)
   {
    copy(&(p->car),&(C[i]));
    p->flag=1;
    p=p->next;
    i++;
   
   }
   if(p==NULL)
   {
    printf("车库满了\n");
    return;
   }
  }
 return;         
}
int Length(LinkList L)//求总长度
{
 LinkList p=L->next;
 int count=0;
 while(p)
 {
  if(p->flag!=0)
   count++;
  p=p->next;
 }
 return count;
}

int Lengthi(LinkList L,int i)//求每一层长度
{
 LinkList p=L->next;
 int count=0;
 int n=0;
 int m=0;
 for(m=0;m<10*(i-1);m++)
  p=p->next;
 while(n<10&&p)
 {
  if(p->flag!=0)
   count++;
  p=p->next;
 }
 return count;
}
void PrintC(Car *C)
{
 printf("车牌号%s\n",C->name);
 printf("车的vip等级%d\n",C->vip);
}
//再谢一个查询车来嗯信息的函数
Car* Res(LinkList L,char name[])
{
 LinkList p=L->next;
 Car *C=(Car *)malloc(sizeof(Car));
 while(p&&strcmp(p->car.name,name))
  p=p->next;
 if(p==NULL)
 {
  printf("车库中没有这辆车\n");
  return;
 }
 if(strcmp(p->car.name,name)==0)
 {
  printf("找到了\n");
   //printf("调试专用112\n");
  copy(C,&(p->car));//这里的car是一个车的结构体
  /*strcpy(C->name,name);
  printf("调试专用112\n");
  C->vip=p->car.vip;
  C->xh=p->car.xh;*/



  printf("调试专用112\n");
 }
 return C;
}

PrintList(LinkList L)//打印出当前车库中所有车的信息
{
 printf("目前车库中共有%d辆车\n",Length(L));
 LinkList p=L->next;
 int i=1;
 
 printf("车库共有%d辆车\n",Length(L));
 while(i<10)
 {
  int j=0;
  printf("第%d层车库共有%d辆车\n",i,Lengthi(L,i));
  while(j<10&&p&&Lengthi(L,i))
  {
   if(p->flag)
   {
    printf("%c车位有车,车辆信息如下\n",'A'+j);
    printf("车牌号%s\n",p->car.name);
    printf("车的VIP等级%d\n",p->car.vip);
   }
   else
    printf("%c车位无车\n",'A'+j);
   p=p->next;
   j++;
  }
  i++;
 }
}
//初始化一个车
void DeC(Car *C)
{
 strcpy(C->name,"\0");
 C->vip=0;
 C->xh=0;
 printf("初始化成功\n");
 return;
}
Car* chuku(GD *Q)//从对队列头出库一辆车，返回车辆的信息，用于后面的链表中削去相同的车
{
 Car *C=(Car *)malloc(sizeof(Car));
 copy(C,&(Q->car[Q->front]));
 printf("车辆出库\n");
 printf("出库车辆信息如下\n");
 printf("车牌号%s\n",Q->car[Q->front].name);
 printf("车的VIP等级%d\n",Q->car[Q->front].vip);
 DeC(&(Q->car[Q->front]));
 Q->front=(Q->front+1)%100;
 return C;
}
//些一个函数用来取出队列中的元素、
void DeD(GD *Q,Car *C)
{
 int i=Q->front;
 while((i+1)%100!=Q->rear)
 {
  if(strcmp(Q->car[i].name,C->name)==0)
  {
   DeC(Q->car);
   printf("队列中同样删除成功\n");
   break;
  }
  i++;
 }
 return;
}
void DeL(LinkList L,Car *C/*用来确定车的名字*/)//从链表中删除一辆车
{
 LinkList p=L->next;
 while(p&&strcmp(p->car.name,C->name))
 {
  p=p->next;PrintList(L);
 }
 if(strcmp(p->car.name,C->name)==0)
 {
  DeC(&(p->car));
  p->flag=0;
  printf("删除成功\n");
 }
}
int main(int argc, char **argv)
{
 LinkList L;
 Create(L);
 int a;
 GD Q;
 Q.rear=Q.front=0;
 printf("*******************************欢迎来到停车场**********************************\n");
 printf("*******************************请输入你要干的事情*****************************\n");
 printf("输入1：停车  输入2：找车 输入3： 出库 输入4：删除车 输入5:打印所有 输入6：退出系统\n");
 int ci=1;
 char name[10];
 Car *C;
 while(1)
 {
  printf("调试专用\n");
  scanf("%d",&a);
  getchar();
  switch(a)
  {
   //printf("调试专用\n");
   case 1: {
      IntCar(cars,ci);//先安顺序给数组赋值
      ci++;
      EnQueue(&Q,cars);//数组的元素原封不动的赋给队列
      BubbleSort(cars,10);//按照vip值排序
      ruku(L,cars);//排完序的数组元素赋给链表
      break;
     }
   case 2:{
      printf("请输入你想要查找的车的车牌号\n");
      scanf("%s",name);
      C=Res(L,name);
      PrintC(C); //找出那两车并打印出车辆的信息   
      break;
     }
   case 3:{
      //Car *C;
      C=chuku(&Q);//从对头出库一辆车
      DeL(L,C);//删去链表中对应的车
      printf("出库成功\n");
      break;
     }
   case 4:{
      printf("请输入你想要删除的车的车牌号\n");
      scanf("%s",name);
      C=Res(L,name);
      DeL(L,C);
      DeD(&Q,C);
      break;
     }
   case 5:PrintList(L);break;
   case 6:exit(1);break;
  }
 }
    return 0;
}