图论算法总结

已于 2022-10-08 21:41:52 修改
阅读量333 收藏 6
点赞数 2
分类专栏： 考研数据结构模板 # 图论 文章标签： 图论 算法 深度优先
于 2022-09-23 19:41:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46503238/article/details/127012744
版权

一、判断无向图是否是一颗树

利用树的特性n个顶点n-1条边,对图进行dfs求出所有的顶点数和边数进行判断

注意:无向图有2n条边,最后要将边数除以2*

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

#define maxn 100

typedef struct ArcNode{
	 int adjvex;
	 int info;//权值
	 struct ArcNode *next; 
}ArcNode;

typedef struct VNode{
	 int data;
	 struct ArcNode *firstarc; 
}VNode;

typedef struct Graph{
	 VNode adjlist[maxn];
	 int n,e;
}Graph; 


void Create(Graph *G){
	 printf("有向图 1 无向图 0: ");
	 int flag=0;
	 scanf("%d",&flag);
	 
	 printf("输入顶点个数 边个数: ");
	 scanf("%d%d",&G->n,&G->e);
	 
	 for(int i=0;i<G->n;i++){
	     printf("请输入第%d个顶点元素值: ",i);
		 fflush(stdin);
		 scanf("%d",&G->adjlist[i].data);
		 G->adjlist[i].firstarc=NULL; 
	 } 
	 
	 int u,v;
	 
	 for(int i=0;i<G->e;i++){
	 	printf("请输入 u   v: ");
		scanf("%d%d",&u,&v);
		ArcNode *p=(ArcNode*)malloc(sizeof(ArcNode));
		p->next=G->adjlist[u].firstarc;
		p->adjvex=v;
		G->adjlist[u].firstarc=p;
		if(flag==0){
			ArcNode *q=(ArcNode*)malloc(sizeof(ArcNode));
			q->next=G->adjlist[v].firstarc;
			q->adjvex=u;
			G->adjlist[v].firstarc=q; 
		} 
	 } 
}

void  Print(Graph *G){
	 printf("**********打印邻接表***********\n");
	 printf("结点: \n");
	 for(int i=0;i<G->n;i++){
	 	   printf("结点编号%d  结点value%d---",i,G->adjlist[i].data);
           ArcNode *p=G->adjlist[i].firstarc;
		   while(p){
		   	printf("%d--->",p->adjvex);
			p=p->next; 
		   } 
		   printf("\n");
	 } 
} 


void DFS(Graph  *G,int v,int  &verNum,int &nodeNum,int vis[]){
	  vis[v]=1;
	  ArcNode *p=G->adjlist[v].firstarc;
	  nodeNum++;
	  while(p!=NULL){
	  	 verNum++;
		   if(!vis[p->adjvex]){
		   	  DFS(G,p->adjvex,verNum,nodeNum,vis);
		   } 
		   p=p->next; 
	  } 
} 


bool IsTree(Graph *G){
	int vis[maxn];
	for(int i=0;i<G->n;i++){
		vis[i]=0; 
	} 
	int verNum=0,nodeNum=0;
	DFS(G,0,verNum,nodeNum,vis);
	if(nodeNum==G->n&&nodeNum-1==verNum/2)return true;
	
	return false; 
} 

int main()
{   


     Graph *G=(Graph*)malloc(sizeof(Graph));
	 Create(G);
	 Print(G); 
	 if(IsTree(G))printf("是一颗树");
	 else printf("不是一颗树"); 
     


    return 0;
}

二、判断有向图是否有环

注意是有向图,不然无法用深搜
无向图利用并查集配合拓扑排序

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

#define maxn 100

typedef struct ArcNode{
	 int adjvex;
	 int info;//权值
	 struct ArcNode *next; 
}ArcNode;

typedef struct VNode{
	 int data;
	 struct ArcNode *firstarc; 
}VNode;

typedef struct Graph{
	 VNode adjlist[maxn];
	 int n,e;
}Graph; 


void Create(Graph *G){
	 printf("有向图 1 无向图 0: ");
	 int flag=0;
	 scanf("%d",&flag);
	 
	 printf("输入顶点个数 边个数: ");
	 scanf("%d%d",&G->n,&G->e);
	 
	 for(int i=0;i<G->n;i++){
	     printf("请输入第%d个顶点元素值: ",i);
		 fflush(stdin);
		 scanf("%d",&G->adjlist[i].data);
		 G->adjlist[i].firstarc=NULL; 
	 } 
	 
	 int u,v;
	 
	 for(int i=0;i<G->e;i++){
	 	printf("请输入 u   v: ");
		scanf("%d%d",&u,&v);
		ArcNode *p=(ArcNode*)malloc(sizeof(ArcNode));
		p->next=G->adjlist[u].firstarc;
		p->adjvex=v;
		G->adjlist[u].firstarc=p;
		if(flag==0){
			ArcNode *q=(ArcNode*)malloc(sizeof(ArcNode));
			q->next=G->adjlist[v].firstarc;
			q->adjvex=u;
			G->adjlist[v].firstarc=q; 
		} 
	 } 
}

void  Print(Graph *G){
	 printf("**********打印邻接表***********\n");
	 printf("结点: \n");
	 for(int i=0;i<G->n;i++){
	 	   printf("结点编号%d  结点value=%d---",i,G->adjlist[i].data);
           ArcNode *p=G->adjlist[i].firstarc;
		   while(p){
		   	printf("%d--->",p->adjvex);
			p=p->next; 
		   } 
		   printf("\n");
	 } 
} 


