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

//定义队列结点
typedef struct node
{
    int num; //排队号码
    struct node *next;
} Node;

//定义队列
typedef struct queue
{
    Node *front; //队首指针
    Node *rear;  //队尾指针
} Queue;

//定义窗口结构体
typedef struct window
{
    int id;     //窗口编号
    int status; //窗口状态，0表示空闲，1表示忙碌，-1表示暂停
} Window;

//初始化队列
void initQueue(Queue *q)
{
    q->front = NULL;
    q->rear = NULL;
}

//判断队列是否为空
int isEmpty(Queue *q)
{
    return q->front == NULL;
}

//入队操作
void enqueue(Queue *q, int num)
{
    Node *newNode = (Node *)malloc(sizeof(Node)); //创建新结点
    newNode->num = num;                           //赋值排队号码
    newNode->next = NULL;
    if (isEmpty(q)) //如果队列为空，新结点既是队首也是队尾
    {
        q->front = newNode;
        q->rear = newNode;
    }
    else //如果队列不为空，新结点插入到队尾，更新队尾指针
    {
        q->rear->next = newNode;
        q->rear = newNode;
    }
}

//出队操作
int dequeue(Queue *q)
{
    if (isEmpty(q)) //如果队列为空，返回-1表示错误
    {
        return -1;
    }
    else //如果队列不为空，删除队首结点，返回其排队号码，更新队首指针
    {
        Node *temp = q->front;   //临时保存队首结点
        int num = temp->num;     //获取排队号码
        q->front = q->front->next; //更新队首指针
        free(temp);              //释放队首结点内存
        return num;              //返回排队号码
    }
}

//打印队列中的所有元素（排队号码）
void printQueue(Queue *q)
{
    if (isEmpty(q)) //如果队列为空，打印提示信息
    {
        printf("当前没有人排队\n");
    }
    else //如果队列不为空，遍历打印所有结点的排队号码
    {
        printf("当前排队的人有：\n");
        Node *p = q->front; //从队首开始遍历
        while (p != NULL)
        {
            printf("%d ", p->num); //打印排队号码
            p = p->next;           //移动到下一个结点
        }
        printf("\n");
    }
}

//初始化窗口数组，设置编号和状态
void initWindow(Window *w, int n)
{
    for (int i = 0; i < n; i++)
    {
        w[i].id = i + 1;     //窗口编号从1开始递增
        w[i].status = 0;     //窗口初始状态为0（空闲）
    }
}

//打印窗口数组中的所有元素（编号和状态）
void printWindow(Window *w, int n)
{
    printf("当前窗口的情况如下：\n");
    for (int i = 0; i < n; i++)
    {
        printf("窗口%d：", w[i].id); //打印窗口编号
        switch (w[i].status)       //根据窗口状态打印对应的信息
        {
        case 0:
            printf("空闲\n");
            break;
        case 1:
            printf("忙碌\n");
            break;
        case -1:
            printf("暂停\n");
            break;
        default:
            printf("未知\n");
            break;
        }
    }
}

//窗口新增操作，返回新增的窗口编号，如果失败返回-1
int addWindow(Window *w, int *n)
{
    if (*n >= 10) //如果窗口数量已经达到10个，不能再增加，返回-1
    {
        return -1;
    }
    else //如果窗口数量小于10个，可以增加一个窗口，更新窗口数量和编号，返回新增的窗口编号
    {
        (*n)++;                  //窗口数量加一
        w[*n - 1].id = *n;       //新增的窗口编号为当前的窗口数量
        w[*n - 1].status = 0;    //新增的窗口状态为0（空闲）
        return w[*n - 1].id;     //返回新增的窗口编号
    }
}

//窗口删除操作，返回删除的窗口编号，如果失败返回-1
int deleteWindow(Window *w, int *n)
{
    if (*n <= 1) //如果窗口数量已经只有一个，不能再删除，返回-1
    {
        return -1;
    }
    else //如果窗口数量大于一个，可以删除最后一个窗口，更新窗口数量，返回删除的窗口编号
    {
        int id = w[*n - 1].id; //获取最后一个窗口的编号
        (*n)--;                //窗口数量减一
        return id;             //返回删除的窗口编号
    }
}

//窗口业务暂停操作，返回暂停的窗口编号，如果失败返回-1
int pauseWindow(Window *w, int n, int id)
{
    if (id < 1 || id > n) //如果输入的编号不在有效范围内，返回-1
    {
        return -1;
    }
    else //如果输入的编号有效，更新对应的窗口状态为-1（暂停），返回暂停的窗口编号
    {
        w[id - 1].status = -1; //更新状态为-1（暂停）
        return id;             //返回暂停的窗口编号
    }
}

