图的简单了解

图(Graph) 型结构

​ 什么是图型结构：由有穷且非空的顶点和顶点之间的边组成的集合

​ 通常表示：G(V,E)，G代表了一个图，V是图中顶点的集合(元素)，E是图中边的集合(元素之间的关系)

无向图：

边用(A,B)方式表示，点到点之间是互通的

在无向图中，任意两个顶点之间都有边，则该图称为无向完全图，则含有n个顶点的无向完全图有n*(n-1)/2条边

有向图：

边用<A,B>方式表示，仅表示A到B点，有向图中的边也称作弧，B是弧头，A是弧尾

在有向图中，任意两个顶点之间都有方向相反的两条弧度，这种图称为有向完全图，则含有n个顶点的有向完全图有n*(n-1)条边

注意：不存在顶点到自身的边，且一条边不重复出现，这种图叫做简单图，数据结构中只研究简单图。

.图中的点多边少称为稀疏图、反之称为称为稠密图，图中的点与点之间的边可以带数据，这些数据称为边的权重，带权重的图称为网

.依附于顶点的边的数量叫做该顶点，有向图中分为出度(从该顶点出发的弧的数量)、入度(指向该顶点的弧的数量)

.路径：V顶点到V1顶点之间经过的边叫做A到B的路径，边的数量称为路径的长度

.第一个顶点到最后一个顶点的路径的都是相同的，这种路径叫做回路或者环

.序列顶点之间不重复出现的路径，叫做简单路径，除了第一个顶点和最后一个顶点，其余顶点不重复出现的回路，称为简单回路

.如果顶点V到顶点V1有路径，则称V和V1是连通的，如果图中任意的顶点之间都是连通的，那么称为连通图

.如果一个图中有n个顶点，至少需要n-1条边才能达到连通图，仅需要n-1条边就形成的连通图叫生成树，如果再配合上权重，代价是最小的叫做最小生成树

图的存储结构：

阾接矩阵：

​ 用一个一维数组来存储n个顶点，用一个n*n二维数组存储边。
​ char V[n] = {A,B,C,D,E,F,G};
​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MfqW60k0-1614677234001)(C:\Users\lenovo\Desktop\图\邻接矩阵.PNG)]

  二维数组中E[i][j]的值为1，则表示V[i],到V[j]有边
  注意：由于不存在自己到自己的边，左对角线上的值为假

  如果存储的是无向图则二维数组中的值沿左对角线对称
  优点：可以方便计算各个顶点的入度和出度
  缺点：当图是稀疏图时，会非常地浪费存储空间

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<string.h>
#include"list_queue.h"

typedef struct Graph
{
	char* v; //顶点
	char* e; //边
	int cnt; //顶点数量
}Graph;

Graph* create_graph(char* str)
{
	//	申请图结构所需要的内存
	Graph* graph = malloc(sizeof(Graph));

	//	计算顶点的数量
	graph->cnt = strlen(str);

	//	申请存储顶点所需要的内存
	graph->v = malloc(graph->cnt);

	//	存储顶点
	strcpy(graph->v,str);

	//	申请存储边所需要的内存
	graph->e = calloc(graph->cnt,graph->cnt);
	return graph;
}

//	添加边
bool adde_graph(Graph* graph,char v1,char v2)
{
	int x = -1,y = -1;
	for(int i=0; i<graph->cnt; i++)
	{
		if(v1 == graph->v[i])
			x = i;
		if(v2 == graph->v[i])
			y = i;
	}
	if(-1 == x || -1 == y) return false;
	
	//	有向图
	// 利用一维数组比表示二维数组(二维数组本质是一维数组)
	graph->e[x*graph->cnt+y] = 1;
	
	//	无向图
	// graph->e[y*graph->cnt+x] = 1;
	return true;
}

void show_graph(Graph* graph)
{
	printf("   ");
	for(int i=0;i<graph->cnt;i++)
	{
		printf("%c ",graph->v[i]);
	}
	printf("\n");
	for(int i=0;i<graph->cnt;i++)
	{
		printf("%c ",graph->v[i]);
		for(int j=0; j<graph->cnt;j++)
		{
			printf(" %hhd",graph->e[i*graph->cnt+j]);
		}
		printf("\n");
	}
}

//	计算顶点的入度
int id_graph(Graph* graph,char v)
{
	for(int y=0; y<graph->cnt;y++)
	{
		if(v == graph->v[y])
		{
			int id = 0;
			for(int x=0;x<graph->cnt;x++)
			{
				id += graph->e[x*graph->cnt+y];
			}
			return id;
		}
	}
	return -1;
}

//	计算顶点的出度
int od_graph(Graph* graph,char v)
{
	for(int x=0;x<graph->cnt;x++)
	{
		if(v == graph->v[x])
		{
			int od=0;
			for(int y=0;y<graph->cnt;y++)
			{
				od += graph->e[x*graph->cnt+y];
			}
			return od;
		}
	}
	return -1;
}