int DFS(Graph  *G,int v,int vis[]){
	  vis[v]=1;
	  ArcNode *p=G->adjlist[v].firstarc;
	  int flag=0; 
	  while(p!=NULL){
		   if(vis[p->adjvex]==1)return 1; //有环 
		   else  flag=DFS(G,p->adjvex,vis);
		   if(flag==1)return 1; 
		   p=p->next; 
	  } 
	  return 0;
} 




int main()
{   


     Graph *G=(Graph*)malloc(sizeof(Graph));
	 Create(G);
	 Print(G); 
	 int vis[maxn];
	 for(int i=0;i<G->n;i++)vis[i]=0; 
	 printf("当前有向图是否有环: %d",DFS(G,0,vis)); 


    return 0;
}

三、利用邻接表进行拓扑排序(卡恩算法)

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

#define maxn 100

typedef struct ArcNode{
	 int adjvex;
	 int info;//权值
	 struct ArcNode *next; 
}ArcNode;

typedef struct VNode{
	 int data;
	 struct ArcNode *firstarc; 
}VNode;

typedef struct Graph{
	 VNode adjlist[maxn];
	 int n,e;
}Graph; 


void Create(Graph *G){
	 printf("有向图 1 无向图 0: ");
	 int flag=0;
	 scanf("%d",&flag);
	 
	 printf("输入顶点个数 边个数: ");
	 scanf("%d%d",&G->n,&G->e);
	 
	 for(int i=0;i<G->n;i++){
	     printf("请输入第%d个顶点元素值: ",i);
		 fflush(stdin);
		 scanf("%d",&G->adjlist[i].data);
		 G->adjlist[i].firstarc=NULL; 
	 } 
	 
	 int u,v;
	 
	 for(int i=0;i<G->e;i++){
	 	printf("请输入 u   v: ");
		scanf("%d%d",&u,&v);
		ArcNode *p=(ArcNode*)malloc(sizeof(ArcNode));
		p->next=G->adjlist[u].firstarc;
		p->adjvex=v;
		G->adjlist[u].firstarc=p;
		if(flag==0){
			ArcNode *q=(ArcNode*)malloc(sizeof(ArcNode));
			q->next=G->adjlist[v].firstarc;
			q->adjvex=u;
			G->adjlist[v].firstarc=q; 
		} 
	 } 
}

void  Print(Graph *G){
	 printf("**********打印邻接表***********\n");
	 printf("结点: \n");
	 for(int i=0;i<G->n;i++){
	 	   printf("结点编号%d  结点value=%d---",i,G->adjlist[i].data);
           ArcNode *p=G->adjlist[i].firstarc;
		   while(p){
		   	printf("%d--->",p->adjvex);
			p=p->next; 
		   } 
		   printf("\n");
	 } 
} 


void  TopSort(Graph *G){
	 int q[maxn]; //队列 
	 int rear=-1,front=-1;
	 int chu[maxn],ru[maxn];
	 for(int i=0;i<G->n;i++){
	 	chu[i]=0,ru[i]=0; 
	 } 
	 //统计出度和入度 
	  for(int i=0;i<G->n;i++){
	  	  ArcNode *p=G->adjlist[i].firstarc;
		  while(p){
		  	 chu[i]++;
			 ru[p->adjvex]++; 
			 p=p->next; 
		  }  
	  }
	  
	//  for(int i=0;i<G->n;i++)printf("%d的入度为%d\n",i,ru[i]);
	//  for(int i=0;i<G->n;i++)printf("%d的出度为%d\n",i,chu[i]);
	  for(int i=0;i<G->n;i++){
	  	if(ru[i]==0)q[++rear]=i;//找出所有入读为0的顶点 
	  }
	  while(front<rear){
	  	  int u=q[++front];
	  	  printf("%d--->",u); 
		  ArcNode *p=G->adjlist[u].firstarc;
		  while(p){
		  	 chu[u]--;
			 ru[p->adjvex]--;
			 if(ru[p->adjvex]==0)q[++rear]=p->adjvex;//入度为0则入队 
			 p=p->next; 
		  } 
	  } 
} 




int main()
{   


     Graph *G=(Graph*)malloc(sizeof(Graph));
	 Create(G);
	 Print(G); 
	 
	 printf("利用卡恩算法拓扑排序如下:\n");
	 TopSort(G); 


    return 0;
}

四、利用DFS进行拓扑排序

先搜到的后记录

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

#define maxn 100

typedef struct ArcNode{
	 int adjvex;
	 int info;//权值
	 struct ArcNode *next; 
}ArcNode;

typedef struct VNode{
	 int data;
	 struct ArcNode *firstarc; 
}VNode;

typedef struct Graph{
	 VNode adjlist[maxn];
	 int n,e;
}Graph; 


void Create(Graph *G){
	 printf("有向图 1 无向图 0: ");
	 int flag=0;
	 scanf("%d",&flag);
	 
	 printf("输入顶点个数 边个数: ");
	 scanf("%d%d",&G->n,&G->e);
	 
	 for(int i=0;i<G->n;i++){
	     printf("请输入第%d个顶点元素值: ",i);
		 fflush(stdin);
		 scanf("%d",&G->adjlist[i].data);
		 G->adjlist[i].firstarc=NULL; 
	 } 
	 
	 int u,v;
	 
	 for(int i=0;i<G->e;i++){
	 	printf("请输入 u   v: ");
		scanf("%d%d",&u,&v);
		ArcNode *p=(ArcNode*)malloc(sizeof(ArcNode));
		p->next=G->adjlist[u].firstarc;
		p->adjvex=v;
		G->adjlist[u].firstarc=p;
		if(flag==0){
			ArcNode *q=(ArcNode*)malloc(sizeof(ArcNode));
			q->next=G->adjlist[v].firstarc;
			q->adjvex=u;
			G->adjlist[v].firstarc=q; 
		} 
	 } 
}