//窗口业务恢复操作，返回恢复的窗口编号，如果失败返回-1
int resumeWindow(Window *w, int n, int id)
{
    if (id < 1 || id > n) //如果输入的编号不在有效范围内，返回-1
    {
        return -1;
    }
    else //如果输入的编号有效，更新对应的窗口状态为0（空闲），返回恢复的窗口编号
    {
        w[id - 1].status = 0; //更新状态为0（空闲）
        return id;            //返回恢复的窗口编号
    }
}

//取号排队操作，返回取得的排队号码，如果失败返回-1
int takeNumber(Queue *q, int *count)
{
    if (*count >= 100) //如果排队号码已经达到100个，不能再取号，返回-1
    {
        return -1;
    }
    else //如果排队号码小于100个，可以取号，并入队，更新排队号码数量，返回取得的排队号码
    {
        (*count)++;          //排队号码数量加一
        enqueue(q, *count);  //将当前的排队号码入队
        return *count;       //返回取得的排队号码
    }
}

//办结离队操作，返回办结的排队号码和对应的窗口编号，如果失败返回-1和0
void finishService(Queue *q, Window *w, int n, int *num, int *id)
{
    if (isEmpty(q)) //如果队列为空，没有人可以办结离队，设置排队号码和窗口编号为-1和0，并直接返回
    {
        *num = -1;
        *id = 0;
        return;
    }
    
    for (int i = 0; i < n; i++) //遍历所有的窗口，找到第一个空闲或忙碌的窗口，如果找到，将其状态设置为1（忙碌），并出队一个排队号码，设置排队号码和窗口编号，并返回
    {
        if (w[i].status == 0 || w[i].status == 1) //找到第一个空闲或忙碌的窗口
        {
            w[i].status = 1; //将其状态设置为1（忙碌）
            *num = dequeue(q); //出队一个排队号码
            *id = w[i].id; //获取窗口编号
            return;
        }
    }
    //如果没有找到空闲或忙碌的窗口，说明所有的窗口都是暂停的，设置排队号码和窗口编号为-1和0，并返回
    *num = -1;
    *id = 0;
    return;
}


//清屏操作，打印一些空行来模拟清屏效果
 void clearScreen() {
  for (int i = 0; i < 50; i++) {
   printf("\n");
   }
}

//帮助操作，打印菜单信息，介绍各个功能的用法 
void printHelp() {
 	printf("欢迎来到罗氏银行！！！\n\n");
	printf("**********************************************\n");
	printf("              窗口排队管理系统                \n");
	printf("**********************************************\n"); 
	printf("1.窗口状态\n2.窗口新增\n3.窗口删除\n4.窗口业务暂停\n5.窗口业务恢复\n\n6.取号排队\n7.办结离队\n\n8.清屏\n9.帮助\n0.退出\n"); 
   }

