床位分配

题目:某客店有N个等级的房间,第k级客房有A(k)个,每个房间有B(k)个单人床,以菜单调用方式设计为单身旅客分配床位以及离店时收回床位的程序。要求分配成功时,印出旅客姓名、年龄、性别、到达日期、客房等级、房间号及床位号;分配不成功时,允许更改房间等级,若不更改等级,印出“满客”提示。

首先建立是三个结构体分别来表示等级,客房,床位的信息。

struct series //等级情况
{
    struct home_count *h;  //房间数组,该等级下有多少房间
    int room_num;          //该等级下房间的个数;
};

struct home_count    //房间情况
{
    int sex;           //入住的性别
    int count;          //房间床位个数
    int surplus;       //剩余床位个数
    int num;             //房间号
    struct bed *head;    //该床位的旅客信息
};

struct bed            //床位情况
{
    int number;        //床位号
    char name[20];     //客人姓名
    int age;          //客人年龄
    int sex;          //客人性别
    int year;
    int month;
    int date;         //客人入住时间
};

然后建立一个等级的指针,并初始化,初始化时,使用三个全局变量n,b,a分别代表等级的个数,房间的个数,床位的个数,进行动态分配,并把房间的入住性别初始为待定,床位号为0表示没有人住。建立四个函数,分别代表着四个功能,一是订房,二是退房,三是查询,四是退出。在订房这个函数里实现房间预订的功能,在这个函数里,先判断旅店人数是否已满,再输入旅客房间的等级,判断旅客的输入的等级是否合法,是的话接着让旅客输入个人的基本信息,通过旅客的性别判断该等级下是否还有空余床位,如果有

给旅客分配房间,并分配床号,房间的剩余人数减一,房间的入住性别为旅客的性别。然后打印旅客的信息并显示订房成功。在退房的函数里,先输入房间号,判断这个房间号是否存在,接着输入旅客的姓名,在这个房间查找是否有这个人,如果有打印旅客的信息及退房日期并显示退房成功、还要把这个房间的剩余床位加一,如果这时候剩余床位和该房间的总床位相等,则把这个房间的入住改为未定。在查询这个函数里,打印每个等级下剩余男、女床位,由于有的房间入住性别是未定的,所以显示时为最多男女剩余床位。退出函数,直接退出就可以了。这里床位为什么没有使用链表来表示,因为不好对其床位号进行操作,而使用数组可以对床位号操作比较容易,可以直接通过下标来实现。

完整代码如下:

#include <stdio.h>
#include <stdlib.h>
#include<time.h>

struct series //等级情况
{
    struct home_count *h;  //房间数组,该等级下有多少房间
    int room_num;          //该等级下房间的个数;
};

struct home_count    //房间情况
{
    int sex;           //入住的性别
    int count;          //房间床位个数
    int surplus;       //剩余床位个数
    int num;             //房间号
    struct bed *head;    //该床位的旅客信息
};

struct bed            //床位情况
{
    int number;        //床位号
    char name[20];
    int age;
    int sex;
    int year;
    int month;
    int date;
};

int n=2,a=2,b=1;

struct series* ini(struct series *head);   //初始化菜单
void main_menu();
struct series* dingfang(struct series *head);  //订房
struct series* tuifang(struct series *head);   //退房
void chaxun(struct series *head);
struct beg* td(struct bed*head,char n[20],int *flag);
int equal(char *s1,char *s2);          //字符串相等判断
void quit();
int empty(struct series head);            //判断该等级下床位是否已满
int Empty(struct series *head);           //判断整个旅店的房间是否已满
int getnum1(struct series head,int x);          //该等级下男生剩余床位 ,该等级下女生剩余床位
int getnum2(struct series *head,int x);             //旅店所剩下男的床位或者女生床位;

int main()
{
    struct series *head;

    int choice=1;
    head=ini(head);
    while(1)
    {
         main_menu();
         printf("请输入:");
         scanf("%d",&choice);
         while(choice!=1&&choice!=2&&choice!=3&&choice!=4)
         {
             printf("请输入1~4:");
             scanf("%d",&choice);
         }
         switch(choice)
         {
             case 1:head=dingfang(head);break;
             case 2:head=tuifang(head);break;
             case 3:chaxun(head);break;
             case 4:quit();break;
         }
    }
    return 0;
}

