图

最新推荐文章于 2024-06-11 11:19:08 发布

hz5034

最新推荐文章于 2024-06-11 11:19:08 发布

阅读量412

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/hz5034/article/details/39457749

本文介绍了几种图的基本表示方法及典型算法实现，包括数组表示法、邻接表、迪杰斯特拉最短路径算法和深度优先搜索算法。通过具体代码示例展示了如何创建图结构并进行遍历操作。

1.数组

#include<iostream>  
#include<queue>  
using namespace std;    
#define MAX_VERTEX_NUM 20    
typedef struct    
{    
    int vexs[MAX_VERTEX_NUM];    
    int arcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM];    
    int vexnum,arcnum;    
}Graph;    
    
int LocateVertex(Graph G,int u)    
{    
    for(int i=0;i<G.vexnum;i++)    
    {    
        if(u==G.vexs[i])return i;    
    }    
}    
    
void CreateGraph(Graph &G)    
{    
    int i,j,k,v1,v2;    
    cin>>G.vexnum>>G.arcnum;    
    for(i=0;i<G.vexnum;i++)cin>>G.vexs[i];    
    for(i=0;i<G.vexnum;i++)    
    {    
        for(j=0;j<G.vexnum;j++)G.arcs[i][j]=0;    
    }    
    for(k=0;k<G.arcnum;k++)    
    {    
        cin>>v1>>v2;    
        i=LocateVertex(G,v1);    
        j=LocateVertex(G,v2);    
        G.arcs[i][j]=1;    
        G.arcs[j][i]=G.arcs[i][j];    
    }    
}    
    
bool visited[MAX_VERTEX_NUM];    
    
void DFS(Graph G,int v)    
{    
    visited[v]=true;    
    cout<<G.vexs[v]<<' ';    
    for(int w=0;w<G.vexnum;w++)    
    {    
        if(G.arcs[v][w]==1&&!visited[w])DFS(G,w);    
    }    
}    
    
void DFSTraverse(Graph G)    
{    
    int v;    
    for(v=0;v<G.vexnum;v++)visited[v]=false;    
    for(v=0;v<G.vexnum;v++)    
    {    
        if(!visited[v])DFS(G,v);    
    }    
}    
  
void BFSTraverse(Graph G)  
{  
    int v,u,w;    
    for(v=0;v<G.vexnum;v++)visited[v]=false;  
    queue<int>q;  
    for(v=0;v<G.vexnum;v++)  
    {  
        if(!visited[v])  
        {  
            visited[v]=true;  
            cout<<G.vexs[v]<<' ';  
            q.push(v);  
            while(!q.empty())  
            {  
                u=q.front();  
                q.pop();  
                for(w=0;w<G.vexnum;w++)  
                {  
                    if(!visited[w]&&G.arcs[u][w]==1)  
                    {  
                        visited[w]=true;  
                        cout<<G.vexs[w]<<' ';  
                        q.push(w);  
                    }  
                }  
            }  
        }  
    }
    cout<<endl;
}  
  
int main()    
{    
    Graph G;    
    CreateGraph(G);    
    DFSTraverse(G);  
    cout<<endl<<"++++++++++++++++++++"<<endl;  
    BFSTraverse(G);  
    return 0;    
}

2.邻接表

#include<iostream>
using namespace std;
#define MAX_VERTEX_NUM 20
typedef struct ArcNode
{
    int adjvex;
    ArcNode *nextarc;
}ArcNode;
typedef struct VNode
{
    int data;
    ArcNode *firstarc;
}VNode,AdjList[MAX_VERTEX_NUM];
typedef struct
{
    AdjList vertices;
    int vexnum,arcnum;
}Graph;

int LocateVertex(Graph &G,int u)
{
    for(int i=0;i<G.vexnum;i++)
    {
        if(u==G.vertices[i].data)return i;
    }
}

void CreateGraph(Graph &G)
{
    int i,v1,v2,p,q;
    cin>>G.vexnum>>G.arcnum;
    for(i=0;i<G.vexnum;i++)
    {
        cin>>G.vertices[i].data;
        G.vertices[i].firstarc=NULL;
    }
    ArcNode *arc;
    for(i=0;i<G.arcnum;i++)
    {
        cin>>v1>>v2;
        p=LocateVertex(G,v1);
        q=LocateVertex(G,v2);
        arc=new ArcNode;
        arc->adjvex=q;
        arc->nextarc=G.vertices[p].firstarc;
        G.vertices[p].firstarc=arc;
        arc=new ArcNode;
        arc->adjvex=p;
        arc->nextarc=G.vertices[q].firstarc;
        G.vertices[q].firstarc=arc;
    }
}