//主函数 
int main()
{
    Queue q;       //创建一个队列
    initQueue(&q); //初始化队列

    Window w[10]; //创建一个窗口数组，最多可以有10个元素
    int n = 3;     //初始时有3个窗口
    initWindow(w, n); //初始化窗口数组

    int count = 0; //记录当前的排队号码数量，初始为0

    int choice; //记录用户的选择

    printHelp(); //打印帮助信息

    while (1) //循环执行用户的选择，直到用户选择退出
    {
        printf("\n请输入序号选择哪种罗氏银行高贵服务：\n"); //提示用户输入功能编号
        scanf("%d", &choice);                         //读取用户输入的功能编号

        switch (choice) //根据用户输入的功能编号执行对应的操作
        {
        case 1: //查看当前所有窗口的编号和状态
            printWindow(w, n);
            break;
        case 2: //增加一个新的窗口
        {
            int id = addWindow(w, &n); //调用增加窗口函数，返回新增的窗口编号
            if (id == -1)              //如果返回-1，表示增加失败，打印提示信息
            {
                printf("无法增加更多的窗口了！\n");
            }
            else //如果返回有效的编号，表示增加成功，打印提示信息
            {
                printf("成功增加了一个新的窗口，编号为%d\n", id);
            }
            break;
        }
        case 3: //删除最后一个窗口
        {
            int id = deleteWindow(w, &n); //调用删除窗口函数，返回删除的窗口编号
            if (id == -1)                 //如果返回-1，表示删除失败，打印提示信息
            {
                printf("无法删除更多的窗口了！\n");
            }
            else //如果返回有效的编号，表示删除成功，打印提示信息
            {
                printf("成功删除了一个窗口，编号为%d\n", id);
            }
            break;
        }
        case 4: //将一个窗口的状态设置为暂停
        {
            int id; //记录用户输入的窗口编号
            printf("请输入您要暂停的窗口编号：\n"); //提示用户输入窗口编号
            scanf("%d", &id);                     //读取用户输入的窗口编号
            int result = pauseWindow(w, n, id);   //调用暂停窗口函数，返回暂停的窗口编号
            if (result == -1)                     //如果返回-1，表示暂停失败，打印提示信息
            {
                printf("无效的窗口编号！\n");
            }
            else //如果返回有效的编号，表示暂停成功，打印提示信息
            {
                printf("成功暂停了窗口%d\n", result);
            }
            break;
        }
        case 5: //将一个窗口的状态设置为空闲
        {
            int id; //记录用户输入的窗口编号
            printf("请输入您要恢复的窗口编号：\n"); //提示用户输入窗口编号
            scanf("%d", &id);                     //读取用户输入的窗口编号
            int result = resumeWindow(w, n, id);  //调用恢复窗口函数，返回恢复的窗口编号
            if (result == -1)                     //如果返回-1，表示恢复失败，打印提示信息
            {
            printf("无效的窗口编号！\n");
            }
             else //如果返回有效的编号，表示恢复成功，打印提示信息
           {
            printf("成功恢复了窗口%d\n", result);
           }
            break;
           }
    case 6: //获取一个新的排队号码，并加入到队列中
    {
        int num = takeNumber(&q, &count); //调用取号排队函数，返回取得的排队号码
        if (num == -1)                    //如果返回-1，表示取号失败，打印提示信息
        {
            printf("无法再取号了！\n");
        }
        else //如果返回有效的号码，表示取号成功，打印提示信息
                {
            printf("您的排队号码是%d，请耐心等待\n", num);
        }
        break;
    }
    case 7: //从队列中取出一个排队号码，并分配给一个空闲或忙碌的窗口
    {
        int num, id; //记录办结的排队号码和对应的窗口编号
        finishService(&q, w, n, &num, &id); //调用办结离队函数，返回办结的排队号码和对应的窗口编号
        if (num == -1 && id == 0)          //如果返回-1和0，表示办结失败，打印提示信息
        {
            printf("当前没有人可以办结离队！\n");
        }
        else //如果返回有效的号码和编号，表示办结成功，打印提示信息
        {
            printf("排队号码%d请到窗口%d办理业务\n", num, id);
        }
        break;
    }
    case 8: //清除屏幕上的内容
        clearScreen();
        break;
    case 9: //显示帮助信息
        printHelp();
        break;
    case 0: //退出系统
        printf("感谢您使用本系统，再见！\n");
        return 0; //结束程序
    default: //输入无效的功能编号，打印提示信息
        printf("无效的功能编号，请重新输入！\n");
        break;
    }
}

return 0;
}

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

//定义队列结点
typedef struct node
{
    int num; //排队号码
    char type; //业务类型
    struct node *next;
} Node;

//定义队列
typedef struct queue
{
    Node *front; //队首指针
    Node *rear;  //队尾指针
} Queue;

//定义窗口结构体
typedef struct window
{
    int id;     //窗口编号
    int status; //窗口状态，0表示空闲，1表示忙碌，-1表示暂停
    char type;  //窗口类别，A表示个人现金业务，B表示个人其他业务，C表示对公现金业务，D表示对公其他业务
} Window;

//初始化队列
void initQueue(Queue *q)
{
    q->front = NULL;
    q->rear = NULL;
}

//判断队列是否为空
int isEmpty(Queue *q)
{
    return q->front == NULL;
}

//入队操作
void enqueue(Queue *q, int num, char type)
{
    Node *newNode = (Node *)malloc(sizeof(Node)); //创建新结点
    newNode->num = num;                           //赋值排队号码
    newNode->type = type;                         //赋值业务类型
    newNode->next = NULL;
    if (isEmpty(q)) //如果队列为空，新结点既是队首也是队尾
    {
        q->front = newNode;
        q->rear = newNode;
    }
    else //如果队列不为空，新结点插入到队尾，更新队尾指针
    {
        q->rear->next = newNode;
        q->rear = newNode;
    }
}