struct series *ini(struct series *head)
{
    printf("    系统初始化\n");
    printf("1.默认初始化  2.自定义初始化\n");
    printf("请输入您的选择:");
    int c,i,j,k;
    scanf("%d",&c);
    if(c==1)    //默认初始化
    {
          head=(struct series *)malloc(sizeof(struct series)*n);     //分配n个等级
          for(i=0;i<n;++i)
          {
              head[i].room_num=a;
              head[i].h=(struct home_count *)malloc(sizeof(struct home_count)*a);   //分配a个房间
              for(k=0;k<a;k++)  //对每个房间情况进行初始化
              {
                  head[i].h[k].count=head[i].h[k].surplus=b;
                  head[i].h[k].sex=3;                    //待定
                  head[i].h[k].num=(i+1)*100+k;
                  head[i].h[k].head=(struct bed*)malloc(sizeof(struct bed)*b);
                  for(j=0;j<b;j++)
                  {
                      head[i].h[k].head[j].number=0;
                  }
              }
          }
    }
    else     //自定义初始化
    {

        printf("请输入等级个数:");
        scanf("%d",&n);
        head=(struct series *)malloc(sizeof(struct series)*n); //分配n个等级
        for(i=0;i<n;i++)
        {
              printf("请输入等级%d房间的个数:",i+1);
              scanf("%d",&a);
              head[i].room_num=a;
              head[i].h=(struct home_count *)malloc(sizeof(struct home_count)*a);   //分配a个房间
              printf("请输入等级%d下房间的床位的个数:",i+1);
              scanf("%d",&b);
              for(k=0;k<a;k++)
              {
                  head[i].h[k].count=head[i].h[k].surplus=b;
                  head[i].h[k].sex=3;
                  head[i].h[k].num=(i+1)*100+k;
                  head[i].h[k].head=(struct bed*)malloc(sizeof(struct bed)*b);
                  for(j=0;j<b;j++)
                  {
                      head[i].h[k].head[j].number=0;
                  }
              }
        }
    }
    printf("初始化结束!!!\n");
    getchar();
    printf("\n按Enter键继续!");
    getchar();
    return head;
}
void main_menu()
{
    printf("*****************************\n");
    printf("*  1:订房         2:退房    *\n");
    printf("*  3:查询         4:退出    *\n");
    printf("*****************************\n");
}

struct series* dingfang(struct series *head)
{
    int n1;
    if(!Empty(head))   //判断人数是否已满
    {
        printf("对不起,旅店暂时无空床位!\n");
        printf("按Enter键继续\n");
        getchar();
        return head;
    }
    struct bed *p1;
    p1=(struct bed *)malloc(sizeof(struct bed));
    printf("请输入您要订的房间等级(1~%d):",n);
  s:scanf("%d",&n1);
    while(n1<1||n1>n)
    {
        printf("对不起,无该等级房间,请重新输入(1~%d):",n);
        scanf("%d",&n1);
    }
    if(!empty(head[n1-1]))
    {
        printf("抱歉,该等级房间人数已满!\n");
        printf("是否更改房间等级(1.更改  2.不更改),请输入:");
        int x;
        scanf("%d",&x);
        if(x==1)
            {
                printf("请重新输入等级:");
                goto s;

            }
        else
        {
            printf("满客\n");
            return head;
        }
    }
    printf("请输入您的姓名:");
    scanf("%s",p1->name);
    printf("请输入您的年龄:");
    scanf("%d",&p1->age);
    printf("请输入您的性别(男:请输入1 女:请输入2):");
    scanf("%d",&p1->sex);
    printf("请输入到达日期:");
    scanf("%d%d%d",&p1->year,&p1->month,&p1->date);
    if(!getnum2(head,p1->sex))
    {
        if(p1->sex==1)
             printf("对不起,旅店暂时无男士床位!\n");
        else
            printf("对不起,旅店暂时无女士床位!\n");
        printf("按Enter键继续\n");
        getchar();
        return head;
    }
    while(!getnum1(head[n1-1],p1->sex))
      {
          printf("抱歉,该等级房间人数已满!\n");
          printf("是否更改房间等级(1.更改  2.不更改),请输入:");
          int x;
          scanf("%d",&x);
          if(x==1)
            {
                printf("请重新输入等级:");
            s1: scanf("%d",&n1);
                while(n1<1||n1>n)
               {
                      printf("对不起,无该等级房间,请重新输入(1~%d):",n);
                      scanf("%d",&n1);
               }
               if(!empty(head[n1-1]))
               {
                   printf("抱歉,该等级房间人数已满!\n");
                   printf("是否更改房间等级(1.更改  2.不更改),请输入:");
                   int x;
                   scanf("%d",&x);
                   if(x==1)
                   {
                        printf("请重新输入等级:");
                    goto s1;

                    }
                    else
                   {
                     printf("满客\n");
                     return head;
                   }
                }

            }
        else
            {
                printf("满客\n");
                return head;
            }
      }
    int flag=0;                                    //标志
    int i,j;
    for(i=0;i<head[n1-1].room_num;i++)   //从第一个房间开始搜索
    {
        for(j=0;j<head[n1-1].h[i].count;j++)
        if(head[n1-1].h[i].surplus!=0&&(head[n1-1].h[i].sex==3||head[n1-1].h[i].sex==p1->sex)&&head[n1-1].h[i].head[j].number==0)
        {
                flag=1;
                break;
        }
        if(flag==1)
            break;

    }
    struct bed *p=head[n1-1].h[i].head;
    if(flag==1)
    {
        p1->number=j+1;
        head[n1-1].h[i].head[j]=*p1;
        printf("订房成功\n");
        printf("姓名:%s\t",p1->name);
        printf("年龄:%d\t",p1->age);
        printf("性别:");
        if(p1->sex==1)
           printf("男\t");
        else
           printf("女\t");
        printf("入住时间:%d-%d-%d\n",p1->year,p1->month,p1->date);
        printf("客房等级:%d\t房间号:%d\t床位号:%d\n",n1,n1*100+i,p1->number);
        head[n1-1].h[i].sex=p1->sex;
        head[n1-1].h[i].surplus-=1;

    }
    printf("\n按Enter键继续!\n");