void  Print(Graph *G){
	 printf("**********打印邻接表***********\n");
	 printf("结点: \n");
	 for(int i=0;i<G->n;i++){
	 	   printf("结点编号%d  结点value=%d---",i,G->adjlist[i].data);
           ArcNode *p=G->adjlist[i].firstarc;
		   while(p){
		   	printf("%d--->",p->adjvex);
			p=p->next; 
		   } 
		   printf("\n");
	 } 
} 



void  DFS(Graph *G,int v,int vis[],int ts[],int &time){
	   vis[v]=1;
	   ArcNode* p=G->adjlist[v].firstarc;
	   
	   while(p){
	   	 if(!vis[p->adjvex]){
	   	 	  DFS(G,p->adjvex,vis,ts,time);
			}
			p=p->next; 
	   } 
	   ts[++time]=v; //最先到达,实际上是拓扑序列中最后的节点 
} 

void TopSort(Graph *G){
	int vis[maxn], ts[maxn];
	for(int i=0;i<G->n;i++){
		vis[i]=0,ts[i]=0; 
	} 
	int time=0; 
	for(int i=0;i<G->n;i++){
		if(!vis[i])DFS(G,i,vis,ts,time);
	} 
    for(int i=G->n;i>=1;i--){ // 倒叙遍历即为拓扑序列 
    	 printf("%d-->",ts[i]);
	}
} 


int main()
{   


     Graph *G=(Graph*)malloc(sizeof(Graph));
	 Create(G);
	 Print(G); 
	 
	 printf("利用DFS算法拓扑排序如下:\n");
	 TopSort(G); 


    return 0;
}

五、打印任意u到v的所有路径

利用path数组记录dfs经过的节点信息,如果u==v则打印当前路径,如果求所有路径必须进行回溯

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

#define maxn 100

typedef struct ArcNode{
	 int adjvex;
	 int info;//权值
	 struct ArcNode *next; 
}ArcNode;

typedef struct VNode{
	 int data;
	 struct ArcNode *firstarc; 
}VNode;

typedef struct Graph{
	 VNode adjlist[maxn];
	 int n,e;
}Graph; 


void Create(Graph *G){
	 printf("有向图 1 无向图 0: ");
	 int flag=0;
	 scanf("%d",&flag);
	 
	 printf("输入顶点个数 边个数: ");
	 scanf("%d%d",&G->n,&G->e);
	 
	 for(int i=0;i<G->n;i++){
	     printf("请输入第%d个顶点元素值: ",i);
		 fflush(stdin);
		 scanf("%d",&G->adjlist[i].data);
		 G->adjlist[i].firstarc=NULL; 
	 } 
	 
	 int u,v;
	 
	 for(int i=0;i<G->e;i++){
	 	printf("请输入 u   v: ");
		scanf("%d%d",&u,&v);
		ArcNode *p=(ArcNode*)malloc(sizeof(ArcNode));
		p->next=G->adjlist[u].firstarc;
		p->adjvex=v;
		G->adjlist[u].firstarc=p;
		if(flag==0){
			ArcNode *q=(ArcNode*)malloc(sizeof(ArcNode));
			q->next=G->adjlist[v].firstarc;
			q->adjvex=u;
			G->adjlist[v].firstarc=q; 
		} 
	 } 
}

void  Print(Graph *G){
	 printf("**********打印邻接表***********\n");
	 for(int i=0;i<G->n;i++){
	 	   printf("结点编号%d  结点value=%d---",i,G->adjlist[i].data);
           ArcNode *p=G->adjlist[i].firstarc;
		   while(p){
		   	printf("%d--->",p->adjvex);
			p=p->next; 
		   } 
		   printf("\n");
	 } 
} 


void  DFS(Graph *G,int u,int v,int vis[],int path[],int d){
	 vis[u]=1;
	 path[++d]=u; 
	 vis[u]=1;
	 if(u==v){
	 	for(int i=1;i<=d;i++){
	 		printf("%d--->",path[i]); 
		 } 
		 printf("\n"); 
	 } 
	 ArcNode *p=G->adjlist[u].firstarc;
	 while(p){
	 	 if(!vis[p->adjvex]){
	 	 	  DFS(G,p->adjvex,v,vis,path,d);
		  } 
		  p=p->next; 
	 } 
	 vis[u]=0;//回溯找出所有路径 
	  
} 


void FindAllPath(Graph* G,int u,int v){
	 int vis[maxn],path[maxn];
	 
	 for(int i=0;i<G->n;i++){
	 	vis[i]=0,path[i]=0;
	 } 
	 DFS(G,u,v,vis,path,0);
	 
} 




int main()
{   


     Graph *G=(Graph*)malloc(sizeof(Graph));
	 Create(G);
	 Print(G); 
	 int u,v;
	 printf("请输入u v: "); 
	 scanf("%d%d",&u,&v);
	 printf("所有路径如下:\n");
	 FindAllPath(G,u,v);
	

    return 0;
}

六、Dijkstr迪杰斯特拉(邻接表实现)

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

#define INF 0X7f7f7f7f 

#define maxn 100


typedef struct ArcNode{
	 int adjvex;
	 int info;//权值
	 struct ArcNode *next; 
}ArcNode;

typedef struct VNode{
	 int data;
	 struct ArcNode *firstarc; 
}VNode;

typedef struct Graph{
	 VNode adjlist[maxn];
	 int n,e;
}Graph; 


