图的相关知识回顾
提示：身着白衣，心有锦缎
文章目录
- 前言
- 一、图的创建
-
- 邻接矩阵
- 邻接表
- 使用邻接矩阵创建一个图
- 使用邻接表创建一个图
- 十字链表
- 深度广度
-
- 邻接矩阵
- 邻接表深度优先
- 广度优先
-
- 邻接矩阵
- 邻接表
- 迪杰斯特拉
- prim 算法
- 贝尔曼福特
- 弗洛伊德
- 克鲁斯卡尔
- 拓扑排序
- 第二种拓扑
- 汇总
前言
这里我写的不是本人看的话 想来大家也是看不懂我写的什么鬼 这里大家自己根据我之前所写 希望大家自己也写一下 才有用
本节中就图的创建 遍历 几种常见的算法进行 回顾
详情还是请看之前的**图的专题
提示：以下是本篇文章正文内容，下面案例可供参考
一、图的创建
邻接矩阵
首先需要知道图的存储形式分为三种，邻接矩阵，邻接表，十字链表 等 但是主要考察的话主要是邻接矩阵 邻接表
首先一个图 需要点和边 其中点存储在一个一维数组中，边存储在一个二维数组中 便是邻接矩阵 若是边存储在链表中便是邻接表 这里我们写一下存储的结构体
邻接矩阵
typedef struct Graph{
VerTexType vexs[MVNum];//顶点表
ArcType arcs[MVNum][MVNun];//邻接矩阵
int vexnum;//顶点数
int arcnum;//边数
}Graph;
邻接表
图中需要有边 和点的类型 边我们需要重新定义一个结构体，需要带一个指针，带指针的用处是 它需要靠这个指针来寻找下一个边，并且需要带此边的权重 还有就是需要知道此边指向的是那一个结点， 基于此我们写出边的结构
typedef struct Arc{
int info;//存储数据
int NextVex;//存放这个边所指向的点
Arc* next; //存放与这个边相同起点的下一个边的指针
}Arc;
此时我们来看点 点此时需要存储它本来的名字信息，除此之外还有它所连接的出度 所以也就需要一个指针
typedef struct Vex{
char name;//结点的名字
Arc* next;//存储的边的信息
}Vex;
现在有边 有点就可以创建图了
typedef struct Graph{
int arcnum;
int vexnum;
Vex Vertices[MAX];
};
使用邻接矩阵创建一个图
既然前面我们存储方式知道了 自然创建图也就是往里面填数据 首先我们先填点表，点表也就是一个一维数组，将点输入之后就是就可以输入边，但是输入的时候，你并不知道边所对应的点是什么，所以需要先查查找边对应的横竖坐标，找到之后 我们这里存储的无向图，所以也就需要A[i][j]与A[j][i] 都需要填上信息
使用邻接表创建一个图
首先还是先将点表填充，与邻接矩阵中的点表不同是这个点表中也有指针域，点填充之后 下面开始填充边 这里需要知道的起点与终点 我们是将按起点插入哪一个点之后的链表中，拿到起点之后 我们就到点表中找它对应的点在点表中的位置，找到之后 申请一个结点，将此边结点插入对印的链表中 这里建议头插法，
十字链表
通过上面的建立发方式我们知道了，若是找一个结点的出度 之间查找对应的点表即可，若是要查找出度，则需要遍历每一个结点对应的所有链表，所有想到一个策略 不止将结点出度连接 同时在点表中添加一个入度 每一次进来一个边的时候，不仅按照之前那样将边结点按照头插发插入 而且还需将它对印的出度结点也按照头插法插入，
深度广度
邻接矩阵
深度优先就是目前来到这个结点，我们继续沿着这个结点深入，直到这个结点到头了 就看是否它的邻接的是否都遍历过了 若是遍历过 就开始回溯 所以这里可以想到的一个方式就是递归调用 自然就会回溯
void DFS(Graph1* &G,int i){
for(int j=0;j<G.vexnum;j++){
if(visit[i]==false&&G.arcs[i][j]!=0){//此时存在边 且边没有被访问过
visit[i]=true;
cout<<G.vexs[j]<<" ";
DFG(G,j);
}
}
}
邻接表深度优先
同样的道理 先将遍历到这一个边的最深处，然后再回溯 这里我们使用这里写的是进入这个结点之前 ，这个结点已经被访问过 然后我们来到这个结点对应的边 进入while之前先判断这个是否存在边，若是存在则找这个边的出结点是否被访问过，若是没有被访问过则进入 若是被访问过则看此结点连接的下一个几点 若是没有被访问过 则此时将其设置为访问过，并且递归 也就是深入
void DFS(Graph2* &G,int i){
Arc* cur=G.Vertices[i].next;
while(cur){
if(visit[cur->NextVex]==false){
visit[cur->NextVex]=true;
cout<<G.Vertices[cur->NextVex]<<" ";
DFS(G,cur->NextVex);
}
cur=cur->next;
}
}
广度优先
邻接矩阵
之前树的时候 层序遍历就是广度遍历，当时是借助队列来实现的，这里同样我们也是借助栈来实现图的广度优先 每进入一个结点都是将与他相连的结点都放入队列中
这里队列中存放的都是已经访问过的结点，并且再进入队列的时候 我们就访问了
void BFS(Graph1* &G,int i){
if G==NULL;Q.push(i);visit[i]=true;
while(!Q.empty()){
int cur=Q.front();
for(int i=0;i<G.vexnum;i++){
if(G.arcs[cur][i]!=0&&visit[i]==false){
cout<<G.vexs[i]<<" ";
G.visit[i]=true;
Q.push(i);
}
}
Q.pop();
}
}
邻接表
思想是一样的，但是因为存储方式的不同 导致操作起来也不同
queue<int> Q;
void BFS2(Graph2* &G,int i){
Q.push(i);visit[i]=true;
while(!Q.empty()){
int cur=Q.front();//每次从队列取出一个点
Arc* CurNode=G.Vertices[i].next;
while(CurNode){//将这个点所连接的点放入队列中
if(visit[CurNode->NextVex]==fasle){
cout<<G.Vertices[i].name<<" ";
visir[CurNode->NextVex]=true;
Q.push(CurNode->NextVex);
}
CurNode=CurNode->next;
}
Q.pop();
}
}
迪杰斯特拉
迪杰斯特拉是用来求单源最短路径的，也就是一个点到其他点的最短距离是多少，并且不适合有负权的，其中的关键是理解dict[k]+A[k][j]
/*迪杰斯特拉算法*/
void distl(Graph1 *G,int i){
bool visit[G.vexnum]=false;visit[i]=true;
int dict[G.vexnum];
for(int i=0;i<G.vexnum;i++){//初始化dict数组
if(G.arcs[0][i])dict[i]=G.arcs[0][i];
else dict=Max;
}
dict[i]=0;
//以上是对dict以及visit数组的初始化
for(int i=0;i<G.vexs-1;i++){//需要选择n-1次结点
//先从dict 中选择一个最小的 并且没有访问过的
int min=Max;int MinLoc=0;
for(int j=0;j<G.vexnum;j++){
if(dict[j]<min&&visit[j]==false){
min=dict[j];//一定可以找到 因为要进行n-1次才能找到所有的结点
MinLoc=j;
}
}
visit[MinLoc]=true;
//按照这个最小的来更新dict数组
for(int j=0;j<G.vexnum;j++){
if(dict[MinLoc]+G.arcs[MinLoc][j]<dict[j]){
dict[j]=dict[MinLoc]+G.arcs[MinLoc][j];
}
}
}
}
prim 算法
Priｍ算法是为了求最小生成树，为什么写在这里 是因为这两个几乎一样，基本思想是将所有的结点分成两种结点，一种是已经在树中的，一种不在树中的 ，每一次从不在树中的结点中选择一个距离此时树最小的一个结点K加入树中，然后根据这个新加入树中的结点，来更新dict数组 你要理解这两个dict数组的含义是不一样的，此prim中的dict 表示的是非树结点距离树的最短距离，如果dict[j]>arc[j][k] 此时就更新dixt[j]=arc[j][k];
/*Prim算法*/
void distl(Graph1 *G,int i){
bool visit[G.vexnum]=false;visit[i]=true;
int dict[G.vexnum];
for(int i=0;i<G.vexnum;i++){//初始化dict数组
if(G.arcs[0][i])dict[i]=G.arcs[0][i];
else dict=Max;
}
dict[i]=0;
//以上是对dict以及visit数组的初始化
for(int i=0;i<G.vexs-1;i++){//需要选择n-1次结点
//先从dict 中选择一个最小的 并且没有访问过的
int min=Max;int MinLoc=0;
for(int j=0;j<G.vexnum;j++){
if(dict[j]<min&&visit[j]==false){
min=dict[j];//一定可以找到 因为要进行n-1次才能找到所有的结点
MinLoc=j;
}
}
visit[MinLoc]=true;
//按照这个最小的来更新dict数组
for(int j=0;j<G.vexnum;j++){
if(G.arcs[MinLoc][j]<dict[j]){
dict[j]=G.arcs[MinLoc][j];
}
}
}
}
细心的同学可能发现一个问题 就是我没有在dict数组判断的那个语句中加上visited[j]==false 上面一个迪杰斯特拉我也同样的没有加 希望大家自己开动小脑袋 想想什么情况下会出现visit[i]==false 并且更新了dic[j]数值
贝尔曼福特
实不相瞒 这个困惑了我一天 主要是昨天晚上多想了一些 我在想若是迪杰斯特拉不加visit[i]==false 那么我在运行 那么不就是可以处理负权的问题了吗 结果果然和我想的一样 结果我就迷茫了 也问了几个人 结果都不会 服了！！！，那么问题先搁置，基本原理是 逐遍的对图中的每一个遍去迭代计算起始点到其余各个点的最短路径，执行N-1遍，最终得到起始点到各个点之间的最短路径 这里还是理解为深度，开始的时候dict已经处理一次过了，所以还需要n-2次松弛这就是最外层的for 判断所有的此深度下的通过中转结点 j 到达的终点k 是否更好 这个深度最多不过是n-1之前我们初始化的时候已经搞过一次 这里需要n-2 次 就这样蒙吧
弗洛伊德
首先弗洛伊德解决的问题是 任意两点中的距离 并且要求权值不能为负，基本思想是若是两个结点i 与j中存在k 结点使得路径更短，我们就更新dict[i][j]=dict[i][k]+dict[k][i] 数组 并且记录下此时的通过的结点path[i][j]=vec[k];
克鲁斯卡尔
与之前的prim prim 是通过顶点来扩展生成树，每一次都是从距离此时树最小距离的结点中选择一个，，但是克鲁斯卡尔不同，它的思想是，按边来选择， 所以我们需要先将边按照权值大小进行排序，但是按照权值排序，按照原来无论是矩阵存储 或者是邻接表的形式都是不易找此边所连接的结点，所以这里我们使用一个新的结构体 ，还有就是需要对结构体中的变量进行排序 注意一下 排序的方法 判断的时候是看一个边的两个结点是否是属于同一个树，若是同一个名字 直接返回 若是不同名字 则放入树中 并且将树种的名字都改了
int klsker(Graph1* &G){
//先给每一个结点起一个名字 防止形成闭环
int name[vexnum];
for(int i=0;i<G.vexnum;i++){
name[i]=i;
}
//首先对边排序 也就需要一个新的边的结构 因为是结构体排序 也要一个新的排序方式
vector<edge> E;
E.sort(E.begin(),E.end(),cmp);//从小到大排序
int num=0;//记录此时选择了几个边
int sum=0;//记录此时树的最小权值之和
for(int i=0;i<G.vexnum;i++){
if(num==G.vexnum-1) break;
//遍历所有的边 从中选择两个小的
int falg1=name[E[i].from];
int falg2=nane[E[i].to];
//判断这两个边是否是同一个树中的
if(flag1==falg2){//同一个树
continue;
}
else{
num+=1;
sum+=E[i].info;//将后面那个边纳入到树中
for(int j=0;j<G.vexnum;j++){//将E2 子树的名字都修改
if(name[j]==flag2){
name[j]=flag1;
}
}
}
}
return sum;
}
拓扑排序
活动安排 要求不能具有回路
首先我们大概需要知道一下它实现的方式 其实就是两步，从图章选择一个入度为零的结点，然后删除此结点 已经此以此结点为起点的弧 这个时候也就影响了 其他结点的入度 所有此时也就需要修改其他节点的入度，这里通过邻接矩阵的列来寻找那个入弧结点，然后修改结点对应的 count[]数组，若是结点被删除则将其中的count 置为-1；
void tuopu(Graph1* &G){
int count[G.vexnum]={0};
//开始初始化count数组 其中的数值表示结点的入度
for(int i=0;i<G.vexnum;i++){//表示列
for(int j=0;j<G.vexnum;j++){//表示行
if(G.arcs[j][i]!=0){//说明有值
count[i]++;
}
}
}
for(int i=0;i<G.vexnum;i++){//需要选择这么多次
//每一次从中选择一个结点count值为0的结点
for(int j=0;j<G.vexnum;j++){//从count数组中选择一个cont值为零的
if(conut[j]==0){
count[j]=-1;//将其删除
for(int h=0;h<G.vexnum;h++){//删除j这一列中连接的结点的入度
if(G.arcs[h][j]){
count[h]--;
}
}
break;
}
}
if(j==G.vexnum){
cout<<"存在环"<<endl;
}
}
}
第二种拓扑
这种方式的思路就是 首先依然是初始化count 数组 将其放入栈或者队列中， 甚至我想的话 放入向量中也该也可以，统计之后遍历count 数组将其中为零的结点放入栈中 然后将栈顶元素弹出，弹出之后 依然是修改与之关联的count 然后将这次过程中的count 为零的点也放入栈中，所以这种出栈操作应该要执行n 次 若是少于n次栈就空了 说明此时图中必然是存在回路，这方式的优点是每一次不需从中再挑选count 为零的点
void tuopu(Graph1* &G){
int count[G.vexnum]={0};stack<int> S;
//开始初始化count数组 其中的数值表示结点的入度
for(int i=0;i<G.vexnum;i++){//表示列
for(int j=0;j<G.vexnum;j++){//表示行
if(G.arcs[j][i]!=0){//说明有值
count[i]++;
}
}
if(count[i]==0){
S.push(i);
}
}
int num=0;//记录弹出结点的次数
while(!S.empty()){
num++;
int cur=S.top();
S.pop();//将栈顶弹出
count[cur]=-1;//将其删除
for(int i=0;i<G.vexnum;i++){
if(G.arcs[i][cur]) count[i]--;
if(count[i]==0){
S.push(i);
}
}
}
if(num<G.vexnum){
cout<<"此时是有环的存在的";
}
}
若是使用邻接表来操作 其中都不需要改什么 依然栈中存放整数类型便可
汇总
#include