关闭

图的邻接表遍历

138人阅读 评论(0) 收藏 举报
分类:
#include <stdio.h>
#include <malloc.h>
#include <conio.h>
#include <string.h>
#define QueueSize 30
typedef struct _vexType{
	int flag;
	int x,y;
	char name[12];
	void *info;
}VexType;

typedef struct _arcType{
	int index;
	int weight;
	struct _arcType *next;
}ArcType;
typedef struct _adjList{
	VexType data;
	ArcType *first;
}AdjList;

typedef struct _ALGraph
{
	int kind;
	int vexNum;
	int arcNum;
	AdjList  *vertice;
}ALGraph;
typedef struct _Queue
{
    int front;
    int rear;
    int count;
    int data[QueueSize];
}Queue;
void InitGraph(ALGraph *g);
void CreatGraph(FILE *fp,ALGraph *g);
int GetIndex(ALGraph *g,char *name);
void InsertArc(AdjList *l,int index,int w);
void DispArc(AdjList *l);
void DFS(ALGraph *G, int i);
void DFSTraverseM(ALGraph *G);
void InitQueue(Queue *Q);
int QueueEmpty(Queue *Q);
int QueueFull(Queue *Q);
void EnQueue(Queue *Q);
void BFS(ALGraph*G, int k);
void BFSTraverseM(ALGraph *G);
void PrintfGraphAL(ALGraph *G);
/*-------------
在文件中写入
形如:
4,5
1,2,A
2,5,B
6,7,C
7,9,D
A B 10
A C 20
A D 30
B D 40
C D 50
-------------*/
int main()
{
	FILE *fp;
	
	ALGraph mygraph;
	InitGraph(&mygraph);
	
	fp=fopen("d:\\graph.txt","r");
	
	CreatGraph(fp,&mygraph);
	PrintfGraphAL(&mygraph);
	printf("深度优先遍历:\n");
    DFSTraverseM(&mygraph);
    printf("广度优先遍历:\n");
    BFSTraverseM(&mygraph);
	return 0;
}

void InitGraph(ALGraph *g)
{
	g->arcNum = 0;
	g->kind = 0;
	g->vertice = NULL;
	g->vexNum = 0;
}
void CreatGraph(FILE *fp,ALGraph *g)
{
	int vexNum,arcNum;
	int i,x,y,w,loc1,loc2;
	char name[12],n1[12],n2[12];
	
	fscanf(fp,"%d,%d",&vexNum,&arcNum);
	g->arcNum = arcNum;
	g->vexNum = vexNum;
	
	g->vertice = (AdjList *)malloc(sizeof(AdjList)*vexNum);
	
	for(i=0;i<vexNum;i++)
	{
		fscanf(fp,"%d,%d,%s",&x,&y,name);
		g->vertice[i].data.x = x;
		g->vertice[i].data.y = y;
		strcpy(g->vertice[i].data.name,name);
		g->vertice[i].first = NULL;
		g->vertice[i].data.flag=0;
	}
	
	for(i=0;i<g->arcNum;i++)
	{
		fscanf(fp,"%s %s %d",n1,n2,&w);
		loc1 = GetIndex(g,n1);
		loc2 = GetIndex(g,n2);
		InsertArc(g->vertice + loc1,loc2,w);
	}
	
	
}

int GetIndex(ALGraph *g,char *name)
{
	int i;
	for(i=0;i<g->vexNum;i++)
	{
		if(strcmp(g->vertice[i].data.name,name) ==0)
			return i;
	}
	return -1;
}


void InsertArc(AdjList *l,int index,int w)
{
	ArcType *p;
	
	p=(ArcType *)malloc(sizeof(ArcType));
	p->index = index;
	p->weight = w;
	p->next = l->first;
	l->first=p;
	
}
void DFS(ALGraph *G, int i)
{
    ArcType *p;
    printf("visit vertex:%s\n", G->vertice [i].data .name );  
    G->vertice[i].data .flag = 1;             
    p = G->vertice [i].first ;     
    while (p)
    {                               
        if (!G->vertice [p->index].data .flag )    
            DFS(G, p->index );      
        p = p->next;                    
    }
}
void DFSTraverseM(ALGraph *G)
{
    int i;
    for (i = 0; i < G->vexNum ; i++)
        G->vertice[i].data .flag = 0;
    for (i = 0; i < G->vexNum ; i++)
        if (!G->vertice[i].data .flag)
            DFS(G, i);
}
void InitQueue(Queue *Q)
{
    Q->front = Q->rear = 0;
    Q->count = 0;
}
int QueueEmpty(Queue *Q)
{
    return Q->count == 0;
}
int QueueFull(Queue *Q)
{
    return Q->count == QueueSize;
}
void EnQueue(Queue *Q, int x)
{
    if (QueueFull(Q))
        printf("Queue overflow");
    else
    {
        Q->count++;
        Q->data[Q->rear] = x;
        Q->rear = (Q->rear + 1) % QueueSize;
    }
}
int DeQueue(Queue *Q)
{
    int temp;
    if (QueueEmpty(Q))
    {
        printf("Queue underflow");
        return NULL;
    }
    else
    {
        temp = Q->data[Q->front];
        Q->count--;
        Q->front = (Q->front + 1) % QueueSize;
        return temp;
    }
}
void BFS(ALGraph*G, int k)
{   
    int i;
    Queue Q;             
    ArcType *p;
    InitQueue(&Q);         
    printf("visit vertex:%s\n", G->vertice [k].data .name);     
    G->vertice[k].data .flag = 1;
    EnQueue(&Q, k);         
    while (!QueueEmpty(&Q))
    {                                  
        i = DeQueue(&Q);                  
        p = G->vertice [i].first;       
        while (p)
        {                              
            if (!G->vertice [p->index ].data .flag )
            {                          
                printf("visit vertex:%s\n", G->vertice [p->index ].data.name );      //访问vj
                G->vertice[p->index ].data .flag = 1;
                EnQueue(&Q, p->index ); 
            }
            p = p->next;                   
        }
    }
}
void BFSTraverseM(ALGraph *G)
{
    int i;
    for (i = 0; i < G->vexNum ; i++)
		G->vertice[i].data .flag = 0;
    for (i = 0; i < G->vexNum ; i++)
        if (!G->vertice[i].data .flag)
            BFS(G, i);
}
void PrintfGraphAL(ALGraph *G)
{
    for (int i = 0; i < G->vexNum ; i++)
    {
        printf("vertex:%s",G->vertice [i].data .name);
        ArcType *p = G->vertice [i].first ;
        while (p)
        {
            printf("→:%d %d", p->index ,p->weight );
            p = p->next;
        }
        printf("\n");
    }
}

