图

最新推荐文章于 2023-12-08 19:32:21 发布
最新推荐文章于 2023-12-08 19:32:21 发布
阅读量375 收藏
点赞数
分类专栏： 数据结构 文章标签： 图
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/songsongL/article/details/95166558
版权

文章目录

前言

简单对比一下线性表、树 、图：
在这里插入图片描述
从上图可以看出图结构是很复杂的，研究图结构的一个专门理论工具便是图论。

图的基本概念

图结构：

  • 顶点（Vertex）：图中的数据元素。
  • 边（Edge）：图中连接这些顶点的线。
    一个完整的图结构由顶点集合和边集合组成。
    G = (V，E)
    其中，V表示图中所有顶点的集合，必须为非空。E表示图中所有边的集合，可以为空，此时表示没有边。

有向图与无向图

有向图：在图结构中，边有方向性，这种图便称为有向图。在表示边时，与顶点的顺序有关。
无向图：在图结构中，边没有方向性，这种图便称为无向图。在表示边时，与顶点的顺序无关。

子图

假设有两个图G = (V，E)和G’ = (V’，E’)，如果V’∈V 且 E’∈E，则称G’为G的子图。
注意：只有顶点集合是子集，或者只有边集合是子集的，都不是子图。

无向完全图与有向完全图

无向完全图：如果在一个无向图中，每两个顶点之间都存在一条边（即n(n-1)/2条），这种图结构称为无向完全图。
有向完全图：如果在一个有向图中，每两个顶点之间都存在方向相反的两条边（即**n(n-1)**条），这种图结构称为有向完全图。

权和网

在实际应用中，每条边可以标上带有具体含义的数值，该数值称为该边上的权。
这种带权的图就叫网。

邻接顶点

两个点确定一条边，这两点就是邻接顶点。
有向图稍微复杂一点，两个顶点分为起始顶点和结束顶点（因为有方向）。

返回目录

顶点的度

连接顶点的边的数量称为顶点的度。
有向图稍微复杂一点，根据方向性可分为入度和出度。
入度：箭头指向自己的边的数量。ID(V)。
出度：箭头往外指的边的数量。OD(V)。
D(V)=ID(V)+OD(V)
一般地，所有顶点的度的和加起来除以2等于图的边数：
e = ∑ i = 0 n D ( V   i   ) e=\sum_{i=0}^n D(V~i~) e=i=0∑n​D(V i )

路径和路径长度

路径指图结构中两个顶点之间要走的边，路径上边的数量称为路径长度。
在这里插入图片描述
如图所示，从V5 到 V2 其中一条路径为（V5，V4）、（V4，V2），路径长度为2。

回路或环

第一个顶点和最后一个顶点相同的路径称为回路或环。

简单路径与简单回路

简单路径：在图结构中，如果一条路径上的顶点不重复出现，则称为简单路径。
简单回路：在图结构中，如果除了第一个顶点和最后一个顶点相同，其余各顶点都不重复的回路称为简单回路。

连通、连通图和连通分量----无向图

连通：如果图结构中两个顶点之间有路径，则这两个顶点是连通的。
注意：连通的两个顶点未必是邻接顶点，只要有路径走得通即可。

连通图：如果无向图中 任意 两个顶点都是连通的，那么这个图便称为连通图。
该图的连通分量。
对于一个连通图，其连通分量有且只有一个，那就是该连通图自身。

强连通图和强连通分量----有向图

强连通图：任意两个顶点Vi，Vj，从Vi 到 Vj 和从Vj 到 Vi 都存在路径，那么这个图便称为强连通图。
强连通分量：有向图的极大强连通子图称为该图的强连通分量。
对于一个强连通图，其强连通分量有且只有一个，那就是该强连通图自身。

