各种图的创建以及广度，深度优先遍历（临接矩阵存储）

#include <stdio.h>
#include <iostream>
#include <limits.h>
#include <queue>

#define INFINTY INT_MAX    				//最大值
#define MaxVertexNum 100				//最大顶点数
using namespace std;
typedef enum{DG,UDG,DN,UDN} GraphKind; 	//图的种类（有向图。无向图，又向网，无向网）
typedef char VertexType;				//顶点类型
typedef int AdjType;					//边的关系类型（对于无权图，用1/0表示是否相邻；
										//	对带权图，则为权值类型）
typedef char InfoType;
typedef struct {
	AdjType adj;
	InfoType* info;						//该弧相关信息的指针
}ArcCell,AdjMatrix[MaxVertexNum][MaxVertexNum]; 		//定义弧和邻接矩阵 

typedef struct {
	VertexType vertex[MaxVertexNum];	//顶点向量
	AdjMatrix arcs;						//邻接矩阵
	int vexnum,arcnum;					//图的当前顶点数和弧数
	GraphKind kind;
    int visited[MaxVertexNum];          //标示每一个顶点是否被訪问过
}MGraph; 				

void CreateGraph(MGraph *G);
int LocateVex(MGraph *G,VertexType v);
void CreateDG(MGraph *G);
void CreateDN(MGraph *G);
void CreateUDG(MGraph *G);
void CreateUDN(MGraph *G);
void CommonInit(MGraph *G);
void display(MGraph *G);
void InsertDGArc(MGraph *G,VertexType v,VertexType w);
void InsertUDGArc(MGraph *G,VertexType v,VertexType w);
void DFSTraver(MGraph *G);
void BFSTraver(MGraph *G);

int main()
{
	MGraph G;
	CreateGraph(&G);
    DFSTraver(&G);
    BFSTraver(&G);
	return 0;
}

//创建图
void CreateGraph(MGraph *G)
{
	printf("please enter the kind of the graph(DG:0,UDG:1,DN:2,UDN:3):");
    scanf("%d",(int *)&(G->kind));

	switch(G->kind) {
		case DG:   CreateDG(G);  break;
        case UDG:  CreateUDG(G); break;
        case DN:   CreateDN(G);  break;
        case UDN:  CreateUDN(G); break;
	}

} 

//求顶点位置函数
int LocateVex(MGraph *G,VertexType v)
{
    int i;
    for(i=0;i<G->vexnum;i++)
    {
        if(G->vertex[i] == v)
            return i;
    }
    return -1;
}

/*
a b
a c
b d
c d
d a
*/
void CommonInit(MGraph *G)
{
	int infoflag;//假设为0，则不含其他信息。

    //1.确定顶点数和弧数
     printf("please enter vexnum , arcnum and is info(1 or 0):");
     scanf("%d%d%d",&(G->vexnum),&(G->arcnum),&infoflag);

     //2.确定各个顶点的值
     printf("the value of each vertex:");
     for(int i=0;i<G->vexnum;i++)
     {
     	//getchar();
     	scanf(" %c",&(G->vertex[i]));
     }

     //3.初始化邻接矩阵
     for (int i = 0; i < G->vexnum; ++i)
     {
         for(int j=0;j< G->vexnum;j++)
         {
            G->arcs[i][j].adj = 0;
            G->arcs[i][j].info = NULL;
         }
     }
}

//插入又向边
void InsertDGArc(MGraph *G,VertexType v,VertexType w)
{
        int i = LocateVex(G,v);
        int j = LocateVex(G,w);

        if(i>=0 && j>=0)
            G->arcs[i][j].adj = 1;
}

//插入无向边
void InsertUDGArc(MGraph *G,VertexType v,VertexType w)
{
        int i = LocateVex(G,v);
        int j = LocateVex(G,w);

        if(i>=0 && j>=0) {
            G->arcs[j][i].adj = 1;
            G->arcs[i][j].adj = 1;
        }
}

//创建有向图
void CreateDG(MGraph *G)
{
	 CommonInit(G);

	 VertexType v1,v2;
     //确定邻接矩阵
     printf("please input %d heads and %d tails:\n",G->arcnum,G->arcnum);
	 for(int k=0; k<G->arcnum; k++)
	 {
	 	scanf(" %c %c",&v1,&v2);
        InsertDGArc(G,v1,v2);
	 }
     display(G);   

}