//出队操作
int dequeue(Queue *q, char type)
{
    if (isEmpty(q)) //如果队列为空，返回-1表示错误
    {
        return -1;
    }
    else //如果队列不为空，删除第一个与指定类型匹配的结点，返回其排队号码，更新队首指针
    {
        Node *p = q->front;   //从队首开始遍历
        Node *prev = NULL;    //记录前驱结点
        
        while (p != NULL)     //循环查找与指定类型匹配的结点
        {
            if (p->type == type) //找到匹配的结点，退出循环
            {
                break;
            }
            prev = p;         //更新前驱结点
            p = p->next;      //移动到下一个结点
        }

        if (p == NULL)       //如果没有找到匹配的结点，返回-1表示错误
        {
            return -1;
        }
        else                 //如果找到匹配的结点，删除它，并返回其排队号码
        {
            int num = p->num;     //获取排队号码
            
            if (prev == NULL)     //如果前驱结点为空，说明匹配的结点是队首结点，更新队首指针为下一个结点
            {
                q->front = q->front->next;
            }
            else                  //如果前驱结点不为空，说明匹配的结点不是队首结点，更新前驱结点的后继为当前结点的后继 
            {
                prev->next = p->next;
            }

            if (p == q->rear)     //如果匹配的结点是队尾结点，更新队尾指针为前驱结点 
            {
                q->rear = prev;
            }

            free(p);              //释放匹配的结点内存
            
            return num;           //返回排队号码
            
        }
        
    }
}

//打印队列中的所有元素（排队号码和业务类型）
void printQueue(Queue *q)
{
    if (isEmpty(q)) //如果队列为空，打印提示信息
    {
        printf("当前没有人排队\n");
    }
    else //如果队列不为空，遍历打印所有结点的排队号码和业务类型
    {
        printf("当前排队的人有：\n");
        Node *p = q->front; //从队首开始遍历
        while (p != NULL)
        {
            printf("%d(%c) ", p->num, p->type); //打印排队号码和业务类型
            p = p->next;           //移动到下一个结点
        }
        printf("\n");
    }
}

//初始化窗口数组，设置编号、状态和类别
void initWindow(Window *w, int n)
{
    for (int i = 0; i < n; i++)
    {
        w[i].id = i + 1;     //窗口编号从1开始递增
        w[i].status = 0;     //窗口初始状态为0（空闲）
        w[i].type = 'A' + i; //窗口初始类别为A、B、C、D...
    }
}

//打印窗口数组中的所有元素（编号、状态、类别和排队人数）
void printWindow(Window *w, int n, Queue *q); //函数声明，增加一个队列参数

//打印窗口数组中的所有元素（编号、状态、类别和排队人数）
void printWindow(Window *w, int n, Queue *q) //函数定义，增加一个队列参数
{
    printf("当前窗口的情况如下：\n");
    for (int i = 0; i < n; i++)
    {
        printf("窗口%d（%c）：", w[i].id, w[i].type); //打印窗口编号和类别
        switch (w[i].status)       //根据窗口状态打印对应的信息
        {
        case 0:
            printf("空闲");
            break;
        case 1:
            printf("忙碌");
            break;
        case -1:
            printf("暂停");
            break;
        default:
            printf("未知");
            break;
        }
        
        int count = 0; //记录当前窗口前面排队的人数
        Node *p = q->front; //从队首开始遍历
              while (p != NULL)   //循环统计与当前窗口类型匹配的结点个数
        {
            if (p->type == w[i].type) //如果结点的业务类型与当前窗口类型匹配，计数加一
            {
                count++;
            }
            p = p->next; //移动到下一个结点
        }
        
        printf("，前面还有%d人排队\n", count); //打印排队人数
    }
}

//窗口新增操作，返回新增的窗口编号，如果失败返回-1
int addWindow(Window *w, int *n)
{
    if (*n >= 10) //如果窗口数量已经达到10个，不能再增加，返回-1
    {
        return -1;
    }
    else //如果窗口数量小于10个，可以增加一个窗口，更新窗口数量和编号，返回新增的窗口编号
    {
        (*n)++;                  //窗口数量加一
        w[*n - 1].id = *n;       //新增的窗口编号为当前的窗口数量
        
        char type;               //记录用户输入的窗口类别
        printf("请输入您要增加的窗口类别A表示个人现金业务，B表示个人其他业务，C表示对公现金业务，D表示对公其他业务：\n"); //提示用户输入窗口类别
        scanf(" %c", &type);     //读取用户输入的窗口类别
        
        while (type != 'A' && type != 'B' && type != 'C' && type != 'D') //如果输入的类别不在有效范围内，提示用户重新输入
        {
            printf("无效的窗口类别，请重新输入！\n");
            scanf(" %c", &type);
        }
        
        w[*n - 1].type = type;   //新增的窗口类别为用户输入的类别
        w[*n - 1].status = 0;    //新增的窗口状态为0（空闲）
        return w[*n - 1].id;     //返回新增的窗口编号
    }
}

