int main(){ int flag;//用标志位flag可以方便结束死循环，返回上一级。 用于多级菜单 while(1){//无限循环，遇到break；跳出循环 当条件为真时一直执行循环体中的语句 menu();//主菜单 switch(c){ //主菜单选项 1 2 3 case 1:{ menu1();//问题1菜单 while(1){ switch(select1){//问题1选项 case 1: bank() ; menu1(); case 2: flag=1;break; }//switch1结束 if(flag)break;//flag=1跳出循环返回上一级 } //while1循环结束 break; } //问题1结束 case 2:{ menu2();//问题2菜单 while(1){ switch(select2){//问题2选项 case 1:{ printf("进入最小生成树求解:\n"); tree( ); //最小生成树求解 menu2(); }//case1结束 case 2:{ flag=1; break; } } //switch2结束 if(flag) break; }//while2结束 break; }//问题2结束 case 3: return 0;//选项3退出 }//switch0结束 }//while0结束 }//main()结束

这段代码是一个多级菜单的程序，主要包含一个无限循环和多个菜单选项，可以通过输入不同的选项来执行不同的功能。具体实现方式如下：

在主函数 `main()` 中，首先定义了一个整型变量 `flag`，用来表示是否需要跳出当前循环。然后通过一个无限循环 `while(1)` 来实现程序的持续运行。在循环中先调用 `menu()` 函数，显示主菜单，然后使用 `switch` 语句根据用户的选择执行相应的操作。

当用户选择主菜单选项1时，会进入问题1的菜单，使用另一个 `while(1)` 循环来等待用户的选择。在循环中使用 `switch` 语句根据用户的选择执行相应的操作。如果用户选择退出菜单，则将 `flag` 的值设为1，并跳出当前循环，返回到上一级菜单。

当用户选择主菜单选项2时，会进入问题2的菜单，同样使用 `while(1)` 循环来等待用户的选择。在循环中使用 `switch` 语句根据用户的选择执行相应的操作。如果用户选择退出菜单，则将 `flag` 的值设为1，并跳出当前循环，返回到上一级菜单。

当用户选择主菜单选项3时，程序结束，使用 `return 0` 语句退出程序。

总的来说，这段代码实现了一个简单的多级菜单程序，通过嵌套的循环和 `switch` 语句可以方便地实现菜单之间的跳转和功能的选择。同时使用 `flag` 变量可以方便地控制程序的流程。

相关问题

51单片机LCD1602多级菜单

下面是51单片机LCD1602多级菜单的代码，可以参考：

#include<reg52.h>
#include<intrins.h>

#define LCD_data P0
sbit RS=P2^0;
sbit RW=P2^1;
sbit EN=P2^2;

void delay_ms(unsigned int x);
void Write_com(unsigned char com);
void Write_data(unsigned char date);
void Init_LCD();
void Display(unsigned char row, unsigned char column, unsigned char *string);
void Menu(unsigned char *menu_item[], unsigned char n);

void main()
{
    unsigned char *menu_item[]={"Menu1","Menu2","Menu3","Menu4","Menu5"};
    Init_LCD();
    while(1)
    {
        Menu(menu_item,5); //显示5个菜单项
    }
}

//延时函数
void delay_ms(unsigned int x)
{
    unsigned int i,j;
    for(i=0;i<x;i++)
        for(j=0;j<125;j++);
}

//写命令到LCD
void Write_com(unsigned char com)
{
    RS=0;
    RW=0;
    LCD_data=com;
    EN=1;
    _nop_();
    EN=0;
}

//写数据到LCD
void Write_data(unsigned char date)
{
    RS=1;
    RW=0;
    LCD_data=date;
    EN=1;
    _nop_();
    EN=0;
}

//初始化LCD
void Init_LCD()
{
    Write_com(0x38); //8位数据，双行，5*7点阵
    Write_com(0x0c); //显示开，无光标，不闪烁
    Write_com(0x06); //写入后地址加1，不移动屏幕
    Write_com(0x01); //清屏
}

//显示字符串
void Display(unsigned char row, unsigned char column, unsigned char *string)
{
    unsigned char i=0;
    if(row==1)
        Write_com(0x80+column); //第一行
    else
        Write_com(0xc0+column); //第二行
    while(string[i]!='\0')
    {
        Write_data(string[i]);
        i++;
    }
}

//显示菜单
void Menu(unsigned char *menu_item[], unsigned char n)
{
    unsigned char i=0, j=1, k=0;
    unsigned char key, flag=1;
    while(flag)
    {
        Display(1,0,menu_item[i]); //显示菜单项
        Display(2,0,menu_item[j]); //显示下一级菜单项
        key=P1&0x0f; //读取按键值
        delay_ms(20); //消除抖动
        if(key!=0x0f) //有按键按下
        {
            delay_ms(20); //消除抖动
            if(key!=0x0f) //再次确认按键
            {
                switch(key)
                {
                    case 0x0e: //向上选择菜单项
                        if(i>0)
                        {
                            i--;
                            j--;
                        }
                        else
                        {
                            i=n-1;
                            j=n;
                        }
                        break;
                    case 0x0d: //向下选择菜单项
                        if(j<n)
                        {
                            i++;
                            j++;
                        }
                        else
                        {
                            i=0;
                            j=1;
                        }
                        break;
                    case 0x0b: //进入下一级菜单
                        Display(1,0,menu_item[j]); //显示下一级菜单
                        Display(2,0,"Return"); //显示返回菜单项
                        while(1) //等待按键
                        {
                            key=P1&0x0f; //读取按键值
                            delay_ms(20); //消除抖动
                            if(key!=0x0f) //有按键按下
                            {
                                delay_ms(20); //消除抖动
                                if(key!=0x0f) //再次确认按键
                                {
                                    if(key==0x0b) //返回上一级菜单
                                        break;
                                }
                            }
                        }
                        break;
                    case 0x07: //选择当前菜单项
                        flag=0; //退出菜单
                        break;
                    default:
                        break;
                }
                if(k!=i) //选择菜单项改变时，清除上一次选择的菜单项
                {
                    Display(1,0,"                ");
                    Display(2,0,"                ");
                    k=i;
                }
            }
        }
    }
}

具体实现多级菜单的部分是在 Menu 函数中，通过不断显示当前菜单项和下一级菜单项，并根据按键的不同响应不同的操作实现的。

多级反馈队列调度算法的基本思想是：当一个新进程进入内存后，首先将它放入第一队列的末尾，按FCFS原则排队等待调度。当轮到该进程执行时，如能在该时间片内完成，便可准备撤离系统；如果它在一个时间片结束时尚未完成，调度程序便将该进程转入第二队列的末尾，再同样地按FCFS原则等待调度执行，以此类推，用链表指针实现。给出c语言代码

以下是一个使用链表指针实现多级反馈队列调度算法的C语言代码：

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

#define MAX_TIME_SLICE 4

typedef struct Process {
    int pid; // 进程ID
    int arrival_time; // 到达时间
    int burst_time; // 执行时间
    int remaining_time; // 剩余执行时间
    int queue_level; // 队列级别
    struct Process *next; // 指向下一个进程的指针
} process;

// 将进程插入队列尾部
void enqueue(process *p, process **rear) {
    if (*rear == NULL) {
        *rear = p;
    } else {
        process *temp = *rear;
        while (temp->next != NULL) {
            temp = temp->next;
        }
        temp->next = p;
    }
}

// 将队列头部进程出队
process *dequeue(process **front, process **rear) {
    process *p = *front;
    if (*front == NULL) {
        *rear = NULL;
    } else {
        *front = (*front)->next;
    }
    return p;
}

int main() {
    process *processes = NULL;
    int n, i, j, time = 0, flag = 0;
    int time_quantum[MAX_PROCESS_NUM] = { 0 }; // 时间片
    int queue_level_num = 3; // 队列数
    process *queues[queue_level_num] = { NULL }; // 队列数组

    printf("请输入进程数：");
    scanf("%d", &n);

    // 输入每个进程的信息
    for (i = 0; i < n; i++) {
        process *p = (process *) malloc(sizeof(process));
        printf("请输入进程%d的到达时间和执行时间：", i);
        scanf("%d %d", &p->arrival_time, &p->burst_time);
        p->pid = i;
        p->remaining_time = p->burst_time;
        p->queue_level = 0;
        time_quantum[i] = MAX_TIME_SLICE; // 初始化时间片
        enqueue(p, &processes); // 将进程加入到进程列表中
    }

    // 多级反馈队列调度算法
    while (flag < n) {
        // 将到达时间小于等于当前时间的进程加入第一级队列
        process *p = processes;
        while (p != NULL) {
            if (p->arrival_time <= time && p->queue_level == 0) {
                enqueue(p, &queues[0]);
                p->queue_level = 1;
            }
            p = p->next;
        }

        // 遍历所有队列，执行队列中的进程
        for (i = 0; i < queue_level_num; i++) {
            process *front = queues[i];
            process *rear = queues[i];
            // 如果队列为空，跳过
            if (front == NULL) {
                continue;
            }
            // 取出队列头部进程
            process *p = dequeue(&front, &rear);
            // 执行该进程
            if (p->remaining_time <= time_quantum[p->pid]) {
                time += p->remaining_time;
                p->remaining_time = 0;
                printf("进程%d在时间%d时执行完毕\n", p->pid, time);
                flag++;
            } else {
                time += time_quantum[p->pid];
                p->remaining_time -= time_quantum[p->pid];
                printf("进程%d在时间%d时执行完一个时间片\n", p->pid, time);
                // 将该进程加入下一级队列
                p->queue_level++;
                enqueue(p, &queues[p->queue_level]);
            }
            // 更新队列头尾指针
            queues[i] = front;
            if (rear != NULL) {
                rear->next = NULL;
            }
        }
    }

    // 释放进程列表中的所有进程
    process *p = processes;
    while (p != NULL) {
        processes = p->next;
        free(p);
        p = processes;
    }

    return 0;
}

注意事项：

1. 在使用链表指针实现多级反馈队列调度算法时，需要为每个进程定义一个 `next` 指针，以便将其加入到队列中或从队列中移除。
2. 在每个进程被加入队列时，都将其 `queue_level` 属性设为 0，即初始加入第一级队列。随着进程被调度，其 `queue_level` 属性逐渐增加，直到完成执行。
3. 在代码实现中，使用了一个数组 `time_quantum` 来保存每个进程的时间片，以便在进程被调度时能够正确地选择执行时间。