一步两步学算法之图邻接表实现

图的邻接表实现

这种结构创建邻接表时添加节点较为绕 建议断点调试下看看

邻接表和邻接矩阵相比 邻接表节省空间但是很难判断两个节点之间是否有边  此种结构要在稀疏图下才划算

下面是代码

 1 #define VERTEX_MAX 20
 2 #include "stdio.h"
 3 #include "malloc.h"
 4 typedef struct edgeNode
 5 {
 6     int Vertex;                //顶点序号
 7     int weight;
 8     struct edgeNode *next;    //指向有边的下一个顶点
 9 }EdgeNode;                    //邻接表边的结构
10
11 typedef struct
12 {
13     EdgeNode *AdjList[VERTEX_MAX];                //顶点的结构体指针数组
14     int VextexNum,EdgeNum;                        //顶点数量 边的数量
15     int GraphType;                                //图的类型
16
17 }ListGraph;                                    //邻接表结构
18 void CreateGraph(ListGraph *G);                //创建邻接表
19 void OutList(ListGraph);                    //输出邻接表
20
21 void CreateGraph (ListGraph *G)
22 {
23     int i,weight;
24     int start,end;
25     EdgeNode *s;
26     for(i=1;i<=G->VextexNum;i++)
27         G->AdjList[i]=NULL;                        //所有顶点初始化为NULL
28     for(i=1;i<=G->EdgeNum;i++)
29     {
30         getchar();
31         printf("第%d条边:",i);
32         scanf("%d%d%d",&start,&end,&weight);
33         s=(EdgeNode*)malloc(sizeof(EdgeNode));            //申请保存一条边的内存
34         s->next=G->AdjList[start];                        //指向上一个顶点所在位置
35         s->Vertex=end;                                    // 保存结束顶点
36         s->weight=weight;
37         G->AdjList[start]=s;                            //邻接表对应该点指向该点
38         if(G->GraphType==0)
39         {
40             s=(EdgeNode *)malloc(sizeof(EdgeNode));
41             s->next=G->AdjList[end];
42             s->Vertex=start;
43             s->weight=weight;
44             G->AdjList[end]=s;
45         }
46     }
47 }
48
49 void OutList(ListGraph *G)
50 {
51     int i;
52     EdgeNode *s;
53     for(i=1;i<=G->VextexNum;i++)
54     {
55         printf("顶点%d",i);
56         s=G->AdjList[i];
57         while(s)
58         {
59             printf("->%d(%d)",s->Vertex,s->weight);
60             s=s->next;
61         }
62         printf("\n");
63     }
64 }
65 main()
66 {
67     ListGraph G;
68     printf("输入生成图的类型(0.无向图,1.有向图)");
69     scanf("%d",&G.GraphType);
70     printf("输入图的顶点数量和边数量");
71     scanf("%d%d",&G.VextexNum,&G.EdgeNum);
72     printf("输入构成各边的两个顶点及权值:\n");
73     CreateGraph(&G);
74     printf("输出邻接表\n");
75     OutList(&G);
76     return 0;
77 }
时间: 2024-08-27 06:21:46

一步两步学算法之图邻接表实现的相关文章

【算法与数据结构】图 -- 邻接表

/************************************************************************ 边(弧)结点 -------------------------- |adjvex | info | nextarc | -------------------------- adjvex:邻接点域,该点在图中的位置 info :相关信息,比如可以保存从某顶点到该点的权值 nextac:指向下一个与该点有相同邻接点的顶点 顶点结点 ---------

Prime算法求最小生成树 (邻接表)

/* Name: Prime算法求最小生成树 (邻接表) Copyright: Author: 巧若拙 Date: 25/11/14 13:38 Description: 实现了 Prime算法求最小生成树 (邻接表)的普通算法和最小堆优化算法. */ #include<stdio.h> #include<stdlib.h> #define MAX 2000   //最大顶点数量 #define INFINITY 999999   //无穷大 typedef int VertexT