//窗口删除操作，返回删除的窗口编号，如果失败返回-1
int deleteWindow(Window *w, int *n)
{
    if (*n <= 4) //如果窗口数量已经只有四个，不能再删除，返回-1
    {
        return -1;
    }
    else //如果窗口数量大于四个，可以删除最后一个窗口，更新窗口数量，返回删除的窗口编号
    {
        int id = w[*n - 1].id; //获取最后一个窗口的编号
        (*n)--;                //窗口数量减一
        return id;             //返回删除的窗口编号
    }
}

//窗口业务暂停操作，返回暂停的窗口编号，如果失败返回-1
int pauseWindow(Window *w, int n, int id)
{
    if (id < 1 || id > n) //如果输入的编号不在有效范围内，返回-1
    {
        return -1;
    }
    else //如果输入的编号有效，更新对应的窗口状态为-1（暂停），返回暂停的窗口编号
    {
        w[id - 1].status = -1; //更新状态为-1（暂停）
        return id;             //返回暂停的窗口编号
    }
}

//窗口业务恢复操作，返回恢复的窗口编号，如果失败返回-1
int resumeWindow(Window *w, int n, int id)
{
    if (id < 1 || id > n) //如果输入的编号不在有效范围内，返回-1
    {
        return -1;
    }
    else //如果输入的编号有效，更新对应的窗口状态为0（空闲），返回恢复的窗口编号
    {
        w[id - 1].status = 0; //更新状态为0（空闲）
        return id;            //返回恢复的窗口编号
    }
}

//取号排队操作，返回取得的排队号码，如果失败返回-1
int takeNumber(Queue *q, int *count)
{
    if (*count >= 100) //如果排队号码已经达到100个，不能再取号，返回-1
    {
        return -1;
    }
    else //如果排队号码小于100个，可以取号，并入队，更新排队号码数量，返回取得的排队号码
    {
        (*count)++;          //排队号码数量加一
        
        char type;           //记录用户输入的业务类型
        printf("请输入您要办理的业务类型（A/B/C/D）：\n"); //提示用户输入业务类型
        scanf(" %c", &type);     //读取用户输入的业务类型
        
        while (type != 'A' && type != 'B' && type != 'C' && type != 'D') //如果输入的类型不在有效范围内，提示用户重新输入
        {
            printf("无效的业务类型，请重新输入！\n");
            scanf(" %c", &type);
        }
        
        enqueue(q, *count, type);  //将当前的排队号码和业务类型入队
        return *count;       //返回取得的排队号码
    }
}

//办结离队操作，返回办结的排队号码和对应的窗口编号，如果失败返回-1和0
void finishService(Queue *q, Window *w, int n, int *num, int *id)
{
    if (isEmpty(q)) //如果队列为空，没有人可以办结离队，设置排队号码和窗口编号为-1和0，并直接返回
    {
        *num = -1;
        *id = 0;
        return;
    }
    
    for (int i = 0; i < n; i++) //遍历所有的窗口，找到第一个空闲或忙碌且与队首业务类型匹配的窗口，如果找到，将其状态设置为1（忙碌），并出队一个排队号码，设置排队号码和窗口编号，并返回
    {
        if ((w[i].status == 0 || w[i].status == 1) && w[i].type == q->front->type) //找到第一个空闲或忙碌且与队首业务类型匹配的窗口
        {
            w[i].status = 1; //将其状态设置为1（忙碌）
            *num = dequeue(q, w[i].type); //出队一个与窗口类型匹配的排队号码
            *id = w[i].id; //获取窗口编号
            return;
        }
    }
    //如果没有找到空闲或忙碌且与队首业务类型匹配的窗口，说明没有合适的窗口可以办理当前的业务，设置排队号码和窗口编号为-1和0，并返回
    *num = -1;
    *id = 0;
    return;
}

//清屏操作，打印一些空行来模拟清屏效果
void clearScreen()
{
   // for (int i = 0; i < 50; i++)
    //{
      //  printf("\n");
    //}
    system("cls");
    printf("清屏成功！！！！！！！！！！！！"); 
}