void Create(Graph *G){
	 printf("有向图 1 无向图 0: ");
	 int flag=0;
	 scanf("%d",&flag);
	 
	 printf("输入顶点个数 边个数: ");
	 scanf("%d%d",&G->n,&G->e);
	 
	 for(int i=0;i<G->n;i++){
	     printf("请输入第%d个顶点元素值: ",i);
		 fflush(stdin);
		 scanf("%d",&G->adjlist[i].data);
		 G->adjlist[i].firstarc=NULL; 
	 } 
	 
	 int u,v,info;
	 
	 for(int i=0;i<G->e;i++){
	 	printf("请输入 u   v 以及结点权值:");
		scanf("%d%d%d",&u,&v,&info);
		
		ArcNode *p=(ArcNode*)malloc(sizeof(ArcNode));
		p->next=G->adjlist[u].firstarc;
		p->adjvex=v;
		p->info=info; 
		G->adjlist[u].firstarc=p;
		if(flag==0){
			ArcNode *q=(ArcNode*)malloc(sizeof(ArcNode));
			q->next=G->adjlist[v].firstarc;
			q->adjvex=u;
			q->info=info; 
			G->adjlist[v].firstarc=q; 
		} 
	 } 
}

void  Print(Graph *G){
	 printf("**********打印邻接表***********\n");
	 for(int i=0;i<G->n;i++){
	 	   printf("结点编号%d  结点value=%d---",i,G->adjlist[i].data);
           ArcNode *p=G->adjlist[i].firstarc;
		   while(p){
		   	printf("%d--权值%d-->",p->adjvex,p->info);
			p=p->next; 
		   } 
		   printf("\n");
	 } 
} 

int  getVal(Graph *G,int u,int v){
	 ArcNode *p=G->adjlist[u].firstarc;
	 while(p!=NULL){
	 	 if(p->adjvex==v)return p->info;
		  p=p->next; 
	 } 
	 
	 return INF;//没有边相连接 
} 

void  DijKstra(Graph *G,int d[],int path[],int st){
	   int  vis[maxn];
	   //初始化 
	   for(int i=0;i<G->n;i++){
	   	   vis[i]=0;
		   path[i]=-1;
		   d[i]=INF; 
	   } 
	   
	   path[st]=-1;
	   d[st]=0; //从u出发
	   
	   for(int i=0;i<G->n-1;i++){ //找到路径和最小的结点 
	   	  int minVal=INF;
		  int u=G->n; 
		  for(int j=0;j<G->n;j++){
		  	 if(!vis[j]&&d[j]<minVal){
		  	 	   minVal=d[j]; 
				   u=j; 
			   } 
		  }
		  vis[u]=1; 
		  
		  for(int j=0;j<G->n;j++){ //更新其他结点 
		  	   int dis=getVal(G,u,j);
			   if(!vis[j]&&d[u]+dis<d[j]){
			   	  d[j]=d[u]+dis;
				  path[j]=u; 
			   } 
		  } 
	   } 
	   
} 

//输出路径 
void  printPath(int path[],int v){
	 if(path[v]==-1)printf("%d ",v);
	 else{
	 	printPath(path,path[v]);//不断向前寻找
	 	printf("%d ",v);
	 } 
} 



int main()
{   


     Graph *G=(Graph*)malloc(sizeof(Graph));
	 Create(G);
	 Print(G); 
	 
	 int d[maxn],path[maxn];
	 
	 printf("输入u v\n");
	 int u,v;
	 scanf("%d%d",&u,&v); 
	 DijKstra(G,d,path,u);
	 
	 printf("到各个顶点的最短路为:\n");
	 
	 for(int i=0;i<G->n;i++){
	 	 printf("%d  ",d[i]); 
	 } 
	 
	 printf("\n");
	 printf("最短路径序列为:\n");//u到v的最短路径序列
	 printPath(path,v); 
	 

    return 0;
}

七、邻接表逆转

原邻接表顶点信息,为逆邻接表边表信息

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

#define INF 0X7f7f7f7f 

#define maxn 100


typedef struct ArcNode{
	 int adjvex;
	 int info;//权值
	 struct ArcNode *next; 
}ArcNode;

typedef struct VNode{
	 int data;
	 struct ArcNode *firstarc; 
}VNode;

typedef struct Graph{
	 VNode adjlist[maxn];
	 int n,e;
}Graph; 


void Create(Graph *G){
	 printf("有向图 1 无向图 0: ");
	 int flag=0;
	 scanf("%d",&flag);
	 
	 printf("输入顶点个数 边个数: ");
	 scanf("%d%d",&G->n,&G->e);
	 
	 for(int i=0;i<G->n;i++){
	     printf("请输入第%d个顶点元素值: ",i);
		 fflush(stdin);
		 scanf("%d",&G->adjlist[i].data);
		 G->adjlist[i].firstarc=NULL; 
	 } 
	 
	 int u,v,info;
	 
	 for(int i=0;i<G->e;i++){
	 	printf("请输入 u   v 以及结点权值:");
		scanf("%d%d%d",&u,&v,&info);
		
		ArcNode *p=(ArcNode*)malloc(sizeof(ArcNode));
		p->next=G->adjlist[u].firstarc;
		p->adjvex=v;
		p->info=info; 
		G->adjlist[u].firstarc=p;
		if(flag==0){
			ArcNode *q=(ArcNode*)malloc(sizeof(ArcNode));
			q->next=G->adjlist[v].firstarc;
			q->adjvex=u;
			q->info=info; 
			G->adjlist[v].firstarc=q; 
		} 
	 } 
}

