关于图的邻接矩阵建立，我真的改不动了

bboobii

//图的邻接矩阵建立
#define    N 100//图最大顶点个数
#define    MAX 32767
#include "stdio.h"

typedef struct//图的邻接矩阵类型
{
        int AdjMatrix[N][N]; //邻接矩阵
        int VexNum, ArcNum; //顶点数，弧数
        //int vexs[N];//存放顶点信息---如该顶点的下一个顶点
} AM_Graph;

//输出图的邻接矩阵
void DisplayAM(AM_Graph g)/*输出邻接矩阵*/
{
        int i, j;
        for (i = 0; i < g.VexNum; i++)
        {
                for (j = 0; j < g.VexNum; j++)
                        if (g.AdjMatrix[i][j] == MAX)
                                printf("%4s", "∞");
                        else  printf("%4d", g.AdjMatrix[i][j]);
                printf("\n");
        }
}



//图的邻接表建立
//图的邻接表存储结构描述
#include "stdlib.h"
#define VERTEX_NUM 8 //顶点数
#define ARC_NUM 9 //边数
typedef int VexType;

typedef struct AdjNode //邻接结点结构
{
        int adjvex;        //邻接点编号
        int weight;   //权值——可选项
        AdjNode* next;   // 邻接点指针
}AL_AdjNode;

typedef struct  //邻接表顶点结点结构
{
        VexType  vertex;   //顶点
        int  indegree;    //入度——此为可选项
        AdjNode* link;     // 邻接点头指针
} AL_VexNode;

typedef struct  //总的邻接表结构
{
        AL_VexNode  VexList[VERTEX_NUM];  //顶点表
        int VexNum, ArcNum;    //顶点数，弧（边）数
} AL_Graph;

//建立邻接表
AL_Graph Create_AdjList(int AdjMatrix[N][N])
{
        int G;
        AL_Graph G = { {0,NULL},VERTEX_NUM,ARC_NUM };
        int j;
        AL_AdjNode* Ptr, * nextPtr;

        for (int i = 0; i < VERTEX_NUM; i++)
        {
                G.VexList[i].vertex = i;
                G.VexList[i].link = NULL;
                j = 0;
                while (j < VERTEX_NUM)
                {
                        if (AdjMatrix[i][j] != 0)//有邻接点
                        {
                                Ptr = (AL_AdjNode*)malloc(sizeof(AL_AdjNode));
                                Ptr->adjvex = j;
                                Ptr->next = NULL;
                                if (G.VexList[i].link == NULL)//首次加入邻接点
                                {
                                        G.VexList[i].link = Ptr;
                                        nextPtr = Ptr;
                                }
                                else
                                {
                                        nextPtr->next = Ptr;
                                        nextPtr = Ptr;
                                }
                        }
                        j++;
                }
        }
        return G;
}
//调试程序
int main()
{
        //邻接表Adjacency List--AL
        int AdjMatrix[N][N] =//邻接矩阵——测试样例1
        { {0,1,1,0,0,0,0,0},
        {1,0,0,1,1,0,0,0},
        {1,0,0,0,0,1,1,0},
        {0,1,0,0,0,0,0,1},
        {0,1,0,0,0,0,0,1},
        {0,0,1,0,0,0,1,0},
        {0,0,1,0,0,1,0,0},
        {0,0,0,1,1,0,0,0} };
        /*===================
        邻接矩阵——测试样例2
        {{0,1,1,1,0,0},
        {0,0,0,0,0,0},
        {0,1,0,0,1,0},
        {0,0,0,0,1,0},
        {0,0,0,0,0,0},
        {0,0,0,1,1,0}};
        =====================*/
        AL_Graph G;
        G = Create_AdjList(AdjMatrix);
        return 0;
}


感觉没毛病，但是一运行就各种未声明的标识符，可是明明声明了，声明顺序也是对的，哭死

ZhKQYu

1. #define    N 100//图最大顶点个数
   
2. #define    MAX 32767
   
3. #include "stdio.h"
   
4. 
   
5. typedef struct//图的邻接矩阵类型
   
6. {
   
7.         int AdjMatrix[N][N]; //邻接矩阵
   
8.         int VexNum, ArcNum; //顶点数，弧数
   
9.         //int vexs[N];//存放顶点信息---如该顶点的下一个顶点
   
10. } AM_Graph;
    
11. 
    
12. //输出图的邻接矩阵
    
