for (int i = 0; i < G->VexNum; i++) { //读取课程名称和学分 fscanf(fp, "%s%d", G->Vertics[i].Date, &G->Vertics[i].Credit); //根据先修课程建立邻接表结点 while ('\n' != fgetc(fp)) { char str[4]; int pos; fscanf(fp, "%s", str); pos = Locate(str); //判断课程是不是没有 if (pos < 0 || pos > G->VexNum) { //判断课程是否有错误 printf("%s请输入正确的先决条件！\n", G->Vertics[i].Date); exit(EXIT_FAILURE); } //更新弧节点 注意是pos指向i的弧 ArcNode* p = (ArcNode*)malloc(sizeof(ArcNode)); p->AdjVex = i; p->Next = G->Vertics[pos].FirstArc; G->Vertics[pos].FirstArc = p; G->ArcNum++; } }之后怎么输出课程先修条件

在建立好有向图的邻接表结构之后，如果需要输出课程的先修条件，可以采用以下方法：

1. 遍历每个顶点，即每个课程，对于每个顶点i，遍历它的邻接表，即所有指向它的弧节点，找到每个弧节点指向的顶点，即该课程的先修课程，输出该先修课程的名称即可。

2. 具体地，对于每个顶点i，可以使用以下代码：

printf("%s的先修课程有：", G->Vertics[i].Date);
ArcNode* p = G->Vertics[i].FirstArc;
while (p) {
    printf("%s ", G->Vertics[p->AdjVex].Date);
    p = p->Next;
}
printf("\n");

其中，G->Vertics[i].Date表示第i个顶点的课程名称，G->Vertics[p->AdjVex].Date表示弧节点p指向的顶点的课程名称。遍历邻接表可以使用一个指向弧节点的指针p，初始值为该顶点的FirstArc字段，每次更新为p->Next。

这样，就可以输出每个课程的先修课程列表了。

相关问题

#include<iostream> using namespace std; typedef struct{ char* vexs; int** arcs; int vexNum; int arcNum; }Graph; Graph* initGraph(int vexNum) { Graph* G = new Graph; G->arcs = new int*;G->vexs = new char; for(int i = 0;i<vexNum;i++) G->arcs[i] = new int; G->arcNum = 0; G->vexNum = vexNum; return G; } void createGraph(Graph* G,char* vexs,int* arcs) { for(int i = 0;i<G->vexNum;i++) { G->vexs[i] = vexs[i]; for(int j = 0;j<G->vexNum;j++) { G->arcs[i][j] = *(arcs+i*G->vexNum+j); if(G->arcs[i][j]) G->arcNum++; } } G->arcNum=2;//无向图 } void dfs(Graph* G,int* visited,int index) { cout<<G->vexs[index]<<'\t'; visited[index] = 1; for(int i = 0;i<G->vexNum;i++) { if(!visited[i] && G->arcs[index][i]) dfs(G,visited,i); } } void test1() { Graph* G = initGraph(5); char vexs[6] = "ABCDE"; int arcs[5][5] = { 0,1,1,1,0, 1,0,1,1,1, 1,1,0,0,0, 1,1,0,0,1, 0,1,0,1,0 }; createGraph(G,vexs,(int*)arcs); int visited[6] = {0}; dfs(G,visited,0); } int main() { test1(); return 0; }

这段代码实现了一个无向图的深度优先搜索算法。代码中使用了一个自定义的结构体 `Graph` 来表示图的结构，其中包含了顶点集合 `vexs`、邻接矩阵 `arcs`、顶点数 `vexNum` 和边数 `arcNum`。

在 `initGraph` 函数中，通过动态分配内存创建了一个 `Graph` 对象，并初始化了邻接矩阵和顶点数。

在 `createGraph` 函数中，根据传入的顶点集合和邻接矩阵数据，将数据复制到图的对应位置，并计算边数。

在 `dfs` 函数中，实现了深度优先搜索算法。从给定的起始顶点开始，遍历与其相邻且未访问过的顶点，并递归调用 `dfs` 函数进行继续搜索。

最后，在 `test1` 函数中，创建了一个具有 5 个顶点的图，并使用深度优先搜索算法进行遍历，输出遍历结果。

需要注意的是，这段代码中存在一些问题，比如在动态分配内存时，没有正确分配数组的空间。下面是修复后的代码：

#include<iostream>
using namespace std;

typedef struct {
    char* vexs;
    int** arcs;
    int vexNum;
    int arcNum;
} Graph;

Graph* initGraph(int vexNum) {
    Graph* G = new Graph;
    
    G->arcs = new int*[vexNum];
    G->vexs = new char[vexNum];
    for (int i = 0; i < vexNum; i++)
        G->arcs[i] = new int[vexNum];
    G->arcNum = 0;
    G->vexNum = vexNum;
    return G;
}

void createGraph(Graph* G, char* vexs, int* arcs) {
    for (int i = 0; i < G->vexNum; i++) {
        G->vexs[i] = vexs[i];
        for (int j = 0; j < G->vexNum; j++) {
            G->arcs[i][j] = *(arcs + i * G->vexNum + j);
            if (G->arcs[i][j])
                G->arcNum++;
        }
    }
    G->arcNum /= 2; // 无向图，边数需要除以2
}

void dfs(Graph* G, int* visited, int index) {
    cout << G->vexs[index] << '\t';
    visited[index] = 1;
    for (int i = 0; i < G->vexNum; i++) {
        if (!visited[i] && G->arcs[index][i])
            dfs(G, visited, i);
    }
}

void test1() {
    Graph* G = initGraph(5);
    char vexs[5] = { 'A', 'B', 'C', 'D', 'E' };
    int arcs[5][5] = {
        {0, 1, 1, 1, 0},
        {1, 0, 1, 1, 1},
        {1, 1, 0, 0, 0},
        {1, 1, 0, 0, 1},
        {0, 1, 0, 1, 0}
    };
    createGraph(G, vexs, (int*)arcs);
    int visited[5] = { 0 };
    dfs(G, visited, 0);
}

int main() {
    test1();
    return 0;
}

这样修复后的代码可以正确创建图的结构，并实现深度优先搜索算法进行遍历。

int LocateVex(AMGraph *G,VerTexType v) { int i; for (i = 0; i < G->vexnum; i++) { if (G->vex[i] == v) return i; } return -1; } Status CreateUDN(AMGraph *G) { int i, j, k; VerTexType v1, v2; ArcType w; printf("输入城市的总数量和总边数："); scanf("%d %d", &G->vexnum, &G->arcnum); fflush(stdin); printf("输入各个城市的代号："); for (i = 0; i < G->vexnum; i++) scanf("%c", &G->vex[i]); for (i = 0; i < G->vexnum;i++) for (j = 0; j < G->vexnum; j++) { G->arc[i][j] = Max_Int; } for (k = 0; k < G->arcnum; k++) { fflush(stdin); printf("输入相邻城市以及它们之间的成本："); scanf("%c %c %d", &v1, &v2, &w); i = LocateVex(G, v1); j = LocateVex(G, v2); G->arc[i][j] = w; G->arc[j][i] = G->arc[i][j]; } return OK; } //查找下一个权值最小的边上的另一个节点 int Min(AMGraph G) { int i; int min = Max_Int; int index = -1; for (i = 0; i < G.vexnum; i++) { if (min>closedge[i].lowcost&&closedge[i].lowcost!=0) { min = closedge[i].lowcost; index = i; } } return index; }

这段代码是 Prim 算法实现中用到的一些函数。其中，LocateVex 函数用来查找顶点 v 在邻接矩阵中的位置，CreateUDN 函数用来创建无向图，包括输入城市的总数量和总边数，各个城市的代号以及相邻城市之间的成本。在 CreateUDN 函数中，邻接矩阵的初值被初始化为 Max_Int，表示两个顶点之间没有边，而输入的边的信息则会更新邻接矩阵中对应位置的权值。Min 函数用来查找 closedge 数组中最小权值的边的位置。具体实现过程为：遍历 closedge 数组，找到权值最小的边的位置，返回该位置即可。