0
0
查看评论

图的邻接表表示及其BFS遍历

图的邻接表表示及其BFS遍历有下面这张图: 假设该图为有向图,边的指向均为小序号指向大序号。那么对该图的BFS遍历如下(假设从序号0的节点开始遍历): 遍历结果应为:a b f c g i d e h BFS遍历类似于树的层序遍历,需要用到队列。下面是程序代码:1.队列定义和相关操作文件...
  • ww1473345713
  • ww1473345713
  • 2016-08-09 14:11
  • 330

图的邻接表创建以及遍历

#define max_vertex_num 100 //该图可以为维护最大的结点个数。 typedef struct Arcnode { int adjvex;//该弧所指向的顶点的位置 struct Arcnode *nextarc; char *info; }Arcnode...
  • u011428875
  • u011428875
  • 2013-12-03 15:39
  • 1382

数据结构之图(邻接表存储,DFS和BFS遍历)

以下代码创建的图是无向,无权图,并且使用邻接表表示图。部分代码参考严蔚敏的数据结构。 一:main部分 #include #include using namespace std; struct ArcNode { int adjvex; //该弧所指向的顶点的位...
  • LaoJiu_
  • LaoJiu_
  • 2015-12-23 21:28
  • 7405

图的邻接表和DFS遍历

邻接矩阵和邻接表的对比之前一篇文章我们学习了 图的邻接矩阵和DFS遍历, 邻接矩阵对于图来说是一种很不错的存储结构,但是也有特殊的情况,例如边数很少的时候。此时的邻接矩阵,只有(v0,v1)和(v1, v0)有值,其他都是0或无穷。然而,所以对于邻接矩阵来说,其它的空间都被浪费掉了,图中结点数很少的...
  • jeffleo
  • jeffleo
  • 2016-11-24 21:52
  • 2436

图算法:1、邻接表实现图的深度优先遍历,广度优先遍历

原文网址:http://blog.csdn.net/codeforme/article/details/6036864# ALGraph.h [cpp] view plaincopy #pragma once   #include&#...
  • qingyuanluofeng
  • qingyuanluofeng
  • 2015-11-21 22:16
  • 2298

图的深度优先搜索遍历(邻接表&邻接矩阵,递归&非递归)(C++)

图的深度优先搜索遍历可有递归和迭代两种方法。递归的方式比较容易,每次以当前节点的未被访问的邻接节点为新的出发点去遍历即可,编程的时候注意维护好全局的访问标记以及访问序列即可(可以以引用的方式传递)。非递归(迭代)的方式需要借助栈。从起点开始,先保存栈顶,然后栈顶出栈,并将该节点(初始的时候为起点)的...
  • zhujiahui622
  • zhujiahui622
  • 2016-08-09 14:26
  • 926

图的深度优先遍历递归算法主针对邻接表有向图

以下是源代码: #include using namespace std; #define MAX_VERTEX_NUM 20 typedef int EdgeData; typedef char VertexData; //顶点数据域 typedef struct node { // ...
  • wen942467928
  • wen942467928
  • 2015-08-15 09:00
  • 1130

用vector实现邻接表的建图

一、vector 简介及基本操作: 1、vector是c++中stl库中封装好的容器,常用定义不定长数组来构建无向图或有向图. 2、基本操作: (1)头文件#include. (2)创建vector对象,vector vec; (3)尾部插入数字:vec.push_back(a); (4)使用...
  • bokzmm
  • bokzmm
  • 2016-04-18 19:42
  • 1988

图的深度优先遍历--邻接表实现

这里用邻接表实现图的深度优先遍历,采用递归实现。 #include using namespace std; #define VERTEXNUM 5//结点数 struct edgenode { int to; int weight; // 边的权值 edgen...
  • u010367506
  • u010367506
  • 2014-05-11 00:55
  • 1646

图的邻接表的遍历(DFS(递归,非递归),BFS,拓扑排序)

要求:对有向图进行DFS(深度优先遍历)和BFS(广度优先遍历)。写出深度优先遍历的递归和非递归算法。 代码如下: #include #include #include #include #include #define MAX 100 using namespace std; int ...
  • llwwlql
  • llwwlql
  • 2015-11-03 23:45
  • 2017
    个人资料
    • 访问:2171次
    • 积分:126
    • 等级:
    • 排名:千里之外
    • 原创:11篇
    • 转载:0篇
    • 译文:0篇
    • 评论:0条
    文章分类
    文章存档