void Sort1(VexNode* t, Message* s, int VexNum) //按各学期负担均匀输出并保存教学计划 { FILE* fp = fopen("E:/sjjg/作业/结果.txt", "w"); int c = 0; //用于输出课程信息 for (int i = 0; i < s->SemesterNum; i++) { int b = 0; //累计每学期学分 printf("\n第%d个学期的课程为：", i + 1); fprintf(fp, "\n第%d个学期的课程为：", i + 1); for (int j = 0; j < VexNum / s->SemesterNum; j++) { if (b + t[c].Credit <= s->MaxCredit) //判断是否超过最大学分 { if (c == VexNum)break; printf("%s ", t[c].Date); //输出课程 fprintf(fp, "%s ", t[c].Date); b = b + t[c].Credit; //学分累计 c++; //指向下一课程 } } if (i < VexNum % s->SemesterNum) //加入平均后多余的课程 { if (c == VexNum)break; printf("%s ", t[c].Date); //输出课程 fprintf(fp, "%s ", t[c].Date); b = b + t[c].Credit; //学分累计 c++; //指向下一课程 } } }代码实现流程

这段代码实现了按照各学期负担均匀输出并保存教学计划的功能。具体实现流程如下：

1. 打开一个名为"结果.txt"的文件，以便将输出结果保存在该文件中。

2. 定义一个变量c，用于输出课程信息。

3. 对于每一个学期，先输出该学期的序号，然后依次输出该学期中的每一门课程。

4. 对于每一门课程，判断该课程的学分是否超过了最大学分s->MaxCredit。如果没有超过，则输出该课程的名称t[c].Date，并将该课程的学分加入到学分累计变量b中，然后将指针c指向下一门课程。如果超过了最大学分，则跳过该课程。

5. 如果该学期的课程数目不足以平均分配给每个学期，则将多余的课程加入到前几个学期中。

6. 最后将输出结果保存到文件中，关闭文件。

相关问题

#define MAXVER 10 #define MAXEDG 13 typedef char VertexType; typedef struct EdgeNode { int v_id; struct EdgeNode* next_edge; }ENode; typedef struct VertexNode { VertexType val; ENode* first_edge; }VNode; typedef struct Graph { int vexnum; //顶点数 int edgenum; //边数 VNode vertexs[MAXVER]; }Graph; void creatGraph(Graph* G, VertexType ver[], VertexType edge[][2]); void DFS(Graph* G, int k, int*_visit, char** res); void BFS(Graph* G, int*_visit, char res[]); void DestroyGraph(Graph*G); void Print(Graph*G);根据初始条件补全下方函数代码，要求使用c语言

根据初始条件，下面是这些函数的代码实现：

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

#define MAXVER 10
#define MAXEDG 13

typedef char VertexType;

typedef struct EdgeNode {
    int v_id;
    struct EdgeNode* next_edge;
} ENode;

typedef struct VertexNode {
    VertexType val;
    ENode* first_edge;
} VNode;

typedef struct Graph {
    int vexnum; // 顶点数
    int edgenum; // 边数
    VNode vertexs[MAXVER];
} Graph;

// 创建图
void creatGraph(Graph* G, VertexType ver[], VertexType edge[][2]) {
    int i, j, k;
    G->vexnum = sizeof(ver) / sizeof(VertexType);
    G->edgenum = sizeof(edge) / sizeof(VertexType) / 2;
    for (i = 0; i < G->vexnum; i++) {
        G->vertexs[i].val = ver[i]; // 顶点数组赋值
        G->vertexs[i].first_edge = NULL; // 初始化邻接表
    }
    for (k = 0; k < G->edgenum; k++) {
        i = j = -1;
        // 查找边的两个顶点在顶点数组中的下标
        for (int l = 0; l < G->vexnum; l++) {
            if (edge[k][0] == G->vertexs[l].val) {
                i = l;
            }
            if (edge[k][1] == G->vertexs[l].val) {
                j = l;
            }
        }
        if (i != -1 && j != -1) {
            // 创建边节点插入邻接表
            ENode* p = (ENode*)malloc(sizeof(ENode));
            p->v_id = j;
            p->next_edge = G->vertexs[i].first_edge;
            G->vertexs[i].first_edge = p;
            p = (ENode*)malloc(sizeof(ENode));
            p->v_id = i;
            p->next_edge = G->vertexs[j].first_edge;
            G->vertexs[j].first_edge = p;
        }
    }
}