void  Print(Graph *G){
	 printf("**********打印邻接表***********\n");
	 for(int i=0;i<G->n;i++){
	 	   printf("结点编号%d  结点value=%d---",i,G->adjlist[i].data);
           ArcNode *p=G->adjlist[i].firstarc;
		   while(p){
		   	printf("%d--权值%d-->",p->adjvex,p->info);
			p=p->next; 
		   } 
		   printf("\n");
	 } 
} 


void  ReverseAdjlist(Graph *G,Graph *R){
	 //初始化 顶点个数、边个数 
	 R->n=G->n;
	 R->e=G->e;
	 //初始化顶点表 
	 for(int i=0;i<G->n;i++){
	 	R->adjlist[i].data=G->adjlist[i].data;
	 	R->adjlist[i].firstarc=NULL;
	 } 
	 
	 //邻接表顶点信息成为逆邻接表边表信息 
	 for(int i=0;i<G->n;i++){
	 	ArcNode *p=G->adjlist[i].firstarc;
		 while(p!=NULL){
		 	ArcNode *s=(ArcNode*)malloc(sizeof(ArcNode));
			 s->adjvex=i;
			 s->next=R->adjlist[p->adjvex].firstarc;
			 R->adjlist[p->adjvex].firstarc=s; //头插法 
			 p=p->next; 
		 } 
	 } 
} 


int main()
{   


     Graph *G=(Graph*)malloc(sizeof(Graph));
	 Create(G);
	 Print(G); 
	 Graph *R=(Graph*)malloc(sizeof(Graph));
	 ReverseAdjlist(G,R);
	 Print(R); 
	 

	 

    return 0;
}

八、在无向无权图最短路距离顶点u最短路径长度为k的所有顶点

利用bfs统计 ,如果d[i]刚好为k则输出,不然加入队列

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

#define INF 0X7f7f7f7f 

#define maxn 100


typedef struct ArcNode{
	 int adjvex;
	 int info;//权值
	 struct ArcNode *next; 
}ArcNode;

typedef struct VNode{
	 int data;
	 struct ArcNode *firstarc; 
}VNode;

typedef struct Graph{
	 VNode adjlist[maxn];
	 int n,e;
}Graph; 


void Create(Graph *G){
	 printf("有向图 1 无向图 0: ");
	 int flag=0;
	 scanf("%d",&flag);
	 
	 printf("输入顶点个数 边个数: ");
	 scanf("%d%d",&G->n,&G->e);
	 
	 for(int i=0;i<G->n;i++){
	     printf("请输入第%d个顶点元素值: ",i);
		 fflush(stdin);
		 scanf("%d",&G->adjlist[i].data);
		 G->adjlist[i].firstarc=NULL; 
	 } 
	 
	 int u,v,info;
	 
	 for(int i=0;i<G->e;i++){
	 	printf("请输入 u   v 以及结点权值:");
		scanf("%d%d%d",&u,&v,&info);
		
		ArcNode *p=(ArcNode*)malloc(sizeof(ArcNode));
		p->next=G->adjlist[u].firstarc;
		p->adjvex=v;
		p->info=info; 
		G->adjlist[u].firstarc=p;
		if(flag==0){
			ArcNode *q=(ArcNode*)malloc(sizeof(ArcNode));
			q->next=G->adjlist[v].firstarc;
			q->adjvex=u;
			q->info=info; 
			G->adjlist[v].firstarc=q; 
		} 
	 } 
}

void  Print(Graph *G){
	 printf("**********打印邻接表***********\n");
	 for(int i=0;i<G->n;i++){
	 	   printf("结点编号%d  结点value=%d---",i,G->adjlist[i].data);
           ArcNode *p=G->adjlist[i].firstarc;
		   while(p){
		   	printf("%d--权值%d-->",p->adjvex,p->info);
			p=p->next; 
		   } 
		   printf("\n");
	 } 
} 



void  dis_k(Graph *G,int k,int u){
	int d[G->n];
	for(int i=0;i<G->n;i++)d[i]=-1;
	
	int queue[maxn];
	int rear=-1,front=-1;
	queue[++rear]=u; 
	d[u]=0;
	while(front<rear){
		int v=queue[++front];
		ArcNode *p=G->adjlist[v].firstarc;
		while(p!=NULL){
			if(d[p->adjvex]==-1){
				d[p->adjvex]=d[v]+1;
				if(d[p->adjvex]==k)printf("%d ",p->adjvex);
				else queue[++rear]=p->adjvex; //如果没有超过k则加入队列 
			}
			p=p->next;
		}
	}
} 



int main()
{   


     Graph *G=(Graph*)malloc(sizeof(Graph));
	 Create(G);
	 Print(G); 
	 printf("请输入u和k: ");
	 int u,k;
	 scanf("%d%d",&u,&k);
	 dis_k(G,k,u); 
	 

	 

    return 0;
}

九、求支撑树,保证从v出发的广搜序列和以v为根的支撑树的层次遍历序列相同

利用bfs,只不过在遍历时存放的不是边表,而是树的结点,这样在bfs同时可以保证队列中出入顺序为层次序列顺序,这样达到了层序序列和bfs序列相同的效果

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

#define INF 0X7f7f7f7f 

#define maxn 100


typedef struct ArcNode{
	 int adjvex;
	 int info;//权值
	 struct ArcNode *next; 
}ArcNode;

typedef struct VNode{
	 int data;
	 struct ArcNode *firstarc; 
}VNode;

typedef struct Graph{
	 VNode adjlist[maxn];
	 int n,e;
}Graph; 


struct TNode{
	int val,childnum;
	struct TNode* child[maxnum];
}TNode; 

