图(Graph)型结构：
什么是图型结构：由有穷且非空的顶点和顶点之间边的集合组成
通常表示： G(V,E) G表示一个图,V是图中顶点集合(元素),E是图中所有边(元素之间的关系)的集合
无向图：
边用(A,B)方式表示，A与B之间互通，边没有指定方向
无向完全图：
在无向图中，任意两个顶点之间都有边，这种叫做无向完全图
含有n个顶点的无向完全图中，共有 n*(n-1)/2 条边
有向图：
边用<A,B>方式表示，仅仅表示从A点到B点的边，有向图中边也叫做弧，A是弧尾，B是弧头
有向完全图：
在有向图中，任意两个顶点之间都有方向相反的两条弧，这种图叫做有向完全图
含有n个顶点的有向完全图中，共有 n*(n-1) 条边
注意：不讨论顶点到自身的边，且不讨论重复的边，这种图统称为简单图，数据结构中只研究简单图
稀疏图：顶点多边少的图，反之称为稠密图
边的权重：图中的边附带有意义的数据，这些数据叫做边的权重，带权重的图也称为网
度：依附于顶点的边的数量称之为该顶点的度，有向图中，度分为出度(从该顶点出发的弧的数量)、入度(指向该顶点的弧的数量)
路径：顶点到顶点之间经过的边叫做路径
路径长度：路径上边的条目数
环：图中某个点通过边最后能绕回该点
回路：专指有向图，从某点出发，最终有弧回到该点，如果某点只有输出或输入，该点没有回路
简单路径：边经过顶点序列中不重复的路径称为简单路径
简单回路：除了第一个顶点和最后一个顶点外，其余顶点不重复的回路称为简单回路
连通：如果顶点V到顶点V1之间有路径，则称V和V1是连通的
连通图：任意顶点之间都是连通的，称之为连通图，如果一个图中有n个顶点则至少需要 n-1 条边才能达到连通图
生成树：顶点数为n，仅需要n-1条边的连通图，称之为生成树，如果给边配上权重，权重和最小的生成树称之为最小生成树
图的遍历：
深度优先遍历(DFS)
对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次
广度优先遍历(BFS)
系统地展开并遍历图中的所有节点，而且每个节点只能访问一次，与队列配合进行
图的存储结构：
邻接矩阵：
char V[n] = {A,B,C,D,E,F,G};
A B C D E F G (弧头)
A [0][1][0][1][0][0][0]
B [0][0][0][1][1][0][0]
C [0][0][0][1][0][1][0]
D [0][0][1][0][0][0][1]
E [0][0][0][0][0][0][1]
F [0][0][0][0][0][0][1]
G [0][0][0][0][0][1][0]
(弧尾)
在二维数组E[i][j]值为1，则表示顶点V[i]到V[j]有边
注意：由于不存在自己到自己的边，左对角线上的值一定为0
如果存储的是无向图则二维数组的值沿对角线对称，可以压缩成一维数组(参考矩阵压缩)
优点：可以方便地计算顶点的出度和入度
缺点：当图是稀疏图时，会非常地浪费存储空间
邻接表：(链式+顺序)
边：
顶点下标
指向下一条边的地址
顶点：
顶点数据
指向第一条边的指针
图：
由顶点组成的数组
顶点数量
优点：节约存储空间，计算出度方便
缺点：计算入度麻烦
十字链表：
是一种专门存储有向图的一种结构
边
弧尾下标
弧头下标
指向弧尾相同的下一条边
指向弧头相同的下一条边
顶点：
顶点数据
指向第一条出度的边
指向第一条入度的边
图：
由顶点组成的数组
顶点数量
优点：节约空间、计算出入度很方便
邻接多重表：
是一种专门存储无向图的一种结构
边：
i j 两个相互依附的顶点的下标
inext 指向下一条依附于i顶点的边
jnext 指向下一条依附于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(const char* str)
{
// 申请邻接矩阵内存
Graph* graph = malloc(sizeof(Graph));
// 计算顶点数量
graph->cnt = strlen(str);
// 申请顶点所需内存
graph->v = malloc(graph->cnt+1);
// 存储顶点
strcpy(graph->v,str);
// 申请存储边所需内存
graph->e = calloc(graph->cnt,graph->cnt);
return graph;
}
// 添加边
bool add_edge(Graph* graph,char v1,char v2)
{
int x = -1, y = -1;
for(int i=0; i<graph->cnt; i++)
{
if(graph->v[i] == v1) x = i;
if(graph->v[i] == v2) 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 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;
}
// 计算顶点的入度
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;
}
// 从第i个顶点开始进行深度优先遍历
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);
vflag[i] = 1;
}
while(!empty_list_queue(queue))
{
int j = front_list_queue(queue);
printf("%c ",graph->v[j]);
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);
vflag[y] = 1;
}
}
}
}
}
int main(int argc,const char* argv[])
{
Graph* graph = create_graph("ABCDEFGX");
add_edge(graph,'A','B');
add_edge(graph,'A','D');
add_edge(graph,'B','D');
add_edge(graph,'B','E');
add_edge(graph,'C','D');
add_edge(graph,'C','F');
add_edge(graph,'D','C');
add_edge(graph,'D','G');
add_edge(graph,'E','G');
add_edge(graph,'F','G');
add_edge(graph,'G','F');
add_edge(graph,'X','E');
show_graph(graph);
DFS_show(graph);
printf("\n");
BFS_show(graph);
}
//邻接表
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include "list_queue.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 add_edge_graph(Graph* graph,char v1,char v2)
{
for(int i=0; i<graph->cnt; i++)
{
if(v1 == graph->v[i].vertex) // v1下标 i
{
for(int j=0; j<graph->cnt; j++)
{
if(v2 == graph->v[j].vertex) // v2下标 j
{
// 创建指向j的边
Edge* edge = create_edge(j);
edge->next = graph->v[i].first;
graph->v[i].first = edge;
return true;
}
}
}
}
return false;
}
// 计算出度
int od_graph(Graph* graph,char v)
{
int od = 0;
for(int i=0; i<graph->cnt; i++)
{
if(v == graph->v[i].vertex)
{
for(Edge* e=graph->v[i].first; e; e=e->next)
{
od++;
}
return od;
}
}
return -1;
}
// 入度
int id_graph(Graph* graph,char v)
{
// 寻找v的下标
for(int i=0; i<graph->cnt; i++)
{
if(v == graph->v[i].vertex)
{
int id = 0;
for(int j=0; j<graph->cnt; j++)
{
for(Edge* e=graph->v[j].first; e; e=e->next)
{
if(e->index == i) id++;
}
}
return id;
}
}
return -1;
}
void _DFS(Graph* graph,int i,char* vflag)
{
if(vflag[i]) return;
printf("%c ",graph->v[i].vertex);
vflag[i] = 1;
for(Edge* e=graph->v[i].first; e; e=e->next)
{
_DFS(graph,e->index,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);
}
printf("\n");
}
// 广度优先
void BFS_show(Graph* graph)
{
ListQueue* queue = create_list_queue();
char vflag[graph->cnt];
memset(vflag,0,graph->cnt);
for(int i=0; i<graph->cnt; i++)
{
if(!vflag[i])
{
push_list_queue(queue,i);
vflag[i] = 1;
}
while(!empty_list_queue(queue))
{
int j = front_list_queue(queue);
printf("%c ",graph->v[j].vertex);
pop_list_queue(queue);
for(Edge* e=graph->v[j].first; e; e=e->next)
{
if(!vflag[e->index])
{
push_list_queue(queue,e->index);
vflag[e->index] = 1;
}
}
}
}
destory_list_queue(queue);
printf("\n");
}
void show_graph(Graph* graph)
{
for(int i=0; i<graph->cnt; i++)
{
printf("index:%d v:%c e:",i,graph->v[i].vertex);
for(Edge* e=graph->v[i].first; e; e=e->next)
{
printf("%c ",graph->v[e->index].vertex);
}
printf(" od:%d id:%d",od_graph(graph,graph->v[i].vertex),
id_graph(graph,graph->v[i].vertex));
printf("\n");
}
}
int main(int argc,const char* argv[])
{
Graph* graph = create_graph("ABCDEFGH");
add_edge_graph(graph,'A','D');
add_edge_graph(graph,'A','B');
add_edge_graph(graph,'B','D');
add_edge_graph(graph,'B','C');
add_edge_graph(graph,'C','D');
add_edge_graph(graph,'D','E');
add_edge_graph(graph,'D','F');
add_edge_graph(graph,'E','G');
add_edge_graph(graph,'G','H');
add_edge_graph(graph,'F','H');
show_graph(graph);
DFS_show(graph);
BFS_show(graph);
}