//创建无向图
void CreateUDG(MGraph *G)
{
	 CommonInit(G);

	 VertexType v1,v2;
     //确定邻接矩阵
     printf("please input %d heads and %d tails:\n",G->arcnum,G->arcnum);
	 for(int k=0; k<G->arcnum; k++)
	 {
	 	scanf(" %c %c",&v1,&v2);
        InsertUDGArc(G,v1,v2);
	 } 

	display(G);
}

//创建又向网
void CreateDN(MGraph *G)
{
	VertexType v1,v2;
	int weight; 

	CommonInit(G);

	//初始化邻接矩阵
	 for (int i = 0; i < G->vexnum; ++i)
	 {
	     for(int j=0;j< G->vexnum;j++)
	        G->arcs[i][j].adj = INFINTY;
	 } 

	 //确定邻接矩阵
	 printf("please input %d heads and %d tails and weights:\n",G->arcnum,G->arcnum);
	 for(int k=0; k<G->arcnum; k++)
	 {
	 	scanf(" %c %c %d",&v1,&v2,&weight);

		int i = LocateVex(G,v1);
	 	int j = LocateVex(G,v2);
	 	if(i>=0 && j>=0)
		{
	 		G->arcs[i][j].adj = weight;
	 	}

	 } 

	display(G);
}

//创建无向网
void CreateUDN(MGraph *G)
{
	VertexType v1,v2;
	int weight; 

	CommonInit(G);

	//初始化邻接矩阵
	 for (int i = 0; i < G->vexnum; ++i)
	 {
	     for(int j=0;j< G->vexnum;j++)
	        G->arcs[i][j].adj = INFINTY;
	 } 

	 //确定邻接矩阵
	 printf("please input %d heads and %d tails and weights:\n",G->arcnum,G->arcnum);
	 for(int k=0; k<G->arcnum; k++)
	 {
	 	scanf(" %c %c %d",&v1,&v2,&weight);

		int i = LocateVex(G,v1);
	 	int j = LocateVex(G,v2);
	 	if(i>=0 && j>=0)
		{
	 		G->arcs[i][j].adj = weight;
	 		G->arcs[j][i].adj = weight;
	 	}

	 } 

	display(G);
}

void display(MGraph *G)
{
    for(int i=0;i<G->vexnum;i++)
    {
        for(int j=0;j<G->vexnum;j++)
        {
            printf("%d ",G->arcs[i][j].adj);
        }
        printf("\n");
    }  

}

void Visit(MGraph *G,int v)
{
    printf("%c ",G->vertex[v]);
}

void DFS(MGraph *G,int v)
{
    Visit(G,v);
    G->visited[v] = 1;

    for(int i=0;i<G->vexnum;i++) {
        if(!(G->visited[i]) && G->arcs[v][i].adj == 1){
        	//cout<<G->visited[i];
            DFS(G,i);
        }

    }
}

//深度优先遍历
void DFSTraver(MGraph *G)
{
    for (int i = 0; i < G->vexnum; i++)
    {
        G->visited[i] = 0;
    }

    printf("DFSTraver:\n");
    for (int i = 0; i < G->vexnum; i++)
    {
        if(!G->visited[i])
        DFS(G,i);
    }

}

//返回节点v的第一个临接顶点
int FirstAdjVertex(MGraph *G,int v)
{
    for (int i = 0; i < G->vexnum; i++)
    {
        if(G->arcs[v][i].adj==1 && i!=v)
            return i;
    }
    return -1;//假设没有，返回-1
}

//返回v相对于w的下一个临接点
int NextAdjVex(MGraph *G,int v,int w)
{
    for (int i = w+1; i < G->vexnum; i++)
    {
        if(G->arcs[v][i].adj==1 && i!=v)
            return i;
    }
    return -1;
}

void BFS(MGraph *G,int v)
{

	int w;
	Visit(G,v);
	G->visited[v] = 1;
	queue<int> q;
	q.push(v);
	while(!q.empty())
	{
		w = q.front();
		q.pop(); //队头元素出队
        while(w!=-1)
        {
            if(!G->visited[w])
            {
                Visit(G,w);
                G->visited[w] = 1;
                q.push(w);
            }
            w = NextAdjVex(G,v,w);
        }
	}
}

//广度度优先遍历
void BFSTraver(MGraph *G)
{
	printf("\nBFSTraver:\n");
	for (int i = 0; i < G->vexnum; i++)
    {
        G->visited[i] = 0;
    }

    for (int i = 0; i < G->vexnum; i++)
    {
        if(!G->visited[i])
        BFS(G,i);
    }
}

watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvaHVvbGFuZ192aXA=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast" >