返回目录

  • 图的存储结构

    • 邻接矩阵

      采用二维数组的形式保存顶点之间的关系。该数组称为邻接矩阵。
      除了一个用于存储邻接矩阵的二维数组外，还需要用一个一维数组来存储顶点信息。
      无权值：
      ![A[i][j]=](https://img-blog.csdnimg.cn/20190710091911355.png
      有权值：
      在这里插入图片描述
      对于无向图，其邻接矩阵左下角和右上角是对称的。

    • 邻接表

      对图中每个顶点Vi建立一个单链表，把与Vi的邻接点放在这个链中。Vi存在头结点中，其余结点存放邻接点边的信息。
      这样邻接表便由两部分组成：表头结点表和边表。
      表头结点表：由所有头结点顺序存储，以便可以随机访问任意顶点的边表。结点包括两个域，数据域，存放顶点名。指针域，指向第一个结点（第一个邻接点）。
      边表：结点包括三个域。邻接点域，存放该邻接点在图中的位置。数据域，存放权值。指针域，指向下一邻接点。
      在这里插入图片描述
      在这里插入图片描述

    • 邻接矩阵与邻接表的比较

    在这里插入图片描述 返回目录

图的操作

  • 采用邻接矩阵表示法

    由上面图的基本概念可知，创建图与网的区别就是增加一个权值。
    创建有向无向的区别就是无向可以默认生成 对称信息，有向 来与回 不同步。

    • 初始化

    typedef struct MNode{
	vertexType vertex[MVNum];	//存储顶点 
	arcType Arc[MVNum][MVNum];	//邻接矩阵，存储边 
	int vexnum,arcnum;
   	GraphKind kind;				//图的种类，有向无向等 
}GraphNode,*Graph;

    • 创建无向图

    void CreateUDG(Graph G)			//创建无向图 
{
	int num=0,					//控制输入顶点数 
		pos1,pos2,				//确认顶点位置 
		i,j;
	char a,
		 b,
		 ch;					//顶点 
    for(i = 0;i<MVNum;i++){ 	//初始化弧
        for(j = 0;j<MVNum;j++){
            G->Arc[i][j] = 0;
        }
    }
    G->kind = UDG; 				//图的类型为无向图 

    printf("请输入顶点(不超过10个，以#结束):\n");
    cin>>ch;
    while(ch!='#' && num <10){
        G->vertex[num] = ch;
        cin>>ch;
        num++;
    }
    G->vexnum = num;  			//顶点个数

    cout<<"请输入对应的弧（ab与ba是一样的边），以##结束"<<endl;
    cin>>a>>b;
    while(a!='#' && b!='#'){
        cout<<a<<"-"<<b<<endl;
        FindPos(G,a,b,pos1,pos2);
        printf("位置a:%d,位置b:%d\n",pos1,pos2);
        if(pos1!= -1 && pos2!= -1){  //忽略不存在的顶点
            G->Arc[pos1][pos2] = 1;
            G->Arc[pos2][pos1] = 1;
            G->arcnum++;
        }
        cin>>a>>b;
    }
}

    • 创建无向网

    void CreateUDN(Graph G)			//创建无向网
{
	int num=0,					//控制输入顶点数 
		pos1,pos2,				//确认顶点位置 
		i,j,
		weight;					//权值 
	char a,
		 b,
		 ch;					//顶点 
		 
	for(i = 0;i<MVNum; i++){ //初始化弧
        for(j = 0;j<MVNum; j++){
            G->Arc[i][j] = MAXINT;
        }
    }
    G->kind = UDN; //设置图的类型

    printf("请输入顶点(不超过10个，以#结束):\n");
    cin>>ch;
    while(ch!='#' && num <10){
        G->vertex[num] = ch;
        scanf("%c",&ch);
        num++;
    }
    G->vexnum = num;  //顶点个数

    cout<<"请输入对应的弧（ab与ba是一样的边）和权值，以###结束"<<endl;
    cin>>a>>b>>weight;
    while(a!='#' && b!='#'){
        cout<<a<<"-"<<b<<":"<<weight<<endl;
        FindPos(G,a,b,pos1,pos2);
        printf("位置a:%d,位置b:%d\n",pos1,pos2);
        if(pos1!= -1 && pos2!= -1){ 		 //忽略不存在的顶点
            G->Arc[pos1][pos2] = weight;
            G->Arc[pos2][pos1] = weight;
            G->arcnum++;
        }
        cin>>a>>b>>weight;
    }
}

    • 创建有向图

    void CreateDG(Graph G)			//创建有向图 
{
	int num=0,					//控制输入顶点数 
		pos1,pos2,				//确认顶点位置 
		i,j;
	char a,
		 b,
		 ch;					//顶点 
	for(int i=0;i<MVNum;i++){				//初始化 
		for(int j=0;j<MVNum;j++){
			G->Arc[i][j]=0;
		}
	}
	G->kind=DG;								//类型为有向图 
	cout<<"请输入顶点，以#结束"<<endl;
	cin>>ch;
	while(ch!='#'&&num<10){
		G->vertex[num]=ch;
		cin>>ch;
		num++;
	} 
	G->vexnum=num;
	
	cout<<"请输入对应的弧（ab与ba是方向相反的边），以##结束"<<endl;
	cin>>a>>b;
	while(a!='#'&&b!='#'){
		cout<<a<<"->"<<b<<endl;
		FindPos(G,a,b,pos1,pos2);
		cout<<"位置a："<<pos1<<"位置b："<<pos2<<endl;
		if(pos1!=-1&&pos2!=-1){
			G->Arc[pos1][pos2]=1;
			G->arcnum++;
		}
		cin>>a>>b;			
	}
}

    • 创建有向网

    void CreateDN(Graph G)			//创建有向网 
{
	int num=0,					//控制输入顶点数 
		pos1,pos2,				//确认顶点位置 
		i,j,
		weight;					//权值 
	char a,
		 b,
		 ch;					//顶点 
    for(i = 0;i < MVNum; i++){ 	//初始化弧
        for(j = 0;j<MVNum; j++){
            G->Arc[i][j] = MAXINT;
        }
    }
    G->kind = DN; 				//图的类型为有向网 

    printf("请输入顶点(不超过10个，以#结束):\n");
    cin>>ch;
    while(ch!='#' && num <10){
        G->vertex[num] = ch;
        cin>>ch;
        num++;
    }
    G->vexnum = num;  //顶点个数

    cout<<"请输入对应的弧（ab与ba是方向相反的边）和权值，以###结束"<<endl;
    cin>>a>>b>>weight;
    while(a!='#' && b!='#'){
        cout<<a<<"->"<<b<<":"<<weight<<endl;
        FindPos(G,a,b,pos1,pos2);
        printf("位置a:%d,位置b:%d\n",pos1,pos2);
        if(pos1!= -1 && pos2!= -1){  //忽略不存在的顶点
            G->Arc[pos1][pos2] = weight;
            G->arcnum++;
        }
        cin>>a>>b>>weight;
    }
}

返回目录

  • 采用邻接表表示法

    由上面图的基本概念可知，创建图与网的区别就是增加一个权值。
    创建有向无向的区别就是无向可以默认生成 对称信息，有向 来与回 不同步。

    • 创建无向图

    void CreateUDG(ALGraph &G) {								//采用邻接表表示法，创建无向图G
			
	int i, k;
	
	cout << "请输入总顶点数和总边数："  ;				//输出总顶点数，总边数
	cin >> G.vexnum >> G.arcnum;
	cout << endl;
	
	cout << "请输入顶点：" << endl;
	for (i = 0 ; i < G.vexnum; i++) {					//输入各点，构建表头结点
		cout << "请输入第" << (i + 1) << "个顶点的名称：";
		cin >> G.vertices[i].data;
		G.vertices[i].fristarrc = NULL;                 //初始化表头结点的指针域为NULL
	}
	
	cout << endl;
	cout << "请输入一条边依附的顶点：" <<endl;
	for (k = 0; k < G.arcnum; k++) {
		VerTexType v1, v2;
		int i, j;
		cout << "请输入第" << (k+1) << "条边依附的顶点";
		cin >> v1 >> v2;								//输入一条边依附的两个顶点
		i = LocateVex(G, v1);							//确定v1和v2在G中的位置，
		j = LocateVex(G, v2);							//即顶点在G.vertices(邻接表)中的序号
												
		ArcNode *p1 = new ArcNode;						//生成一个新的边结点*p1
		p1->adjvex = j;									//邻接点序号为j
		p1->nextarc = G.vertices[i].fristarrc;	
		G.vertices[i].fristarrc = p1;					//将新节点*p1插入vi的边表
		  
		ArcNode *p2 = new ArcNode;						//生成另一个对称的新的边结点*p2
        p2->adjvex = i;									//邻接点序号为i
		p2->nextarc = G.vertices[j].fristarrc;	
		G.vertices[j].fristarrc = p2;					//将新结点*p2插入顶点Vj的边表
				
	}
}

    • 创建无向网

    void CreateUDN(ALGraph &G) {							//采用邻接表表示法，创建无向网G
			
	int i, k;
	
	cout << "请输入总顶点数和总边数："  ;				//输出总顶点数，总边数
	cin >> G.vexnum >> G.arcnum;
	cout << endl;
	
	cout << "请输入顶点：" << endl;
	for (i = 0 ; i < G.vexnum; i++) {					//输入各点，构建表头结点
		cout << "请输入第" << (i + 1) << "个顶点的名称：";
		cin >> G.vertices[i].data;
		G.vertices[i].fristarrc = NULL;                 //初始化表头结点的指针域为NULL
	}
	
	cout << endl;
	cout << "请输入一条边依附的顶点,和权值" <<endl;
	for (k = 0; k < G.arcnum; k++) {
		VerTexType v1, v2;
		int i, j,weight;
		cout << "请输入第" << (k+1) << "条边依附的顶点";
		cin >> v1 >> v2>>weight;						//输入一条边依附的两个顶点
		i = LocateVex(G, v1);							//确定v1和v2在G中的位置，
		j = LocateVex(G, v2);							//即顶点在G.vertices(邻接表)中的序号
												
		ArcNode *p1 = new ArcNode;						//生成一个新的边结点*p1
		p1->adjvex = j;	
		p1->info = weight;								//邻接点序号为j
		p1->nextarc = G.vertices[i].fristarrc;	
		G.vertices[i].fristarrc = p1;					//将新节点*p1插入vi的边表
		  
		ArcNode *p2 = new ArcNode;						//生成另一个对称的新的边结点*p2
        p2->adjvex = i;		
		p2->info = weight;								//邻接点序号为i
		p2->nextarc = G.vertices[j].fristarrc;	
		G.vertices[j].fristarrc = p2;					//将新结点*p2插入顶点Vj的边表
				
	}
}

返回目录

  • 图的遍历

    因为图中的任意顶点都可能和其余的顶点邻接。所以必须记下每个已访问过的顶点，避免同一顶点被访问多次。设一个辅助数组 IsRead[MVNum]，初始值为0/false，一旦访问过就置1/true。即 打卡 操作。

    • 深度优先搜索

    • 广度优先搜索

返回目录

  • 邻接矩阵表示法总的代码：

    #include<iostream>
#include<stdio.h> 
#include<stdlib.h>
#include<queue>
#include<math.h> 
using namespace std;


#define MVNum 10//最大顶点数 
#define MAXINT 32768//表示极大值 
typedef enum{DG,DN,UDG,UDN} GraphKind; //有向图、有向网、无向图、无向网 
typedef int arcType;
typedef char vertexType;


#define MAX_SIZE 20

/*定义队列*/
typedef struct QNode{
    int Qarr[MAX_SIZE];
    int tail,head;
    int size;
}QNode,*Queue;

void InitQueue(Queue &Q){
    Q= (QNode *)malloc(sizeof(QNode));
    if(Q){
        Q->size = 0;
        Q->head = 0;
        Q->tail = 0;
    }
}

int isEmpty(Queue Q){
    if(Q->head == Q->tail)
		return 1;
    return 0;
}

int isFull(Queue Q){
    if((Q->tail +1) % MAX_SIZE == Q->head)
		return 1;
    return 0;
}

/*入队列*/
void EnterQueue(Queue Q, int data){
    if(isFull(Q)){
        printf("队列已经满!!\n");
        return;
    }
    Q->Qarr[Q->tail] = data;
    Q->size++;
    Q->tail = (Q->tail +1) % MAX_SIZE;
    return;
}

void OutQueue(Queue Q, int &data){
    if(isEmpty(Q)){
        printf("队列为空!!\n");
        return;
    }
    data= Q->Qarr[Q->head];
    Q->size--;
    Q->head = (Q->head +1) % MAX_SIZE;
    return;
}



typedef struct MNode{
	vertexType vertex[MVNum];	//存储顶点 
	arcType Arc[MVNum][MVNum];	//邻接矩阵，存储边 
	int vexnum,arcnum;
   	GraphKind kind;				//图的种类，有向无向等 
}GraphNode,*Graph;

int IsRead[MVNum];

int Init(Graph &G){
	G=(GraphNode *)malloc(sizeof(GraphNode));
	G->vexnum=0;
	G->arcnum=0;
	if(G) return 1;
	else cout<<"初始化出错！"<<endl;
	return 0;
}

void FindPos(Graph G,char a,char b,int &pos1,int &pos2){//查找位置 
	int i=0;
	pos1=-1;pos2=-1;
	for(int i=0;i<G->vexnum;i++){
		if(G->vertex[i]==a){
			pos1=i;
			continue;
		}
		else if(G->vertex[i]==b){
			pos2=i;
			continue;
		}
	}
}

void CreateDG(Graph G)			//创建有向图 
{
	int num=0,					//控制输入顶点数 
		pos1,pos2,				//确认顶点位置 
		i,j;
	char a,
		 b,
		 ch;					//顶点 
	for(int i=0;i<MVNum;i++){				//初始化 
		for(int j=0;j<MVNum;j++){
			G->Arc[i][j]=0;
		}
	}
	G->kind=DG;								//类型为有向图 
	cout<<"请输入顶点，以#结束"<<endl;
	cin>>ch;
	while(ch!='#'&&num<10){
		G->vertex[num]=ch;
		cin>>ch;
		num++;
	} 
	G->vexnum=num;
	
	cout<<"请输入对应的弧（ab与ba是方向相反的边），以##结束"<<endl;
	cin>>a>>b;
	while(a!='#'&&b!='#'){
		cout<<a<<"->"<<b<<endl;
		FindPos(G,a,b,pos1,pos2);
		cout<<"位置a："<<pos1<<"位置b："<<pos2<<endl;
		if(pos1!=-1&&pos2!=-1){
			G->Arc[pos1][pos2]=1;
			G->arcnum++;
		}
		cin>>a>>b;			
	}
}

void CreateDN(Graph G)			//创建有向网 
{
	int num=0,					//控制输入顶点数 
		pos1,pos2,				//确认顶点位置 
		i,j,
		weight;					//权值 
	char a,
		 b,
		 ch;					//顶点 
    for(i = 0;i < MVNum; i++){ 	//初始化弧
        for(j = 0;j<MVNum; j++){
            G->Arc[i][j] = MAXINT;
        }
    }
    G->kind = DN; 				//图的类型为有向网 

    printf("请输入顶点(不超过10个，以#结束):\n");
    cin>>ch;
    while(ch!='#' && num <10){
        G->vertex[num] = ch;
        cin>>ch;
        num++;
    }
    G->vexnum = num;  //顶点个数

    cout<<"请输入对应的弧（ab与ba是方向相反的边）和权值，以###结束"<<endl;
    cin>>a>>b>>weight;
    while(a!='#' && b!='#'){
        cout<<a<<"->"<<b<<":"<<weight<<endl;
        FindPos(G,a,b,pos1,pos2);
        printf("位置a:%d,位置b:%d\n",pos1,pos2);
        if(pos1!= -1 && pos2!= -1){  //忽略不存在的顶点
            G->Arc[pos1][pos2] = weight;
            G->arcnum++;
        }
        cin>>a>>b>>weight;
    }
}

void CreateUDG(Graph G)			//创建无向图 
{
	int num=0,					//控制输入顶点数 
		pos1,pos2,				//确认顶点位置 
		i,j;
	char a,
		 b,
		 ch;					//顶点 
    for(i = 0;i<MVNum;i++){ 	//初始化弧
        for(j = 0;j<MVNum;j++){
            G->Arc[i][j] = 0;
        }
    }
    G->kind = UDG; 				//图的类型为无向图 

    printf("请输入顶点(不超过10个，以#结束):\n");
    cin>>ch;
    while(ch!='#' && num <10){
        G->vertex[num] = ch;
        cin>>ch;
        num++;
    }
    G->vexnum = num;  			//顶点个数

    cout<<"请输入对应的弧（ab与ba是一样的边），以##结束"<<endl;
    cin>>a>>b;
    while(a!='#' && b!='#'){
        cout<<a<<"-"<<b<<endl;
        FindPos(G,a,b,pos1,pos2);
        printf("位置a:%d,位置b:%d\n",pos1,pos2);
        if(pos1!= -1 && pos2!= -1){  //忽略不存在的顶点
            G->Arc[pos1][pos2] = 1;
            G->Arc[pos2][pos1] = 1;
            G->arcnum++;
        }
        cin>>a>>b;
    }
}

void CreateUDN(Graph G)			//创建无向网
{
	int num=0,					//控制输入顶点数 
		pos1,pos2,				//确认顶点位置 
		i,j,
		weight;					//权值 
	char a,
		 b,
		 ch;					//顶点 
		 
	for(i = 0;i<MVNum; i++){ //初始化弧
        for(j = 0;j<MVNum; j++){
            G->Arc[i][j] = MAXINT;
        }
    }
    G->kind = UDN; //设置图的类型

    printf("请输入顶点(不超过10个，以#结束):\n");
    cin>>ch;
    while(ch!='#' && num <10){
        G->vertex[num] = ch;
        scanf("%c",&ch);
        num++;
    }
    G->vexnum = num;  //顶点个数

    cout<<"请输入对应的弧（ab与ba是一样的边）和权值，以###结束"<<endl;
    cin>>a>>b>>weight;
    while(a!='#' && b!='#'){
        cout<<a<<"-"<<b<<":"<<weight<<endl;
        FindPos(G,a,b,pos1,pos2);
        printf("位置a:%d,位置b:%d\n",pos1,pos2);
        if(pos1!= -1 && pos2!= -1){  //忽略不存在的顶点
            G->Arc[pos1][pos2] = weight;
            G->Arc[pos2][pos1] = weight;
            G->arcnum++;
        }
        cin>>a>>b>>weight;
    }
}

void BuildGraph(Graph G){
	int choose=0;				//选择 
	cout<<"请选择建立图的类型:"<<endl;
	cout<<"1.有向图      2.有向网"<<endl<<"3.无向图      4.无向网"<<endl;
	cin>>choose;
	cout<<endl;
	switch(choose){
		case 1:CreateDG(G);break;
		case 2:CreateDN(G);break;
		case 3:CreateUDG(G);break;
		case 4:CreateUDN(G);break;
		default:cout<<"ERROR";return;
	}
}

void DepthFS(Graph G,int pos){		 /*深度优先搜索for图*/
    int i = 0,j = 0;
    if(IsRead[pos] == 0){
        IsRead[pos] = 1; 			//被访问过，打卡 
        printf("遍历顶点%c\n",G->vertex[pos]);
    }

    for(i = 0;i<G->vexnum;i++){
        if(G->Arc[pos][i] == 1 && IsRead[i] ==0){  //存在弧
            DepthFS(G,i);
        }
    }
}

void DepthFS1(Graph G,int pos){		 /*深度优先搜索for网*/
    int i = 0,j = 0;
    if(IsRead[pos] == 0){
        IsRead[pos] = 1; 			//被访问过，打卡 
        printf("遍历顶点%c\n",G->vertex[pos]);
    }

    for(i = 0;i<G->vexnum;i++){
        if(G->Arc[pos][i] !=INFINITY && IsRead[i] ==0){  //存在弧且未被遍历
            DepthFS1(G,i);
        }
    }
}

/*深度优先搜索*/
void DFS(Graph G){
    if(G->kind == DG || G->kind == UDG){  //图
        DepthFS(G,0);
    }else if(G->kind == DN || G->kind == UDN){ //网
        DepthFS1(G,0);
    }
}

void BFS1(Graph G,int pos){ //广度优先搜索for图
    int i = 0,temp;
    Queue Q;
    InitQueue(Q);
    for(i = 0; i<G->vexnum;i++){  //清零
        IsRead[i] = 0;
    }
    if(IsRead[pos] ==0){
        IsRead[pos] = 1;
        printf("遍历顶点:%c\n",G->vertex[pos]);
    }
    EnterQueue(Q,pos);
    while(!isEmpty(Q)){//当队列不为空
        OutQueue(Q,temp);
        for(i = 0; i< G->vexnum;i++){
            if(G->Arc[temp][i] == 1 && IsRead[i] == 0){
                IsRead[i] = 1;
                printf("遍历顶点:%c\n",G->vertex[i]);
                EnterQueue(Q,i);
            }
        }
    }
    free(Q);
}

void BFS2(Graph G,int pos){ //广度优先搜索for图
    int i = 0,temp;
    Queue Q;
    InitQueue(Q);
    for(i = 0; i <G->vexnum;i++){  //清零
        IsRead[i] = 0;
    }
    if(IsRead[pos] ==0){
        IsRead[pos] = 1;
        printf("遍历顶点:%c\n",G->vertex[pos]);
    }
    EnterQueue(Q,pos);
    while(!isEmpty(Q)){//当队列不为空
        OutQueue(Q,temp);
        for(i = 0; i< G->vexnum;i++){
            if(G->Arc[temp][i] != INFINITY && IsRead[i] == 0){
                IsRead[i] = 1;
                printf("遍历顶点:%c\n",G->vertex[i]);
                EnterQueue(Q,i);
            }
        }
    }
    free(Q);
}

void BFS(Graph G){
    if(G->kind == DG || G->kind == UDG){  		//图
        BFS1(G,0);
    }else if(G->kind == DN || G->kind == UDN){ 	//网
        BFS2(G,0);
    }
}

int main(){
    int i = 0;
    Graph G = NULL;
    Init(G);
    BuildGraph(G);
    for(i = 0; i<MVNum; i++){
        IsRead[i] = 0;  //未被遍历
    }
    printf("\n深度优先搜索:\n");
    DFS(G);
    printf("\n广度优先搜索:\n");
    BFS(G);
    return 0;
}

    创建如图所示的图：
    在这里插入图片描述

  • 邻接表表示法总的代码：

    #include <iostream>
#include<queue>
using namespace std;

#define MVNum 100									    //最大顶点信息
int IsRead[MVNum];

typedef char VerTexType;
typedef int OtherInfo;

   //----------图的邻接表存储表示-----------
typedef struct ArcNode {								//边结点
	int adjvex;											//该边所指向顶点的位置
	struct ArcNode *nextarc;							//指向下一条边的指针
	OtherInfo info;										//和边相关的信息
													
}ArcNode;

typedef struct VNode {
	VerTexType data;									//顶点信息
	ArcNode *fristarrc;							    	//指向第一条依附该顶点的边 
	                                                                                                                                                                                                                                                                
} VNode,AdjList[MVNum];

typedef struct {
	AdjList vertices;									// 邻接表
	int vexnum;                                         //图的当前顶点数
	int arcnum;											//图的当前边数	
}ALGraph;

int LocateVex(ALGraph G,VerTexType v) {
	for (int i = 0; i < G.vexnum; i++) 
		if (G.vertices[i].data == v)
			return i;	      
		return -1;	
}

void CreateUDG(ALGraph &G) {								//采用邻接表表示法，创建无向图G
			
	int i, k;
	
	cout << "请输入总顶点数和总边数："  ;				//输出总顶点数，总边数
	cin >> G.vexnum >> G.arcnum;
	cout << endl;
	
	cout << "请输入顶点：" << endl;
	for (i = 0 ; i < G.vexnum; i++) {					//输入各点，构建表头结点
		cout << "请输入第" << (i + 1) << "个顶点的名称：";
		cin >> G.vertices[i].data;
		G.vertices[i].fristarrc = NULL;                 //初始化表头结点的指针域为NULL
	}
	
	cout << endl;
	cout << "请输入一条边依附的顶点:" <<endl;
	for (k = 0; k < G.arcnum; k++) {
		VerTexType v1, v2;
		int i, j;
		cout << "请输入第" << (k+1) << "条边依附的顶点";
		cin >> v1 >> v2;								//输入一条边依附的两个顶点
		i = LocateVex(G, v1);							//确定v1和v2在G中的位置，
		j = LocateVex(G, v2);							//即顶点在G.vertices(邻接表)中的序号
												
		ArcNode *p1 = new ArcNode;						//生成一个新的边结点*p1
		p1->adjvex = j;									//邻接点序号为j
		p1->nextarc = G.vertices[i].fristarrc;	
		G.vertices[i].fristarrc = p1;					//将新节点*p1插入vi的边表
		  
		ArcNode *p2 = new ArcNode;						//生成另一个对称的新的边结点*p2
        p2->adjvex = i;									//邻接点序号为i
		p2->nextarc = G.vertices[j].fristarrc;	
		G.vertices[j].fristarrc = p2;					//将新结点*p2插入顶点Vj的边表
				
	}
}

void CreateUDN(ALGraph &G) {							//采用邻接表表示法，创建无向网G
			
	int i, k;
	
	cout << "请输入总顶点数和总边数："  ;				//输出总顶点数，总边数
	cin >> G.vexnum >> G.arcnum;
	cout << endl;
	
	cout << "请输入顶点：" << endl;
	for (i = 0 ; i < G.vexnum; i++) {					//输入各点，构建表头结点
		cout << "请输入第" << (i + 1) << "个顶点的名称：";
		cin >> G.vertices[i].data;
		G.vertices[i].fristarrc = NULL;                 //初始化表头结点的指针域为NULL
	}
	
	cout << endl;
	cout << "请输入一条边依附的顶点,和权值" <<endl;
	for (k = 0; k < G.arcnum; k++) {
		VerTexType v1, v2;
		int i, j,weight;
		cout << "请输入第" << (k+1) << "条边依附的顶点";
		cin >> v1 >> v2>>weight;						//输入一条边依附的两个顶点
		i = LocateVex(G, v1);							//确定v1和v2在G中的位置，
		j = LocateVex(G, v2);							//即顶点在G.vertices(邻接表)中的序号
												
		ArcNode *p1 = new ArcNode;						//生成一个新的边结点*p1
		p1->adjvex = j;	
		p1->info = weight;								//邻接点序号为j
		p1->nextarc = G.vertices[i].fristarrc;	
		G.vertices[i].fristarrc = p1;					//将新节点*p1插入vi的边表
		  
		ArcNode *p2 = new ArcNode;						//生成另一个对称的新的边结点*p2
        p2->adjvex = i;		
		p2->info = weight;								//邻接点序号为i
		p2->nextarc = G.vertices[j].fristarrc;	
		G.vertices[j].fristarrc = p2;					//将新结点*p2插入顶点Vj的边表
				
	}
}

void DepthFS(ALGraph G,int pos){ 		/*深度优先搜索for图*/
	ArcNode *p=NULL;
    int i = 0,j = 0;
    if(IsRead[pos] == 0){
        IsRead[pos] = 1; 				//被访问过，打卡 
        printf("遍历顶点%c\n",G.vertices[pos].data);
        p= G.vertices[pos].fristarrc; //指向依赖该点的边。边又有三个域：邻接点的位置，权重，指向下一条边的指针。 
    }
	 
	while(p!=NULL){
		if(!IsRead[p->adjvex]){
			DepthFS(G,p->adjvex);			
		}						
		p=p->nextarc;
	}
}

void BFS(ALGraph G,int pos){ 		//广度优先搜索for图
    int i = 0,temp;
    ArcNode * p = NULL;
    queue<char>Q;
    
    for(i = 0; i <G.vexnum;i++){ 	 //清零
        IsRead[i] = 0;
    }
    
    if(IsRead[pos] ==0){
        IsRead[pos] = 1;
        printf("遍历顶点:%c\n",G.vertices[pos].data);
    }
    
    Q.push(pos);
    while(!Q.empty()){			//当队列不为空
        temp=Q.front();
        Q.pop();
        p=G.vertices[temp].fristarrc;
        while(p)
        {
            if(!IsRead[p->adjvex])
            {
                IsRead[p->adjvex]=true;
                printf("遍历顶点:%c\n",G.vertices[p->adjvex].data);
                Q.push(p->adjvex);
            }
            p=p->nextarc;
        }
    }
}

int main(){
	ALGraph G;
	CreateUDG(G);
	
	int i;
	cout << endl;
	for (i = 0; i < G.vexnum; i++) {
		VNode temp = G.vertices[i];					 //将G的顶点信息付给temp
		ArcNode *p = temp.fristarrc;				 //将顶点信息temp中的边信息给p
		if ( p ==  NULL){
			cout << G.vertices[i].data;
			cout << endl;
		}
		else {
			cout << temp.data;
			while (p)
			{
				cout << "->";
				cout << p->adjvex;
				p = p->nextarc;

			}
//			if(!p){
//				cout<<"->^";
//			} 
		}
		cout << endl;
	}
	cout<<"深度遍历:"<<endl; 
	DepthFS(G,0);
	cout<<"广度遍历:"<<endl; 
	BFS(G,0); 
	return 0;
}
songsongL
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java图片上查找图片算法
01-21
　屏幕截图，得到图A，(查找的目标图片为图B)； 　遍历图A的像素点，根据图B的尺寸，得到图B四个角映射到图A上的四个点； 　得到的四个点与图B的四个角像素点的值比较。如果四个点一样，执行步骤4；否则，回到...
ThinkphpUploadPic单图片上传+多图片上传
03-27
thinkphp+单图片上传+多图片上传（ThinkphpUploadPic） ##单图片上传：使用修改后的uploadify插件 使用方法： 1、添加/Public/plugins/uploadify文件夹； 2、html：见onePic.html,主要是引入js和css文件，在js...
数据结构-使用邻接矩阵创建无向图
晨钟暮鼓林中径，晚风花间寺中人
12-01 2万+
1.邻接矩阵 邻接矩阵（Adjacency Matrix)是表示顶点之间相邻关系的矩阵。 2.程序分析 W i,j表示边上的权值；∞表示计算机允许的，大于所有边权值的数。 用邻接矩阵表示法表示图，除了用一个存储邻接矩阵的二维数组外，还需要用一个一维数组来存储顶点信息。 //采用邻接矩阵表示法创建无向网 #include <iostream> using namespace std; #define MaxInt 32767 //表示极大值，即∞ #de
【数据结构】采用邻接矩阵表示法创建无向网、无向图、有向图、有向网
jianbiao1483的博客
08-21 8995
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档（∞/权值，对称）2、代码（0/1，对称）（∞/权值，不对称）（0/1，不对称）​​​​​​​。
无向图邻接矩阵的创建
热门推荐
Change_Improve的博客
01-29 2万+
无向图的邻接矩阵：存储方式是利用两个数组来表示图。一个一维数组（Vexs）存储图中顶点信息，另一个二维数组（Edge）存储图中边的信息。 首先创建邻接矩阵的结构体，变量有存放顶点信息的一维数组（Vexs），存放边的信息的二维数组（Edge），当前的顶点数和边数这四个变量，然后创建一个子函数CreateMGraph用来创建无向图的邻接矩阵，在创建一个子函数ShowpGraph用来输出创建的无向邻接...
C数据结构——无向图(邻接矩阵方式) 创建与基本使用
小象的个人博客
08-01 807
【代码】C数据结构——无向图(邻接矩阵方式) 创建与基本使用。
7-1 邻接矩阵表示法创建无向图
最新发布
dwjg123的博客
12-08 352
采用邻接矩阵表示法创建无向图G ，依次输出各顶点的度。
点击图片弹出大图效果交互
08-03
JS 图片 放大 JS放大图片 很好的一个代码.以后还有很多.
python百度图片爬虫
08-10
百度图片爬虫
Android 图片浏览全屏缩放
05-10
高仿现在主流的图片浏览的全屏缩放效果。如QQ好友动态、微信朋友圈。
一起来创建一个无向图吧！
充满好奇的threecat
11-26 5629
前言：         创建图可是遍历的基础呢，虽然写了广度优先遍历（）和深度优先遍历（DFS），但是自己对于创建图这一块还是想再来一遍（once again?），基础也是很重要的。         我们都知道图的储存结构表示有多种：邻接矩...
图：邻接矩阵表示法创建无向图并深度优先搜索遍历
双鱼座boyy的博客
05-16 5931
无向图表示： 代码： #include<iostream> using namespace std; #define pointMax 100 #define MaxInt 32767 struct AMgroup { char VTchart[pointMax]; //顶点表 int AMchart[pointMax][pointMax]; //邻接矩阵 int point, vert; ...
数据结构：采用邻接矩阵法表示法创建无向网
普通大学的普通学生的一些学习记录博客
04-03 697
代码如下 看注释 #include<stdio.h> #include<stdlib.h> #include<string.h> //使用邻接矩阵法创建无向网 #define MAX 100 //最大顶点点数 #define INF 65535 //表示极大值 //邻接矩阵存储结构 typedef struct { char vexs[MAX]; //顶点表 int arc[MAX][MAX]; //邻接矩阵 int numVertex
采用邻接矩阵法创建无向图和有向图
千言万语ROOM
05-24 9567
#include<stdio.h> #include<stack> #include <iostream> #define MAXSIZE 100 #define MaxInt 32767 //表示最大值，即正无穷大 #define MVNum 100 //定义最大顶点数 using namespace std; typedef char VerTexType;//假设顶点数据类型为字符型 typedef int ArcType;//假设边的权值为整型 type.
基于邻接矩阵构造无向图的算法
_考不上研究生不改名的博客
03-13 1279
邻接矩阵是图论中表示图结构的一种常用数据结构，其可以以矩阵的形式明确地表示图中节点之间的连接关系。本篇博客将深入讨论基于邻接矩阵构造无向图的算法，探究其实现思路。邻接矩阵是一个二维数组，通常表示为一个正方形矩阵。对于一个无向图，它的邻接矩阵的大小为n×n，其中n为图中节点的数量。邻接矩阵的元素可以表示节点之间的连接关系，常见的表示方式是使用0和1，其中1代表两个节点之间有连接，而0表示没有连接。基于邻接矩阵构造无向图的算法是使用二维数组来清晰地表示图中节点之间的连接关系。
邻接矩阵存储无向图
qq_48988844的博客
09-14 2829
邻接矩阵的优势： 可以快速判断两个顶点之间是否有边； 方便计算各顶点的度，无向图中：顶点i的度 = 邻接矩阵第i行（列）中的元素和；有向图中：顶点的出度 = 邻接矩阵第i行中的元素和，顶点的入度 = 邻接矩阵第i列中的元素和。 ...
java 邻接矩阵_邻接矩阵无向图(三)之 Java详解
weixin_36418862的博客
02-12 433
邻接矩阵无向图的介绍邻接矩阵无向图是指通过邻接矩阵表示的无向图。上面的图G1包含了"A,B,C,D,E,F,G"共7个顶点，而且包含了"(A,C),(A,D),(A,F),(B,C),(C,D),(E,G),(F,G)"共7条边。由于这是无向图，所以边(A,C)和边(C,A)是同一条边；这里列举边时，是按照字母先后顺序列举的。上图右边的矩阵是G1在内存中的邻接矩阵示意图。A[i][j]=1表示第i...
数据结构（C语言版）——邻接矩阵表示法创建无向网
m0_67929407的博客
11-26 3977
邻接矩阵表示法创建无向网的算法
邻接矩阵创建无向网（C实现）
m0_61395860的博客
03-15 2589
个人是在准备2023计算机的考研，所以在此记录自己的学习成果，由于最近报了平台的C1认证，部分时间用在前端的练习中，数据结构还剩图、查找和排序，一改之前的作风，不在进行说明一些基本概念，直接附可以执行的代码供需要的同学使用。 结构体定义： #include<stdio.h> #include<stdlib.h> #define maxint 32767 #define maxnum 100 #define ok true #define error false typede.
elementui 轮播图图片
09-02
ElementUI 是一款基于 Vue.js 的 UI 组件库，它提供了丰富的组件和工具，其中也包括了轮播图组件。在 ElementUI 中使用轮播图组件需要引入 Carousel、CarouselItem 组件，并在 Carousel 组件中通过 v-for 指令循环渲染图片。 以下是一个简单的示例代码： ```vue <template> <div> <el-carousel :interval="4000"> <el-carousel-item v-for="(item, index) in images" :key="index"> <img :src="item.url" alt="图片" style="width: 100%;"> </el-carousel-item> </el-carousel> </div> </template> <script> export default { data() { return { images: [ { url: '图片1的URL' }, { url: '图片2的URL' }, { url: '图片3的URL' }, // 可以添加更多的图片URL ] }; } }; </script> ``` 你需要将示例代码中的 "图片1的URL"、"图片2的URL"、"图片3的URL" 替换成实际的图片 URL。可以根据需要自定义轮播图的样式和配置项，如 interval 属性控制轮播间隔时间等。 希望这个示例能够帮到你。如果有其他问题，欢迎继续提问！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值