图的两种存储(邻接矩阵和邻接表)和两种遍历(DFS和BFS)

图的表示有很多,形式不固定,我暂时先记录我已经懂了的,能写的两种即大多数人应该都知道的邻接矩阵和邻接表. 邻接矩阵: 这里的邻接矩阵和离散数学说的有一点不同,至少有向图的邻接矩阵不同(离散书上的有向图的邻接矩阵求法到是有点像求任意两点的最短路径的Floyd算法) 以上都是(我现有知识认为的)废话: 重点 : G : 表示图: Nv:表示图的点数: Ne:表示图的边数: 邻接矩阵 即是一个 Nv * Nv 的矩阵,矩阵是用来储存  权值的(如果是带权图且有边的话),如果是无权图的的话,如果两顶点有

网络流三大算法【邻接矩阵+邻接表】POJ1273

网络流的基本概念跟算法原理我是在以下两篇博客里看懂的,写的非常好. http://www.cnblogs.com/ZJUT-jiangnan/p/3632525.html http://www.cnblogs.com/zsboy/archive/2013/01/27/2878810.html 网络流有四种算法, 包括 Edmond-Karp(简称EK), Ford-Fulkerson(简称FF), dinic算法以及SAP算法. 下面我会写出前三种算法的矩阵跟邻接表的形式, 对于第四种以后有必要

数据结构----图(邻接表用法)

1.定义图的结构: 1 #define NUM_MAX 6 2 typedef struct ArcNode{ 3 int adjvex; 4 struct ArcNode * nextArc; 5 }ArcNode; //定义弧结点结构体 6 typedef struct VertexNode{ 7 int data; 8 ArcNode * firstArc; 9 }VertexNode;//定义顶点结构体 10 typedef struct { 11 VertexNode * AdjLis

一步两步学算法之图的广度搜索

bfs利用队列搜索    详细看代码 #define VERTEX_MAX 26 //图的最大定点数 #define MAXVALUE 32767 //最大值 #include "stdio.h" #define QUEUE_MAXSIZE 10 //队列最大容量 typedef struct { char Vertex[VERTEX_MAX]; //保存定点信息的数组 int Edges[VERTEX_MAX][VERTEX_MAX]; //边的权 int IsTrav[VERTEX

一步两步学算法之图的深度搜素

DFS 与BFS 的不同之处 直接采用递归 从一个点的邻点直接向下搜索 而不是一个点的所有邻点 .可以把BFS想成一张网  DFS相当于一条路走到黑走不通再换别的路 DFS比BFS更容易理解 1 void DFSraverse(MatrixGraph *G) 2 { 3 int i; 4 for(i=0;i<G->VertexNum;i++) 5 G->IsTrav[i]=0; 6 printf("深度优先遍历节点"); 7 for(i=0;i<G->Ve

一步两步学算法之哈夫曼编码(最优二叉树)

比较难理解的 都打了备注了 1 #include "stdio.h" 2 #include "stdlib.h" 3 #include "string.h" 4 char alphabet[]={'A','B','C','D'}; 5 typedef struct 6 { 7 int weight; //权值 8 int parent; //父节点序号 9 int left ; 10 int right; 11 }HuffmanTree; 12

一步两步学算法之树的遍历 非递归实现

递归的程序其实我觉得可读性较高  但是执行效率低下 为了做一道PAT的题 去理解了下非递归实现树的遍历 用一个栈来实现 先序遍历 先访问节点 再把节点push进栈 再访问 再push 直到next=NULL 然后pop出一个节点 也就是弹出一个节点 访问它的右边 再弹出 在访问 中序遍历 把左边节点全部push进栈 然后弹出 访问中间 再访问右边  再弹出 一直循环 后序遍历 比较难理解  要入两次栈才能访问 先左边全部入栈  栈顶是左边的元素 此书不能访问 因为右边还没入栈 下面给出先序和后序