void DFS(Graph* graph,int i,char* vflag)
{
	if(vflag[i]) return;

	printf("%c ",graph->v[i]);
	vflag[i] = 1;

	for(int j=0; j<graph->cnt;j++)
	{
		if(graph->e[i*graph->cnt+j])
		{
			DFS(graph,j,vflag);
		}
	}
}

// 	深度优先遍历 给顶点加上标志位
void DFS_show(Graph* graph)
{
	char vflag[graph->cnt];		//边长数组不能初始化
	memset(vflag,0,graph->cnt);
	
	for(int i=0;i<graph->cnt;i++)
	{
		DFS(graph,i,vflag);
	}
}

//	广度优先遍历
void BFS_show(Graph* graph)
{
	char vflag[graph->cnt];
	memset(vflag,0,graph->cnt);

	ListQueue* queue = create_list_queue();
	for(int i=0;i<graph->cnt;i++)
	{
		if(!vflag[i])
			push_list_queue(queue,i);
		while(!empty_list_queue(queue))
		{
			int j = head_list_queue(queue);
			printf("%c ",graph->v[j]);
			vflag[j] = 1;

			pop_list_queue(queue);
			for(int y=0;y<graph->cnt;y++)
			{
				if(graph->e[j*graph->cnt+y] && !vflag[y])
				{
					push_list_queue(queue,y);
				}
			}
		}
	}
}

int main(int argc,const char* argv[])
{
	char* str = "ABCDEFGHI";
	Graph* graph = create_graph(str);
	adde_graph(graph,'A','B');
	adde_graph(graph,'C','A');
	adde_graph(graph,'B','E');
	adde_graph(graph,'B','D');
	adde_graph(graph,'E','D');
	adde_graph(graph,'E','C');
	adde_graph(graph,'C','G');
	adde_graph(graph,'F','G');
	adde_graph(graph,'F','H');
	adde_graph(graph,'I','F');
	show_graph(graph);
	printf("id = %d\n",id_graph(graph,'G'));
	printf("od = %d\n",od_graph(graph,'A'));
	DFS_show(graph);
	printf("\n");
	BFS_show(graph);
}

阾接表：

边：

​ 顶点下标

​ 下一条边的地址

顶点：

​ 数据

​ 指向第一条边的指针

图：

​ 由顶点组成的成员

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<string.h>

// 边
typedef struct Edge
{
	int index;
	struct Edge* next;
}Edge;

//	创建到下标为index顶点的边
Edge* create_edge(int index)
{
	Edge* edge = malloc(sizeof(Edge));
	edge->index = index;
	edge->next = NULL;
	return edge;
}

//	顶点
typedef struct Vertex
{
	char vertex;
	Edge* first;
}Vertex;

//	图
typedef struct Graph
{
	Vertex* v;	//顶点表
	int cnt;	//顶点的数量
}Graph;

// 创建图
Graph* create_graph(const char* str)
{
	//	申请内存
	Graph* graph = malloc(sizeof(Graph));
	//	计算顶点的数量
	graph->cnt = strlen(str);
	//	申请顶点所需要的内存
	graph->v = malloc(sizeof(Vertex)*graph->cnt);
	//	初始化顶点
	for(int i=0; i<graph->cnt; i++)
	{
		graph->v[i].vertex = str[i];
		graph->v[i].first = NULL;
	}
	return graph;
}

//	添加边
bool adde_graph(Graph* graph,char v1,char v2)
{
	for(int i=0; i<graph->cnt; i++)
	{
		if(v1 == graph->v[i].vertex)
		{
			for(int j=0; j<graph->cnt; j++)
			{
				if(v2 == graph->v[j].vertex)
				{
					//	相当于链表中的头插入
					Edge* edge = create_edge(j);
					edge->next = graph->v[i].first;
					graph->v[i].first = edge;
					return true;
				}
			}
		}
	}
	return false;
}

void show_graph(Graph* graph)
{
	for(int i=0; i<graph->cnt;i++)
	{
		printf("index:%d v:%c ",i,graph->v[i].vertex);
		for(Edge* e = graph->v[i].first; e!=NULL; e=e->next)
		{
			printf("e: %d ",e->index);	
		}
		printf("\n");
	}
}

int main(int argc,const char* argv[])
{
	char* str = "ABCDEF";
	Graph* graph = create_graph(str);
	adde_graph(graph,'A','B');
	adde_graph(graph,'A','C');
	adde_graph(graph,'B','D');
	adde_graph(graph,'C','E');
	adde_graph(graph,'D','C');
	adde_graph(graph,'E','F');
	
	show_graph(graph);
}
注：此代码要结合链表使用