// 深度优先遍历
void DFS(Graph* G, int k, int*_visit, char** res) {
    int i;
    res[*_visit] = &(G->vertexs[k].val); // 将遍历到的顶点存入 res 数组
    *_visit += 1;
    _visit[k] = 1; // 标记该顶点已被访问
    ENode* p = G->vertexs[k].first_edge;
    while (p) {
        if (!_visit[p->v_id]) {
            DFS(G, p->v_id, _visit, res); // 递归访问邻接顶点
        }
        p = p->next_edge;
    }
}

// 广度优先遍历
void BFS(Graph* G, int*_visit, char res[]) {
    int i, j, k;
    int queue[MAXVER], front = 0, rear = 0;
    for (i = 0; i < G->vexnum; i++) {
        if (!_visit[i]) {
            res[rear++] = G->vertexs[i].val; // 将未被访问的顶点加入队列
            _visit[i] = 1; // 标记该顶点已被访问
        }
        while (front < rear) {
            k = queue[front++]; // 出队一个顶点
            ENode* p = G->vertexs[k].first_edge;
            while (p) {
                if (!_visit[p->v_id]) {
                    res[rear++] = G->vertexs[p->v_id].val; // 将邻接顶点加入队列
                    _visit[p->v_id] = 1; // 标记该顶点已被访问
                }
                p = p->next_edge;
            }
        }
    }
}

// 销毁图
void DestroyGraph(Graph*G) {
    G->vexnum = 0;
    G->edgenum = 0;
    for (int i = 0; i < G->vexnum; i++) {
        ENode* p = G->vertexs[i].first_edge;
        while (p) {
            ENode* q = p;
            p = p->next_edge;
            free(q); // 释放邻接表节点
        }
    }
}

// 打印图
void Print(Graph*G) {
    int i;
    printf("顶点数：%d，边数：%d\n", G->vexnum, G->edgenum);
    printf("顶点数组：");
    for (i = 0; i < G->vexnum; i++) {
        printf("%c ", G->vertexs[i].val);
    }
    printf("\n邻接表：\n");
    for (i = 0; i < G->vexnum; i++) {
        ENode* p = G->vertexs[i].first_edge;
        printf("%c -> ", G->vertexs[i].val);
        while (p) {
            printf("%c ", G->vertexs[p->v_id].val);
            p = p->next_edge;
        }
        printf("\n");
    }
}

void printGraphLit( GraphList *G) { /*输出邻接表，输出格式：顶点->邻接顶点编号->...*/ }

以下是输出邻接表的代码实现：

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

#define MAX_VERTEX_NUM 100

// 邻接表节点
typedef struct ArcNode {
    int adjvex;             // 邻接点的位置
    struct ArcNode *next;   // 指向下一个邻接点
} ArcNode;

// 顶点信息
typedef struct VertexNode {
    int data;               // 顶点信息
    ArcNode *firstarc;      // 指向第一个邻接点
} VertexNode;

// 邻接表
typedef struct GraphList {
    VertexNode vertex[MAX_VERTEX_NUM];  // 存放顶点信息
    int vexnum;                         // 顶点数目
    int arcnum;                         // 边数目
} GraphList;

// 输出邻接表
void printGraphList(GraphList *G) {
    printf("Adjacency list of the graph:\n");
    for (int i = 0; i < G->vexnum; i++) {
        printf("%d: ", G->vertex[i].data);
        ArcNode *arc = G->vertex[i].firstarc;
        while (arc) {
            printf("%d ", G->vertex[arc->adjvex].data);
            arc = arc->next;
        }
        printf("\n");
    }
}

注意事项：

1. 输出格式为 `顶点->邻接顶点编号->...`。
2. 这个函数不需要返回值，直接在函数中输出即可。