    getchar();
    return head;
}

struct series* tuifang(struct series *head)   //退房
{
    int n1,n2,k;
    char name1[20];
    printf("请输入您要退订的房间号:");
   s:scanf("%d",&n1);
    k=n1%100;
    n2=(n1-k)/100-1;
    if(n2<0||n2>n-1)
    {
        printf("您输入的房间号有误,请重新输入:");
        goto s;
    }
    if(head[n2].room_num-1<k)
    {
        printf("您输入的房间号有误,请重新输入:");
        goto s;
    }
    printf("请输入您的姓名:");
    scanf("%s",name1);
    int i,flag=0;
    for(i=0;i<head[n2].h[k].count;i++)
    {
        if(head[n2].h[k].head[i].number!=0&&equal(head[n2].h[k].head[i].name,name1))
        {
            flag=1;
            break;
        }
    }
   if(flag==1)
    {
            printf("姓名:%s 性别",head[n2].h[k].head[i].name);
            head[n2].h[k].head[i].number=0;
            head[n2].h[k].surplus+=1;
            if(head[n2].h[k].head[i].sex==1)
                printf("男\t");
            else
                printf("女\t");
             time_t t;
             t=time(NULL);
            char *time;
            time=ctime(&t);
            printf("退房日期:%s\n",time);
            printf("退房成功\n");
            if(head[n2].h[k].surplus==head[n2].h[k].count)
            {
                head[n2].h[k].sex=3;
            }

    }
    else
    {
        printf("对不起,此房间没有您的入住信息!\n");
    }
    printf("按Enter键继续!\n");
    getchar();
    return head;
}

int equal(char *s1,char *s2)         //客人姓名的对照
{
    int l1,l2,i,j;
    l1=strlen(s1);
    l2=strlen(s2);
    if(l1==l2)
    {
        for(i=0,j=0;i<l1;i++,j++)
        {
            if(s1[i]!=s2[j])
                return 0;
        }
        return 1;
    }
    return 0;
}

int empty(struct series head)    //判断该等级下床位是否已满
{
    int i;
    for(i=0;i<head.room_num;i++)
    {
        if(head.h[i].surplus!=0)
            return 1;
    }
    return 0;
}

int Empty(struct series *head) //判断整个旅店的床位是否已满
{
    int i;
    for(i=0;i<n;i++)
    {
        if(empty(head[i]))
            return 1;
    }
    return 0;
}
int getnum1(struct series head,int x)          //该等级下男生剩余床位
{
    int num=0;
    int i,j;
    if(x==1)
    {
        for(i=0;i<head.room_num;i++)
       {
        if(head.h[i].sex==3||head.h[i].sex==1)
             num+=head.h[i].surplus;
       }
    }
    else
    {
        for(i=0;i<head.room_num;i++)
       {
        if(head.h[i].sex==3||head.h[i].sex==2)
             num+=head.h[i].surplus;
       }
    }
    return num;
}

int getnum2(struct series *head,int x)        //该旅店一共剩下男生或者女生剩余床位
{

    int num=0;
    int i,j;
    for(i=0;i<n;i++)
    {
             num+=getnum1(head[i],x);
    }
    return num;
}

void chaxun(struct series *head)
{
    int i,j;
    for(i=0;i<n;i++)
    {
        printf("等级%d,最多剩余%d个男床位,最多剩余%d个女床位\n",i+1,getnum1(head[i],1),getnum1(head[i],2));
    }
}
void quit()
{
    printf("谢谢您的使用,再见!");
    exit(1);
}
时间: 2024-10-11 01:40:54

床位分配的相关文章

【c/c++】内存分配大小