void Traserve(Graph G)
{
    int i;
    for(i=0;i<G.vexnum;i++)
    {
        cout<<G.vertices[i].data<<' ';
        ArcNode *arc=G.vertices[i].firstarc;
        while(arc)
        {
            cout<<arc->adjvex<<' ';
            arc=arc->nextarc;
        }
        cout<<endl;
    }
}

int main()
{
    Graph G;
    CreateGraph(G);
    Traserve(G);
    return 0;
}

3.Dijkstra算法（数组）

#include<iostream>  
using namespace std;    
#define MAX_VERTEX_NUM 20    
typedef struct    
{    
    int vexs[MAX_VERTEX_NUM];    
    int arcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM];    
    int vexnum,arcnum;    
}Graph;       
    
void CreateGraph(Graph &G)    
{    
    int i,j,k,w;    
    cin>>G.vexnum>>G.arcnum;    
    for(i=0;i<G.vexnum;i++)cin>>G.vexs[i];    
    for(i=0;i<G.vexnum;i++)    
    {    
        for(j=0;j<G.vexnum;j++)G.arcs[i][j]=10000;    
    }    
    for(k=0;k<G.arcnum;k++)    
    {    
        cin>>i>>j>>w;    
        G.arcs[i][j]=w;    
    }    
} 

bool final[MAX_VERTEX_NUM];
bool P[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
int D[MAX_VERTEX_NUM];

void Dijkstra(Graph G,int v0)
{
	int v,w,i,j,min;
	for(v=0;v<G.vexnum;v++)
	{
		final[v]=false;
		D[v]=G.arcs[v0][v];
		for(w=0;w<G.vexnum;w++)P[v][w]=false;
		if(D[v]<10000)
		{
			P[v][v0]=true;
			P[v][v]=true;
		}
	}
	D[v0]=0;
	final[v0]=true;
	for(i=1;i<G.vexnum;i++)
	{
		min=10000;
		for(w=0;w<G.vexnum;w++)
		{
			if(!final[w]&&D[w]<min)
			{
				v=w;
				min=D[w];
			}
		}
		final[v]=true;
		for(w=0;w<G.vexnum;w++)
		{
			if(!final[w]&&(min+G.arcs[v][w]<D[w]))
			{
				D[w]=min+G.arcs[v][w];
				for(j=0;j<G.vexnum;j++)P[w][j]=P[v][j];
				P[w][w]=true;
			}
		}
	}
}

int main()    
{   
    int i,j;
	Graph G;
    CreateGraph(G);
	Dijkstra(G,0);
	for(i=1;i<G.vexnum;i++)cout<<0<<' '<<G.vexs[i]<<' '<<D[i]<<endl;
	for(i=0;i<G.vexnum;i++)
	{
		for(j=0;j<G.vexnum;j++)cout<<(int)P[i][j]<<' ';
		cout<<endl;
	}
    return 0;    
}

4.DFS（算法导论）

#include<iostream>  
using namespace std;
#define n 20 
int color[n],d[n],f[n],time=0;
int pred[n];

typedef struct VNode  
{  
    int data;
    VNode *next;
}VNode;  
typedef struct  
{  
    VNode Adj[n];  
    int VNum,ENum;  
}Graph;  

void create_graph(Graph &G)  
{  
    int i,v1,v2;  
    cin>>G.VNum>>G.ENum;  
    for(i=0;i<G.VNum;i++)  
    {  
        cin>>G.Adj[i].data;  
        G.Adj[i].next=NULL;  
    }  
    VNode *p;  
    for(i=0;i<G.ENum;i++)  
    {  
        cin>>v1>>v2;  
        p=(VNode *)malloc(sizeof(VNode));
        p->data=v2;
        p->next=G.Adj[v1].next;
        G.Adj[v1].next=p;  
    }  
}  

void DFS_visit(Graph G,int u)
{
    d[u]=++time;
    color[u]=1;
    VNode *p=G.Adj[u].next;
    while(p)
    {
        if(color[p->data]==0)
        {
            pred[p->data]=u;
            DFS_visit(G,p->data);
        }
        p=p->next;
    }
    f[u]=++time;
}

void DFS(Graph G)
{
    int i;
    for(i=0;i<G.VNum;i++)
    {
        color[i]=0;
        pred[i]=0;
    }
    for(i=0;i<G.VNum;i++)
    {
        if(color[i]==0)DFS_visit(G,i);
    }
}

int main()    
{
    Graph G;
    create_graph(G);
    DFS(G);
    cout<<endl;
    for(int i=0;i<G.VNum;i++)cout<<d[i]<<' '<<f[i]<<endl;
    return 0;    
}