void Create(Graph *G){
	 printf("有向图 1 无向图 0: ");
	 int flag=0;
	 scanf("%d",&flag);
	 
	 printf("输入顶点个数 边个数: ");
	 scanf("%d%d",&G->n,&G->e);
	 
	 for(int i=0;i<G->n;i++){
	     printf("请输入第%d个顶点元素值: ",i);
		 fflush(stdin);
		 scanf("%d",&G->adjlist[i].data);
		 G->adjlist[i].firstarc=NULL; 
	 } 
	 
	 int u,v,info;
	 
	 for(int i=0;i<G->e;i++){
	 	printf("请输入 u   v 以及结点权值:");
		scanf("%d%d%d",&u,&v,&info);
		
		ArcNode *p=(ArcNode*)malloc(sizeof(ArcNode));
		p->next=G->adjlist[u].firstarc;
		p->adjvex=v;
		p->info=info; 
		G->adjlist[u].firstarc=p;
		if(flag==0){
			ArcNode *q=(ArcNode*)malloc(sizeof(ArcNode));
			q->next=G->adjlist[v].firstarc;
			q->adjvex=u;
			q->info=info; 
			G->adjlist[v].firstarc=q; 
		} 
	 } 
}

void  Print(Graph *G){
	 printf("**********打印邻接表***********\n");
	 for(int i=0;i<G->n;i++){
	 	   printf("结点编号%d  结点value=%d---",i,G->adjlist[i].data);
           ArcNode *p=G->adjlist[i].firstarc;
		   while(p){
		   	printf("%d--权值%d-->",p->adjvex,p->info);
			p=p->next; 
		   } 
		   printf("\n");
	 } 
} 


TNode* bfs(Graph *G,int v){
	int vis[G->n];
	for(int i=0;i<G->n;i++)vis[i]=0;
	
	TNode * Qu[G->n];
	int front =-1,rear=-1;
	vis[v]=1;
	TNode *root=(TNode*)malloc(sizeof(TNode));
	root->val=v;
	Qu[++rear]=root; //采用队列存放TNode结点模拟层次遍历 
	while(front<rear){ //进行bfs达到广搜和层次遍历为同一序列的效果 
		TNode *t=Qu[++front];
		t->childnum=0;
		ArcNode *p=G->adjlist[t->val].firstarc;
		while(p!=NULL){
			if(vis[p->adjvex]==0){
				TNode* s=(TNode*)malloc(sizeof(TNode));
				s->val=p->adjvex;
				t->childnum[t->childnum++]=s;
				Qu[++rear]=s;
				vis[p->adjvex]=1;
			}
			p=p->next;
		}
	}
	return root;
}

十、树的直径问题

从任意顶点出发搜索到直径一端a,再从a搜到另一端b
原理是从任意顶点出发所搜最远的距离顶点,一定是直径端点,一定顶点一定距离直径两端中一个近一个远

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

#define INF 0X7f7f7f7f 

#define maxn 100


typedef struct ArcNode{
	 int adjvex;
	 int info;//权值
	 struct ArcNode *next; 
}ArcNode;

typedef struct VNode{
	 int data;
	 struct ArcNode *firstarc; 
}VNode;

typedef struct Graph{
	 VNode adjlist[maxn];
	 int n,e;
}Graph; 



void Create(Graph *G){
	 printf("有向图 1 无向图 0: ");
	 int flag=0;
	 scanf("%d",&flag);
	 
	 printf("输入顶点个数 边个数: ");
	 scanf("%d%d",&G->n,&G->e);
	 
	 for(int i=0;i<G->n;i++){
	     printf("请输入第%d个顶点元素值: ",i);
		 fflush(stdin);
		 scanf("%d",&G->adjlist[i].data);
		 G->adjlist[i].firstarc=NULL; 
	 } 
	 
	 int u,v,info;
	 
	 for(int i=0;i<G->e;i++){
	 	printf("请输入 u   v 以及结点权值:");
		scanf("%d%d%d",&u,&v,&info);
		
		ArcNode *p=(ArcNode*)malloc(sizeof(ArcNode));
		p->next=G->adjlist[u].firstarc;
		p->adjvex=v;
		p->info=info; 
		G->adjlist[u].firstarc=p;
		if(flag==0){
			ArcNode *q=(ArcNode*)malloc(sizeof(ArcNode));
			q->next=G->adjlist[v].firstarc;
			q->adjvex=u;
			q->info=info; 
			G->adjlist[v].firstarc=q; 
		} 
	 } 
}

void  Print(Graph *G){
	 printf("**********打印邻接表***********\n");
	 for(int i=0;i<G->n;i++){
	 	   printf("结点编号%d  结点value=%d---",i,G->adjlist[i].data);
           ArcNode *p=G->adjlist[i].firstarc;
		   while(p){
		   	printf("%d--权值%d-->",p->adjvex,p->info);
			p=p->next; 
		   } 
		   printf("\n");
	 } 
} 


int  ShortestPath(Graph *G,int v,int d[]){
	  for(int i=0;i<G->n;i++){
	      d[i]=-1;
	  }	   
	  int Qu[G->n];
	  int front=-1,rear=-1;
	   
	  d[v]=1;
	  Qu[++rear]=v;
	  
	  while(front<rear){
	  	int u=Qu[++front];
		 ArcNode *p=G->adjlist[u].firstarc;
		 while(p!=NULL){
		 	if(d[p->adjvex]==-1){
		 		 d[p->adjvex]=d[u]+1;
		 		 Qu[++rear]=p->adjvex; 
			 } 
			 p=p->next; 
		 }
	  }
	  
	  int max=0;
	  
	  for(int i=0;i<G->n;i++){
	  	 if(d[i]>d[max]) max=i; 
	  	}
	  	printf("\n"); 
	return max; 
} 