13. void DisplayAM(AM_Graph g)/*输出邻接矩阵*/
    
14. {
    
15.         int i, j;
    
16.         for (i = 0; i < g.VexNum; i++)
    
17.         {
    
18.                 for (j = 0; j < g.VexNum; j++)
    
19.                         if (g.AdjMatrix[i][j] == MAX)  // CHANGE
    
20.                                 printf("%4s", "∞");
    
21.                         else  printf("%4d", g.AdjMatrix[i][j]);  // CHANGE
    
22.                 printf("\n");
    
23.         }
    
24. }
    
25. 
    
26. 
    
27. 
    
28. //图的邻接表建立
    
29. //图的邻接表存储结构描述
    
30. #include "stdlib.h"
    
31. #define VERTEX_NUM 8 //顶点数
    
32. #define ARC_NUM 9 //边数
    
33. typedef int VexType;
    
34. 
    
35. typedef struct AdjNode //邻接结点结构
    
36. {
    
37.         int adjvex;        //邻接点编号
    
38.         int weight;   //权值——可选项
    
39.         struct AdjNode* next;   // 邻接点指针  CHANGE
    
40. }AL_AdjNode;
    
41. 
    
42. typedef struct  //邻接表顶点结点结构
    
43. {
    
44.         VexType  vertex;   //顶点
    
45.         int  indegree;    //入度——此为可选项
    
46.         struct AdjNode* link;     // 邻接点头指针  CHANGE
    
47. } AL_VexNode;
    
48. 
    
49. typedef struct  //总的邻接表结构
    
50. {
    
51.         AL_VexNode  VexList[VERTEX_NUM];  //顶点表
    
52.         int VexNum, ArcNum;    //顶点数，弧（边）数
    
53. } AL_Graph;
    
54. 
    
55. //建立邻接表
    
56. AL_Graph Create_AdjList(int AdjMatrix[N][N])
    
57. {
    
58.         //int G;
    
59.         AL_Graph G = { {0,NULL},VERTEX_NUM,ARC_NUM };
    
60.         int j;
    
61.         AL_AdjNode* Ptr, * nextPtr;
    
62. 
    
63.         for (int i = 0; i < VERTEX_NUM; i++)
    
64.         {
    
65.                 G.VexList->vertex = i;
    
66.                 G.VexList->link = NULL;
    
67.                 j = 0;
    
68.                 while (j < VERTEX_NUM)
    
69.                 {
    
70.                         if (AdjMatrix[j] != 0)//有邻接点
    
71.                         {
    
72.                                 Ptr = (AL_AdjNode*)malloc(sizeof(AL_AdjNode));
    
73.                                 Ptr->adjvex = j;
    
74.                                 Ptr->next = NULL;
    
75.                                 if (G.VexList->link == NULL)//首次加入邻接点
    
76.                                 {
    
77.                                         G.VexList->link = Ptr;
    
78.                                         nextPtr = Ptr;
    
79.                                 }
    
80.                                 else
    
81.                                 {
    
82.                                         nextPtr->next = Ptr;
    
83.                                         nextPtr = Ptr;
    
84.                                 }
    
85.                         }
    
86.                         j++;
    
87.                 }
    
88.         }
    
89.         return G;
    
90. }
    
91. //调试程序
    
92. int main()
    
93. {
    
94.         //邻接表Adjacency List--AL
    
95.         int AdjMatrix[N][N] =//邻接矩阵——测试样例1
    
96.         { {0,1,1,0,0,0,0,0},
    
97.         {1,0,0,1,1,0,0,0},
    
98.         {1,0,0,0,0,1,1,0},
    
99.         {0,1,0,0,0,0,0,1},
    
100.         {0,1,0,0,0,0,0,1},
     
101.         {0,0,1,0,0,0,1,0},
     
102.         {0,0,1,0,0,1,0,0},
     
103.         {0,0,0,1,1,0,0,0} };
     
104.         /*===================
     
105.         邻接矩阵——测试样例2
     
106.         {{0,1,1,1,0,0},
     
107.         {0,0,0,0,0,0},
     
108.         {0,1,0,0,1,0},
     
109.         {0,0,0,0,1,0},
     
110.         {0,0,0,0,0,0},
     
111.         {0,0,0,1,1,0}};
     
112.         =====================*/
     
113.         AL_Graph G;
     
114.         G = Create_AdjList(AdjMatrix);
     
115.         return 0;
     
116. }
     

复制代码