测试平台:linux 32位系统 用sizeof()运算符计算分配空间大小.单位:字节 1. 数组名与变量名的区别 int main() { char q[] = "hello"; cout << "q:" << sizeof(q) << endl; char *mq = q; cout << "mq:" << sizeof(mq) << endl; const char *

操作系统: 最佳适配算法和邻近适配算法的模拟实现(内存分配算法)

实现动态分区的分配算法. (1) 最佳适配算法:选择内存空闲块中最适合进程大小的块分配. (2) 邻近适配算法:从上一次分配的地址开始查找符合要求的块,所查找到的第一个满足要求的空闲块就分配给进程. 模拟添加进程的时候,假定内存是一块完整的空闲区,对于算法(1)来说,分配的时候遍历所有的空闲内存块,找出其中最适合的一块,注意此时内存分区的总块数可能已经发生了变化: 对于算法(2)来说,则需要从上次分配的内存块(使用变量记录即可)接着向下找到第一个满足条件的块即可,内存分区的总块可能也已经发生了变

JAVA中堆栈和内存分配

(一).栈.堆 1.寄存器:最快的存储区, 由编译器根据需求进行分配,我们在程序中无法控制.2. 栈:存放基本类型的变量数据和对象的引用,但对象本身不存放在栈中,而是存放在堆(new 出来的对象)或者常量池中(字符串常量对象存放在常量池中.)3. 堆:存放所有new出来的对象.4. 静态域(属于方法区) :存放静态成员(static定义的)5. 常量池 (属于方法区):存放字符串常量和基本类型常量(public static final).6. 非RAM存储:硬盘等永久存储空间这里我们主要关心栈

JAVA内存区域及使用分配

JAVA虚拟机运行时会将JVM使用的内存划分为不同的区域,每个区域负责不同的功能,以及各个区域的创建,销毁都各不相同. 下图是JVM运行时内存数据区的划分, 图1.JVM运行时数据区 1.程序计数器 每个线程都拥有一个独立的程序计数器,用于记录当前线程所要执行的字节码指令,该类内存区域为"线程私有"内存. 2.虚拟机栈 该区域也有人称为栈内存(对应java堆内存),这个叫法不完全正确,但可以便于理解. 该区域也是线程私有的,并且与线程的生命周期相同. 主要负责方法执行的内存部分,在每个

实验四 内存的分配与回收

#include <stdio.h> #include <malloc.h> #include <process.h> #include <string.h> #define minisize 1 typedef struct freeTable { char proID[6]; int startAddr; /*空闲区起始地址*/ int length; /*空闲区长度,单位为字节*/ int flag; /*空闲区表登记栏标志,用"0"

nginx之upstream集中分配方式

一.分配方式 1.轮询方式(默认) upstream realserver {     server 192.168.1.1;     server 192.168.1.2; } 每一个请求会按照时间顺序分配到后端不同的服务器上,假如有一台服务器宕机,则会自动剔除该服务器. 2.weight权重 upstream realserver {         server 192.168.1.1 weight=5;         server 192.168.1.2 weight=8; } 根据后

Lua2.4 内存分配 mem.c

先看看头文件里的定义,定义了一些出错信息,几个内存管理接口,和宏.几个宏的定义也是用到了内存分配的几个接口.newvector 在之前的词法分析里已经出现了.几个接口,看函数名字比较容易看出来它的作用.下面看一下它们各自的实现: void luaI_free (void *block) {   if (block)   {     *((int *)block) = -1;  /* to catch errors */     free(block);   } } 释放内存.设置 -1 的那个地

内存分配算法 之 首次适应-最佳适应

程序在向操作系统申请内存空间的时候,操作系统会扫描空闲块链表并从中取出一块足够大的分配,与之对应的算法有 首次适应 和 最佳适应,顾名思义,首次适应就是把首次遇到的足够大的空闲块分配给应用程序,最佳适应就是扫描完空闲块链表把大小与申请空间最匹配的空闲块分配给应用程序. mem.h        程序用到的头文件 main.c       主函数 fit.c        具体的实现函数 这里使用make来编译使用,若是读者还没接触过make的, 请移步参考我写的这篇文章:http://netca

C++ Primer 学习笔记_98_特殊工具与技术 --优化内存分配

特殊工具与技术 --优化内存分配 引言: C++的内存分配是一种类型化操作:new为特定类型分配内存,并在新分配的内存中构造该类型的一个对象.new表达式自动运行合适的构造函数来初始化每个动态分配的类类型对象. new基于每个对象分配内存的事实可能会对某些类强加不可接受的运行时开销,这样的类可能需要使用用户级的类类型对象分配能够更快一些.这样的类使用的通用策略是,预先分配用于创建新对象的内存,需要时在预先分配的内存中构造每个新对象. 另外一些类希望按最小尺寸为自己的数据成员分配需要的内存.例如,