int Piameter_Tree(Graph *G){
	int d[G->n];
	int first=ShortestPath(G,0,d);
	printf("直径一端为:%d ",first);
	int last=ShortestPath(G,first,d);
	printf("另一端为: %d",last);
	
	return d[last]; 
}


int  main(){
	
	Graph* G=(Graph*)malloc(sizeof(Graph));
	Create(G);
	
	Print(G);
	 Piameter_Tree(G); 
	
	
	
	
	return 0; 
}

十一、Dijkstra应用偏心距问题

在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>
#include<stdbool.h>
#include<math.h>
#define INF 0X7f7f7f7f 

#define maxn 100

typedef struct ArcNode{
	 int adjvex;
	 int info;
	 struct ArcNode* next; 
}ArcNode;


typedef struct VNode{
	 int data;
	 struct ArcNode *firstarc; 
}VNode; 


typedef struct AGraph{
	VNode adjlist[maxn];
	int n,e; 
}AGraph;


void Create(AGraph *G){
	 printf("有向图 1 无向图 0: ");
	 int flag=0;
	 scanf("%d",&flag);
	 
	 printf("输入顶点个数 边个数: ");
	 scanf("%d%d",&G->n,&G->e);
	 
	 for(int i=0;i<G->n;i++){
	     printf("请输入第%d个顶点元素值: ",i);
		 fflush(stdin);
		 scanf("%d",&G->adjlist[i].data);
		 G->adjlist[i].firstarc=NULL; 
	 } 
	 
	 int u,v,info;
	 
	 for(int i=0;i<G->e;i++){
	 	printf("请输入 u   v 以及结点权值:");
		scanf("%d%d%d",&u,&v,&info);
		
		ArcNode *p=(ArcNode*)malloc(sizeof(ArcNode));
		p->next=G->adjlist[u].firstarc;
		p->adjvex=v;
		p->info=info; 
		G->adjlist[u].firstarc=p;
		if(flag==0){
			ArcNode *q=(ArcNode*)malloc(sizeof(ArcNode));
			q->next=G->adjlist[v].firstarc;
			q->adjvex=u;
			q->info=info; 
			G->adjlist[v].firstarc=q; 
		} 
	 } 
}


void  Print(AGraph *G){
	 printf("**********打印邻接表***********\n");
	 printf("结点: \n");
	 for(int i=0;i<G->n;i++){
	 	   printf("结点编号%d  结点value%d---",i,G->adjlist[i].data);
           ArcNode *p=G->adjlist[i].firstarc;
		   while(p){
		   	printf("%d--->",p->adjvex);
			p=p->next; 
		   } 
		   printf("\n");
	 } 
} 

void Dijkstra(AGraph *G,int v,int A[maxn][maxn]){
	//最短路迪杰斯特拉 
	int vis[G->n],d[G->n];
	for(int i=0;i<G->n;i++){
		vis[i]=0;
		d[i]=INF; 
	} 
	d[v]=0;
	for(int i=0;i<G->n-1;i++){
		
		 int minDis=INF;
		 int u=v; 
		 for(int i=0;i<G->n;i++){
		 	 if(!vis[i]&&d[i]<minDis){
		 	 	  minDis=d[i];
				  u=i; 
			  } 
		 }
		 
		 vis[u]=1;
		 ArcNode* p=G->adjlist[u].firstarc;
		 while(p){
		 	int k=p->adjvex;
			if(!vis[k]&&d[u]+p->info<d[k]){
				d[k]=d[u]+p->info;
			} 
			p=p->next; 
		 } 	
	}
	//记录在二维数组里
	for(int i=0;i<G->n;i++){
		A[v][i]=d[i];
	}
} 


void  FindCenter(AGraph *G){
	int A[maxn][maxn];
	for(int i=0;i<G->n;i++){
		Dijkstra(G,i,A);//求出各个顶点的最短路 
	}
	int ans=INF,center=0; 
	for(int i=0;i<G->n;i++){
		printf("顶点:%d   ",i);
		
		for(int j=0;j<G->n;j++){
			printf("%d ",A[i][j]);
		} 
		printf("\n");
		//求当前顶点i的偏心距
		int dis=0; 
		for(int j=0;j<G->n;j++){
			if(A[i][j]>dis){
				dis=A[i][j]; 
			} 
		} 
		if(dis<ans){
			ans=dis; 
			center=i; 
		} 
	} 
	printf("图的中心为%d,  其偏心距为%d\n",center,ans); 
}


