【Dev-c++】C语言数据结构实验——图

一、实验目的

    1、掌握图的基本存储方法和相关术语

    2、掌握图的两种搜索路径的遍历方法

    3、理解最小生成树的有关概念及普里姆(Prim)和克鲁斯卡尔算法

    4、掌握图的有关应用

二、实验要求

    1、认真阅读程序。

2、上机调试，并运行程序。

3、保存和截图程序的运行结果，并结合程序进行分析。

三、实验内容和基本原理

    1、实验6.1 建立无向图的邻接矩阵存并输出

    给出一个无向图，求它的邻接矩阵（见参考程序1）：

    2、实验6.2 建立图的邻接存储并在此基础上实现图的深度优先遍历和广度优先遍历

//参考程序1

#include

#include

#define MAX 20

typedef int VexType;

typedef VexType Mgraph[MAX][MAX];

void creat_mg(Mgraph G);

void output_mg(Mgraph G);

Mgraph G1;

int n,e,v0;

void main()

{

       creat_mg(G1);

       output_mg(G1);

}

void creat_mg(Mgraph G)

{

       int i,j,k;

       printf("n 请输入无向图的顶点数和边数，如: 6,5:");

       scanf("%d,%d",&n,&e);

       for(i=1;i<=n;i++)

              for(j=1;j<=n;j++)

                     G[i][j]=0;

              for(k=1;k<=e;k++)

              {

                     printf("n请输入每条边的两个顶点编号，如：2,5 :");

                     scanf("%d,%d",&i,&j);

                     G[i][j]=1;

                     G[j][i]=1;

              }

}

void output_mg(Mgraph G)

{

       int i,j;

       for(i=1;i 
                       
 
参考程序2
 
#include

#include

#define MAX 20

typedef int VexType;

typedef struct Vnode

{

       VexType data;

       struct Vnode *next;

}Vnode;

typedef Vnode Lgraph[MAX];

typedef struct

{

       int V[MAX];

       int front;

       int rear;

}Queue;

void creat_L(Lgraph G);

void output_L(Lgraph G);

void dfsL(Lgraph G,int v);

void bfsL(Lgraph G,int v);

Lgraph Ga;

int n,e,visited[MAX];

void main()

{

       int v1,i;

       for(i=0;idata=i;

              p->next=G[j].next;

              G[j].next=p;

              q=(Vnode *)malloc(sizeof(Vnode));

              q->data=j;

              q->next=G[i].next;

              G[i].next=q;

       }

}

void output_L(Lgraph G)

{

       int i;

       Vnode *p;

       for(i=1;i<=n;i++)

       {

              printf("n与[%d]关联的顶点有:",i);

              p=G[i].next;

              while(p!=NULL)

              {

                     printf("%5d",p->data);

                     p=p->next;

              }

       }

}

void initqueue(Queue *q)

{

       q->front=-1;

       q->rear=-1;

}

int quempty(Queue *q)

{

       if(q->front==q->rear)

       {

              return 1;

       }

       else

       {

              return 0;

       }

}

void enqueue(Queue *q,int e)

{

       if((q->rear+1)%MAX==q->front)

              printf("队列满!n");

       else

       {

              q->rear=(q->rear+1)%MAX;

              q->V[q->rear]=e;

       }

}

int dequeue(Queue *q)

{

       int t;

       if(q->front==q->rear)

       {

              printf("队列空!n");

              return 0;

       }

              else

              {

                     q->front=(q->front+1)%MAX;

                     t=q->V[q->front];

                     return t;

              }

}

void dfsL(Lgraph G,int v)

{

       Vnode *p;

       printf("%d->",G[v].data);

       visited[v]=1;

       p=G[v].next;

       while(p)

       {

              v=p->data;

              if(visited[v]==0)

                     dfsL(G,v);

              p=p->next;

       }

}

void bfsL(Lgraph g,int v)

{

       int x;

       Vnode *p;

       Queue *q=(Queue *)malloc(sizeof(Queue));

       initqueue(q);

       printf("n %d->",g[v].data);

       visited[v]=1;

       enqueue(q,v);

       while(!quempty(q))

       {

              x=dequeue(q);

              p=g[x].next;

              while(p)

              {

                     v=p->data;

                     if(visited[v]==0)

                     {

                            printf("%d->",g[v].data);

                            visited[v]=1;

                            enqueue(q,v);

                     }

                     p=p->next;

              }

       }

       printf("n");

}