//帮助操作，打印菜单信息，介绍各个功能的用法
void printHelp()
{
    printf("欢迎来到罗氏银行！！！\n\n");
	printf("**********************************************\n");
	printf("              窗口排队管理系统                \n");
	printf("**********************************************\n"); 
	printf("1.窗口状态\n2.窗口新增\n3.窗口删除\n4.窗口业务暂停\n5.窗口业务恢复\n\n6.取号排队\n7.办结离队\n\n8.清屏\n9.帮助\n0.退出\n"); 
}

//主函数
int main()
{
    Queue q;       //创建一个队列
    initQueue(&q); //初始化队列

    Window w[10]; //创建一个窗口数组，最多可以有10个元素
    int n = 4;     //初始时有4个窗口
    initWindow(w, n); //初始化窗口数组

    int count = 0; //记录当前的排队号码数量，初始为0

    int choice; //记录用户的选择

    printHelp(); //打印帮助信息

    while (1) //循环执行用户的选择，直到用户选择退出
    {
        printf("\n请输入序号（0-9）选择哪种罗氏银行高贵服务：\n"); //提示用户输入功能编号
        scanf("%d", &choice);                         //读取用户输入的功能编号

        switch (choice) //根据用户输入的功能编号执行对应的操作
        {
        case 1: //查看当前所有窗口的编号、状态、类别和排队人数
            printWindow(w, n, &q); //增加一个队列参数
            break;
        case 2: //增加一个新的窗口
        {
            int id = addWindow(w, &n); //调用增加窗口函数，返回新增的窗口编号
            if (id == -1)              //如果返回-1，表示增加失败，打印提示信息
            {
                printf("无法增加更多的窗口了！\n");
            }
            else //如果返回有效的编号，表示增加成功，打印提示信息
            {
                printf("成功增加了一个新的窗口，编号为%d\n", id);
            }
            break;
        }
        case 3: //删除最后一个窗口
        {
            int id = deleteWindow(w, &n); //调用删除窗口函数，返回删除的窗口编号
            if (id == -1)                 //如果返回-1，表示删除失败，打印提示信息
            {
                printf("无法删除更多的窗口了！\n");
            }
            else //如果返回有效的编号，表示删除成功，打印提示信息
            {
                printf("成功删除了一个窗口，编号为%d\n", id);
            }
            break;
        }
        case 4: //将一个窗口的状态设置为暂停
        {
            int id; //记录用户输入的窗口编号
            printf("请输入您要暂停的窗口编号：\n"); 
            scanf("%d", &id);                    
            int result = pauseWindow(w, n, id);   
            if (result == -1)                     
            {
                printf("无效的窗口编号！\n");
            }
            else //如果返回有效的编号，表示暂停成功，打印提示信息
            {
                printf("成功暂停了窗口%d\n", result);
            }
            break;
        }
        case 5: //将一个窗口的状态设置为空闲
        {
            int id; //记录用户输入的窗口编号
            printf("请输入您要恢复的窗口编号：\n"); //提示用户输入窗口编号
                        scanf("%d", &id);                     //读取用户输入的窗口编号
            int result = resumeWindow(w, n, id);  //调用恢复窗口函数，返回恢复的窗口编号
            if (result == -1)                     //如果返回-1，表示恢复失败，打印提示信息
            {
                printf("无效的窗口编号！\n");
            }
            else //如果返回有效的编号，表示恢复成功，打印提示信息
            {
                printf("成功恢复了窗口%d\n", result);
            }
            break;
        }
        case 6: //获取一个新的排队号码，并加入到队列中
        {
            int num = takeNumber(&q, &count); //调用取号排队函数，返回取得的排队号码
            if (num == -1)                    
            {
                printf("无法再取号了！\n");
            }
            else 
            {
                printf("您的排队号码是%d，请耐心等待\n", num);
            }
            break;
        }
        case 7: 
        {
            int num, id; 
            finishService(&q, w, n, &num, &id); 
            if (num == -1 && id == 0)          
            {
                printf("当前没有人可以办结离队！\n");
            }
            else 
            {
                printf("排队号码%d请到窗口%d办理业务\n", num, id);
            }
            break;
        }
        case 8: 
            clearScreen();//这波我用C直接调用系统函数，牛逼克拉斯 
            break;
        case 9: 
            printHelp();
            break;
        case 0: 
            printf("感谢您使用本系统，再见！\n");
            return 0; 
        default: 
            printf("无效的功能编号，请重新输入！\n");
            break;
        }
    }

    return 0;
}