int  main(){
	
	
	AGraph *G=(AGraph*)malloc(sizeof(AGraph));
	Create(G);
	Print(G); 
	FindCenter(G); 
	
	
	return 0; 
}
曼切斯特的流氓
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数学建模——图论经典问题及知识框架总结
weixin_53026957的博客
09-01 3274
在一给定的无向图G = (V, E) 中，(u, v) 代表连接顶点 u 与顶点 v 的边（即），而 w(u, v) 代表此边的权重，若存在 T 为 E 的子集且为无循环图，使得联通所有结点的的 w(T) 最小，则此 T 为 G 的最小生成树。最大流问题，是网络流理论研究的一个基本问题，求网络中一个可行流f*，使其流量v(f)达到最大， 这种流f称为最大流，这个问题称为(网络)最大流问题。最大流问题是一个特殊的线性规划问题，就是在容量网络中，寻找流量最大的可行流。贪心算法，每一步最优，但不能保证全局最优。.
图算法的总结
qq_45716444的博客
10-06 972
图论 图算法 最短路径 拓扑排序 1514. 概率最大的路径 1334. 阈值距离内邻居最少的城市
数据结构之图论
断的博客
07-09 360
数据结构之图论概览
图论中的算法
最新发布
一枚数学专业的小码农的博客
06-07 1610
图论一文全解（吐血详细，内含实现代码）
图论算法汇集
cxylixiaodong的博客
02-01 1025
图的分类 方向：有向图()、无向图<> 边带不带权：带权图（网）、无权图 特殊的图：无向完全图（任意两个顶点都有边）、有向完全图（任意两个顶点都有方向相反的两条弧） 无向连通图（任意两顶点都是连通的） 有向连通图：强连通图(有向图任意两顶点，都存在相对的路径，如v1->v2和v2->v1）； ...
超级实用图论算法总结篇，算法入门必备
11-01
在本篇文章中，我们将深入探讨图论算法的基础概念、重要算法及其应用。 首先，图论的基本元素包括顶点（Vertex）和边（Edge）。顶点代表实体，边则表示这些实体之间的关系。图可以分为有向图（Edges有方向）和无向...
图论算法算法总结.pdf
09-17
图论算法算法总结.pdf
acm图论所有的算法模版
06-09
在ACM图论算法中，图的割点、桥和双连通分量是重要的概念。以下是关于这些知识点的详细解释： 1. **割点（Cut Vertex）**： 割点是指在一个无向图中，如果移除该节点会导致原本连通的图变成不连通或增加连通分量的...
并行图论算法,并行图论算法
02-15
并行图论算法是计算机...总结来说，並行图论算法通过充分利用现代计算资源，解决了传统串行算法在处理大规模图问题时的效率瓶颈。不断的研究和创新将推动这一领域的进一步发展，为解决更多复杂问题提供强有力的支持。
图论算法 —— 图论概述
Alex_McAvoy的博客
05-14 2万+
【概述】 图是计算机中常用的一种存储结构，图论是数学的一个分支，他以图为研究对象，不同情形具有不同的算法。 关于图：点击这里 【图的常见算法】 图的搜索：点击这里 图的遍历：点击这里 AOV 网与拓扑排序：点击这里 AOE 网与关键路径：点击这里 图的连通性：点击这里 Floyd 算法：点击这里 Dijkstra 算法：点击这里 Ford 算法与 SPFA：点击这里 差分...
图论算法dijkstra/dfs/bfs/hp
Aaron.无剑
06-20 785
目录1介绍2 图的基本概念2.1 定义性质2.2 分类3 图的存储方式3.1 链接矩阵3.2 链接表4 图的遍历4.1 dfs4.2 bfs5 dijkstra算法6 动态规划hp7 简单封装一个图类 1介绍 2 图的基本概念 2.1 定义性质 2.2 分类 3 图的存储方式 3.1 链接矩阵 3.2 链接表 4 图的遍历 4.1 dfs 4.2 bfs 5 dijkstra算法 6 动态规划hp 7 简单封装一个图类 ...
数据挖掘--分类算法的优缺点
快乐的鱼儿学敲码
08-19 2836
1决策树（Decision Trees）的优缺点 决策树的优点： 一、           决策树易于理解和解释.人们在通过解释后都有能力去理解决策树所表达的意义。 二、           对于决策树，数据的准备往往是简单或者是不必要的.其他的技术往往要求先把数据一般化，比如去掉多余的或者空白的属性。 三、           能够同时处理数据型和常规型属性。其他的技术往往要求数据属性的
数据挖掘十大经典算法（包括各自优缺点 / 适用数据场景）
热门推荐
昆兰.沃斯 的博客
09-04 15万+
本文主要分析皆来自其他资料，借用较为权威的总结来对我已经学习的这些经典算法做一个极为精简的概述（根据自身经验有一定修改），另外同时附上机器学习实战中作者对各种算法的评价。另外机器学习实战这本书是本人看了这么多书籍或者资料中唯一一本坚持从头看到尾，看完了的书籍，包括其中的代码皆实践运行过，收获颇多，个人认为虽然这本书时间上已经算是老资料了，但其中作者的各种总结和代码的演练都由浅入深（前提还是要有一点...
各种算法对比以及各自的优缺点
方同学的博客
03-07 7607
贝叶斯分类法 优点： 1）所需估计的参数少，对于缺失数据不敏感。 2）有着坚实的数学基础，以及稳定的分类效率。 缺点： 1）假设属性之间相互独立，这往往并不成立。（喜欢吃番茄、鸡蛋，却不喜欢吃番茄炒蛋）。 2）需要知道先验概率。 3）分类决策存在错误率。 决策树 优点： 1）不需要任何领域知识或参数假设。 2）适合高维数据。 3）简单易于理解。 4）短时间内处理大量数据，得到可行且效果较好的结果...
【归纳】图论的各种基本算法的总结
qq_44684599的博客
04-02 3459
图论的题也刷了不少了，但是近期才发现前面的一些dij什么的都忘记怎么写了，甚至分不清楚dij和spfa的区别了…所以想到这里做一些简单图论算法归纳。主要涉及的算法有：Floyd算法，dijkstra算法，spfa算法，prim算法和kruskal（其实这两个就是最小生成树算法）,以及一维,二维的并查集算法（抱歉萌新最近也就学了这些算法大佬们见笑了QAQ）。 欧克！let’s begin ! 首先...
算法：图论问题
ShellDawn的博客
05-27 443
问题A： 给出N个顶点度数，判断是否可图？ 贪心方法尝试构图，时间O(NNlogN) 每次找出度数最大的点，与其后数个点构成边，构成边后，两个顶点度数-1。 但凡有一个顶点不能构成边，则不可图。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值