时间： 2024-10-10 15:11:00

各种图的创建以及广度，深度优先遍历（临接矩阵存储）的相关文章

C++实现图的邻接矩阵的创建以及其深度优先遍历和广度优先遍历

#include<iostream> using namespace std; typedef char vertextype; typedef int edgetype; #define maxvex 100 #define infinity 1000 #include<queue> int visited[100]; class MGraph{ public: vertextype vexs[maxvex]; edgetype arc[maxvex][maxvex]; int

图的广度、深度优先遍历 C语言

以下是老师作为数据结构课的作业的要求,没有什么实际用处和可以探讨和总结的的地方,所以简单代码直接展示. 宽度优先遍历: 1 #include<cstdio> 2 #include<iostream> 3 #include<cstring> 4 using namespace std; 5 6 #define _clr(x, y) memset(x, y, sizeof(x)) 7 #define N 1010 8 9 int head[N], tot; 10 struc

图的深度和广度遍历(邻接矩阵)

这里我采用邻接矩阵的存储方式对图进行遍历 #include <iostream> #include <queue> #define INFINITY 100 #define MAXNODE 100 #define OK 1 using namespace std; typedef char VertexType; int vis[MAXNODE]; typedef struct { int adj; } ArcType; typedef struct { VertexType ve

图的创建和遍历(BFS/DFS)

图的表示方法主要有邻接矩阵和邻接表.其中邻接表最为常用,因此这里便以邻接表为例介绍一下图的创建及遍历方法. 创建图用到的结构有两种:顶点及弧 struct ArcNode { int vertexIndex; //该弧指向的顶点位置 struct ArcNode* next; //指向下一个弧 InfoType info; //该弧的相关信息,如权重等 }; struct Vertex { VertexType data; //顶点信息 ArcNode* firstArc; //指向第一条依附该

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

这里用邻接表实现图的深度优先遍历,采用递归实现. #include<iostream> using namespace std; #define VERTEXNUM 5//结点数 struct edgenode { int to; int weight; // 边的权值 edgenode *next; }; struct vnode { int from; edgenode *first; }; void createGraph(vnode *adjilist, int start, int

数据结构（C实现）------- 图的深度优先遍历

[本文是自己学习所做笔记,欢迎转载,但请注明出处:http://blog.csdn.net/jesson20121020] 算法描述: 假设给定图G的初始状态是所有顶点均未曾访问过,在G中任选一顶点vi为初始的出发点,则深度优先遍历可定义如下: 首先访问出发点vi,并将其标记为已被访问过:然后,依次从vi出发遍历vi的每一个邻接点vj,若vj未曾访问过,则以vj为新的出发点继续进行深度优先遍历,直至图中所有和vi有路径相通的顶点都被访问到为止.因此,若G是连通图,则从初始出发点开始的遍历过程结束

以邻接表作为存储结构的图的深度优先遍历和广度优先遍历（c++版)

一.图的存储用邻接表法存储图,存储结构分为两部分,一部分为存储图的所有顶点的数组,另一部分为挂载在数组的每个元素后面的用来表示顶点的邻接点的链表. 1.存储顶点的结构单元为: class vnode { public: string nodename; bool visted;//进行图的遍历时用于标记图是否被访问过 node *next; vnode() { visted = false; next = NULL; } }; 链表的结构单元为: class node { public: st

图的广度优先遍历和深度优先遍历

图是一种很重要的数据结构,在我们的编程生活中应用极其广泛 #include <iostream> using namespace std; #define INFINITY 32767 #define MAX_VEX 20 //最大顶点个数 #define QUEUE_SIZE (MAX_VEX+1) //队列长度 bool *visited; //访问标志数组 //图的邻接矩阵存储结构 typedef struct { char *vexs; //顶点向量 int arcs[MAX_VEX]

基于邻接表存储的图的深度优先遍历和广度优先遍历

一.深度优先遍历是连通图的一种遍历策略.其基本思想如下: 设x是当前被访问顶点,在对x做过访问标记后,选择一条从x出发的未检测过的边(x,y).若发现顶点y已访问过,则重新选择另一条从x出发的未检测过的边,否则沿边(x,y)到达未曾访问过的y,对y访问并将其标记为已访问过:然后从y开始搜索,直到搜索完从y出发的所有路径,即访问完所有从y出发可达的顶点之后,才回溯到顶点x,并且再选择一条从x出发的未检测过的边.上述过程直至从x出发的所有边都已检测过为止. 例如下图中: 1.从0开始,首先找到0的关