数据结构实验课：实验六、图的遍历操作及应用

最新推荐文章于 2024-10-09 20:06:13 发布
最新推荐文章于 2024-10-09 20:06:13 发布
阅读量1.1w 收藏 86
点赞数 136
分类专栏： 数据结构实验课 c语言 文章标签： 数据结构 链表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51222650/article/details/117049041
版权

题目

一、实验目的

掌握有向图和无向图的概念；掌握邻接矩阵和邻接链表建立图的存储结构；掌握DFS及BFS对图的遍历操作；了解图结构在人工智能、工程等领域的广泛应用。

二、 实验要求

采用邻接矩阵和邻接链表作为图的存储结构，完成有向图和无向图的DFS和BFS操作。本实验给出了示例程序，其中共有4处错误，错误段均有标识，属于逻辑错误。请认真理解程序，修改程序代码，并在电脑上调试运行。

三、 DFS和BFS 的基本思想

深度优先搜索法DFS的基本思想：从图G中某个顶点Vo出发，首先访问Vo，然后选择一个与Vo相邻且没被访问过的顶点Vi访问，再从Vi出发选择一个与Vi相邻且没被访问过的顶点Vj访问，……依次继续。如果当前被访问过的顶点的所有邻接顶点都已被访问，则回退到已被访问的顶点序列中最后一个拥有未被访问的相邻顶点的顶点W，从W出发按同样方法向前遍历。直到图中所有的顶点都被访问。
广度优先算法BFS的基本思想：从图G中某个顶点Vo出发，首先访问Vo，然后访问与Vo相邻的所有未被访问过的顶点V1，V2，……，Vt；再依次访问与V1，V2，……，Vt相邻的起且未被访问过的的所有顶点。如此继续，直到访问完图中的所有顶点。

四、示例程序

1.邻接矩阵作为存储结构的程序示例
#include"stdio.h"
#include"stdlib.h"
#define MaxVertexNum 100 //定义最大顶点数
typedef struct{
char vexs[MaxVertexNum]; //顶点表
int edges[MaxVertexNum][MaxVertexNum];
//邻接矩阵，可看作边表
int n,e; //图中的顶点数n和边数e
}MGraph; //用邻接矩阵表示的图的类型
//========= 建立邻接矩阵 =======
void CreatMGraph(MGraph *G)
{
int i,j,k;
char a;
printf(“Input VertexNum(n) and EdgesNum(e): “);
scanf(”%d,%d”,&G->n,&G->e); //输入顶点数和边数
scanf("%c",&a);
printf(“Input Vertex string:”);
for(i=0;in;i++)
{
scanf("%c",&a);
G->vexs[i]=a; //读入顶点信息，建立顶点表
}
for(i=0;in;i++)
for(j=0;jn;j++)
G->edges[i][j]=0; //初始化邻接矩阵
printf(“Input edges,Creat Adjacency Matrix\n”);
for(k=0;ke;k++) { //读入e条边，建立邻接矩阵
scanf("%d%d",&i,&j); //输入边（Vi，Vj）的顶点序号
G->edges[i][j]=1;
G->edges[j][i]=1; //若为无向图，矩阵为对称矩阵；若建立有向图，去掉该条语句
}
}
//========= 定义标志向量，为全局变量 ======

typedef enum{FALSE,TRUE} Boolean;
Boolean visited[MaxVertexNum];
//======== DFS：深度优先遍历的递归算法======
void DFSM(MGraph *G,int i)
{ //以Vi为出发点对邻接矩阵表示的图G进行DFS搜索，邻接矩阵是0，1矩阵
int j;
printf("%c",G->vexs[i]); //访问顶点Vi
visited[i]=TRUE; //置已访问标志
for(j=0;jn;j++) //依次搜索Vi的邻接点
if(G->edges[i][j]== 1 && ! visited[j])
DFSM(G,j); //（Vi，Vj）∈E，且Vj未访问过，故Vj为新出发点
}
void DFS(MGraph *G)
{ //此段代码有一处错误
int i;
for(i=0;in;i++)
visited[i]=FALSE; //标志向量初始化
for(i=0;in;i++)
if(!visited[i]) //Vi未访问过
DFS(G,i); //以Vi为源点开始DFS搜索
}
//======== BFS：广度优先遍历 ======

void BFS(MGraph *G,int k)
{ //以Vk为源点对用邻接矩阵表示的图G进行广度优先搜索
int i,j,f=0,r=0;
int cq[MaxVertexNum]; //定义队列
for(i=0;in;i++)
visited[i]=FALSE; //标志向量初始化
for(i=0;i<=G->n;i++)
cq[i]=-1; //队列初始化
printf("%c",G->vexs[k]); //访问源点Vk
visited[k]=TRUE;
cq[r]=k; //Vk已访问，将其入队。注意，实际上是将其序号入队
while(cq[f]!=-1) { //队非空则执行
i=cq[f]; f=f+1; //Vf出队
for(j=0;jn;j++) //依次Vi的邻接点Vj
if(G-> edges[i][j] = =1 && !visited[j]) { //Vj未访问 以下三行代码有一处错误
printf("%c",G->vexs[j]); //访问Vj
visited[j] =FALSE; r=r+1; cq[r]=j; //访问过Vj入队
}
}
}
// ========= main =====
void main()
{
MGraph *G;
G=(MGraph *)malloc(sizeof(MGraph)); //为图G申请内存空间
CreatMGraph(G); //建立邻接矩阵
printf(“Print Graph DFS: “);
DFS(G); //深度优先遍历
printf(”\n”);
printf(“Print Graph BFS: “);
BFS(G,3); //以序号为3的顶点开始广度优先遍历
printf(”\n”);}
执行顺序：
Input VertexNum(n) and EdgesNum(e): 8，9
Input Vertex string: 01234567
Input edges,Creat Adjacency Matrix
0 1
0 2
1 3
1 4
2 5
2 6
3 7
4 7
5 6
Print Graph DFS: 01374256
Print Graph BFS: 31704256

2.邻接链表作为存储结构程序示例
#include"stdio.h"
#include"stdlib.h"
#define MaxVertexNum 50 //定义最大顶点数
typedef struct node{ //边表结点
int adjvex; //邻接点域
struct node *next; //链域
}EdgeNode;
typedef struct vnode{ //顶点表结点
char vertex; //顶点域
EdgeNode *firstedge; //边表头指针
}VertexNode;
typedef VertexNode AdjList[MaxVertexNum]; //AdjList是邻接表类型
typedef struct {
AdjList adjlist; //邻接表
int n,e; //图中当前顶点数和边数
} ALGraph; //图类型
//建立图的邻接表
void CreatALGraph(ALGraph *G)
{
int i,j,k;
char a;
EdgeNode *s; //定义边表结点
printf(“Input VertexNum(n) and EdgesNum(e): “);
scanf(”%d,%d”,&G->n,&G->e); //读入顶点数和边数
scanf("%c",&a);
printf(“Input Vertex string:”);
for(i=0;in;i++) //建立顶点表
{
scanf("%c",&a);
G->adjlist[i].vertex=a; //读入顶点信息
G->adjlist[i].firstedge=NULL; //边表置为空表
}
printf(“Input edges,Creat Adjacency List\n”);
for(k=0;ke;k++) { //建立边表
scanf("%d%d",&i,&j); //读入边（Vi，Vj）的顶点对序号
s=(EdgeNode )malloc(sizeof(EdgeNode)); //生成边表结点
s->adjvex=j; //邻接点序号为j
s->next=G->adjlist[i].firstedge;
G->adjlist[i].firstedge=s; //将新结点S插入顶点Vi的边表头部
s=(EdgeNode )malloc(sizeof(EdgeNode));
s->adjvex=i; //邻接点序号为i
s->next=G->adjlist[j].firstedge;
G->adjlist[j].firstedge=s; //将新结点S插入顶点Vj的边表头部
}
}
//定义标志向量，为全局变量
typedef enum{FALSE,TRUE} Boolean;
Boolean visited[MaxVertexNum];
//DFS：深度优先遍历的递归算法======
void DFSM(ALGraph *G,int i)
{ //以Vi为出发点对邻接链表表示的图G进行DFS搜索
EdgeNode *p;
printf("%c",G->adjlist[i].vertex); //访问顶点Vi
visited[i]=TRUE; //标记Vi已访问
p=G->adjlist[i].firstedge; //取Vi边表的头指针
while§ { //依次搜索Vi的邻接点Vj，这里j=p->adjvex
//以下3行代码有一处错误
if(! visited[p->adjvex]) //若Vj尚未被访问
DFS(G,p->adjvex); //则以Vj为出发点向纵深搜索
p=p->next; //找Vi的下一个邻接点
}
}
void DFS(ALGraph *G)
{
int i;
for(i=0;in;i++)
visited[i]=FALSE; //标志向量初始化
for(i=0;in;i++)
if(!visited[i]) //Vi未访问过
DFSM(G,i); //以Vi为源点开始DFS搜索
}
//BFS：广度优先遍历
void BFS(ALGraph *G,int k)
{ //以Vk为源点对用邻接链表表示的图G进行广度优先搜索
int i,f=0,r=0;
EdgeNode *p;
int cq[MaxVertexNum]; //定义FIFO队列
for(i=0;in;i++)
visited[i]=FALSE; //标志向量初始化
for(i=0;i<=G->n;i++)
cq[i]=-1; //初始化标志向量
printf("%c",G->adjlist[k].vertex); //访问源点Vk
visited[k]=TRUE;
cq[r]=k; //Vk已访问，将其入队。注意，实际上是将其序号入队
while(cq[f]!=-1)
{ //队列非空则执行
i=cq[f]; f=f+1; //Vi出队
p=G->adjlist[i].firstedge; //取Vi的边表头指针
while§
{ //依次搜索Vi的邻接点Vj（令p->adjvex=j）
if(!visited[p->adjvex]) { //若Vj未访问过
printf("%c",G->adjlist[p->adjvex].vertex); //访问Vj
visited[p->adjvex]=TRUE;
//以下3行代码有一处错误
r=r+1; cq[r]=p->adjvex; //访问过的Vj入队
}
p=p->next->next; //找Vi的下一个邻接点
}
}//endwhile
}
//主函数
void main()
{
int i;
ALGraph *G;
G=(ALGraph *)malloc(sizeof(ALGraph));
CreatALGraph(G);
printf(“Print Graph DFS: “);
DFS(G);
printf(”\n”);
printf(“Print Graph BFS: “);
BFS(G,3);
printf(”\n”);
}
执行顺序：
Input VertexNum(n) and EdgesNum(e): 8，9
Input Vertex string: 01234567
Input edges,Creat Adjacency List
0 1
0 2
1 3
1 4
2 5
2 6
3 7
4 7
5 6
Print Graph DFS: 02651473
Print Graph BFS: 37140265

二、 实验任务

  1. 改正程序中的错误并调试通过，测试并完成实验报告的撰写。
  2. 选做题，编写程序输出该无向网络的最小生成树以及该最小生成树的所有边。

代码

邻接矩阵作为图的存储结构：

#include <stdio.h>
#include <stdlib.h>
#define MaxVertexNum 100     //定义最大顶点数
typedef struct{
    char vexs[MaxVertexNum];        //顶点表
    int edges[MaxVertexNum][MaxVertexNum];
//邻接矩阵，可看作边表
    int n,e;          //图中的顶点数n和边数e
}MGraph;              //用邻接矩阵表示的图的类型
//=========建立邻接矩阵=======
void CreatMGraph(MGraph *G)
{
     int i,j,k;
     char a;
     printf("Input VertexNum(n) and EdgesNum(e): ");
     scanf("%d,%d",&G->n,&G->e);         //输入顶点数和边数
     scanf("%c",&a);
     printf("Input Vertex string:");
     for(i=0;i<G->n;i++)
     {
 scanf("%c",&a);
 G->vexs[i]=a;             //读入顶点信息，建立顶点表
     }
     for(i=0;i<G->n;i++)
for(j=0;j<G->n;j++)
    G->edges[i][j]=0;    //初始化邻接矩阵
     printf("Input edges,Creat Adjacency Matrix\n");
     for(k=0;k<G->e;k++) {       //读入e条边，建立邻接矩阵
 scanf("%d%d",&i,&j);        //输入边（Vi，Vj）的顶点序号
 G->edges[i][j]=1;
 G->edges[j][i]=1; //若为无向图，矩阵为对称矩阵；若建立有向图，去掉该条语句
     }
}
//=========定义标志向量，为全局变量=======
typedef enum{FALSE,TRUE} Boolean;
Boolean visited[MaxVertexNum];
//========DFS：深度优先遍历的递归算法======
void DFSM(MGraph *G,int i)
{ //以Vi为出发点对邻接矩阵表示的图G进行DFS搜索，邻接矩阵是0，1矩阵
    int j;
    printf("%c",G->vexs[i]);     //访问顶点Vi
    visited[i]=TRUE;             //置已访问标志
    for(j=0;j<G->n;j++)          //依次搜索Vi的邻接点
if(G->edges[i][j]==1 && ! visited[j])
    DFSM(G,j);              //（Vi，Vj）∈E，且Vj未访问过，故Vj为新出发点
}
void DFS(MGraph *G)
{  //此段代码有一处错误
    int i;
    for(i=0;i<G->n;i++)
visited[i]=FALSE;            //标志向量初始化
    for(i=0;i<G->n;i++)
if(!visited[i])              //Vi未访问过
    DFSM(G,i);               //以Vi为源点开始DFS搜索
}
//===========BFS：广度优先遍历=======
void BFS(MGraph *G,int k)
{                //以Vk为源点对用邻接矩阵表示的图G进行广度优先搜索
    int i,j,f=0,r=0;
    int cq[MaxVertexNum];        //定义队列
    for(i=0;i<G->n;i++)
visited[i]=FALSE;         //标志向量初始化
    for(i=0;i<G->n;i++)
cq[i]=-1;                    //队列初始化
    printf("%c",G->vexs[k]);     //访问源点Vk
    visited[k]=TRUE;
    cq[r]=k;          //Vk已访问，将其入队。注意，实际上是将其序号入队
    while(cq[f]!=-1) {          //队非空则执行
     i=cq[f]; f=f+1;             //Vf出队
     for(j=0;j<G->n;j++)         //依次Vi的邻接点Vj
         if(G->edges[i][j]==1 && !visited[j]) {  //Vj未访问 \\以下三行代码有一处错误
         printf("%c",G->vexs[j]);         //访问Vj
         visited[j]=TRUE;          r=r+1; cq[r]=j;          //访问过Vj入队
         }
    }
}
//==========main=====
int main()
{
    MGraph *G;
    G=(MGraph *)malloc(sizeof(MGraph));   //为图G申请内存空间
    CreatMGraph(G);          //建立邻接矩阵
printf("Print Graph DFS: ");
DFS(G);                  //深度优先遍历
    printf("\n");
    printf("Print Graph BFS: ");
    BFS(G,3);             //以序号为3的顶点开始广度优先遍历
    printf("\n");
    return 0;
}

邻接链表作为图的存储结构：

#include <stdio.h>
#include <stdlib.h>
#define MaxVertexNum 50          //定义最大顶点数
typedef struct node{       //边表结点
     int adjvex;           //邻接点域
     struct node *next;    //链域
}EdgeNode;
typedef struct vnode{      //顶点表结点
    char vertex;           //顶点域
    EdgeNode *firstedge;   //边表头指针
}VertexNode;
typedef VertexNode AdjList[MaxVertexNum];         //AdjList是邻接表类型
typedef struct {
    AdjList adjlist;       //邻接表
    int n,e;               //图中当前顶点数和边数
} ALGraph;                 //图类型
//=========建立图的邻接表=======
void CreatALGraph(ALGraph *G)
{
     int i,j,k;
     char a;
     EdgeNode *s;           //定义边表结点
     printf("Input VertexNum(n) and EdgesNum(e): ");
     scanf("%d,%d",&G->n,&G->e);       //读入顶点数和边数
     scanf("%c",&a);
     printf("Input Vertex string:");
     for(i=0;i<G->n;i++)         //建立边表
     {
	scanf("%c",&a);
	G->adjlist[i].vertex=a;       //读入顶点信息
	G->adjlist[i].firstedge=NULL;  //边表置为空表
     }
     printf("Input edges,Creat Adjacency List\n");
     for(k=0;k<G->e;k++) {        //建立边表
	scanf("%d%d",&i,&j);          //读入边（Vi，Vj）的顶点对序号
	s=(EdgeNode *)malloc(sizeof(EdgeNode));    //生成边表结点
	s->adjvex=j;                  //邻接点序号为j
	s->next=G->adjlist[i].firstedge;
	G->adjlist[i].firstedge=s;     //将新结点*S插入顶点Vi的边表头部
	s=(EdgeNode *)malloc(sizeof(EdgeNode));
	s->adjvex=i;                   //邻接点序号为i
	s->next=G->adjlist[j].firstedge;
	G->adjlist[j].firstedge=s;      //将新结点*S插入顶点Vj的边表头部
     }
}
//=========定义标志向量，为全局变量=======
typedef enum{FALSE,TRUE} Boolean;
Boolean visited[MaxVertexNum];
//========DFS：深度优先遍历的递归算法======
void DFSM(ALGraph *G,int i)
{                         //以Vi为出发点对邻接链表表示的图G进行DFS搜索
    EdgeNode *p;
    printf("%c",G->adjlist[i].vertex);    //访问顶点Vi
    visited[i]=TRUE;                      //标记Vi已访问
    p=G->adjlist[i].firstedge;            //取Vi边表的头指针
while(p) {                  //依次搜索Vi的邻接点Vj，这里j=p->adjvex
//以下3行代码有一处错误
	if(! visited[p->adjvex])      //若Vj尚未被访问
		    DFSM(G,p->adjvex);        //则以Vj为出发点向纵深搜索
	p=p->next;                    //找Vi的下一个邻接点
    }
}
void DFS(ALGraph *G)
{
    int i;
    for(i=0;i<G->n;i++)
	visited[i]=FALSE;             //标志向量初始化
    for(i=0;i<G->n;i++)
	if(!visited[i])               //Vi未访问过
	    DFSM(G,i);                //以Vi为源点开始DFS搜索
}
//==========BFS：广度优先遍历=========
void BFS(ALGraph *G,int k)
{                          //以Vk为源点对用邻接链表表示的图G进行广度优先搜索
    int i,f=0,r=0;
    EdgeNode *p;
    int cq[MaxVertexNum];         //定义FIFO队列
    for(i=0;i<G->n;i++)
	visited[i]=FALSE;	         //标志向量初始化
    for(i=0;i<=G->n;i++)
	cq[i]=-1;                          //初始化标志向量
    printf("%c",G->adjlist[k].vertex); //访问源点Vk
    visited[k]=TRUE;
    cq[r]=k;           //Vk已访问，将其入队。注意，实际上是将其序号入队
    while(cq[f]!=-1) {   //队列非空则执行
	i=cq[f]; f=f+1;                //Vi出队
	p=G->adjlist[i].firstedge;     //取Vi的边表头指针
	while(p) {                //依次搜索Vi的邻接点Vj（令p->adjvex=j）
	    if(!visited[p->adjvex]) {           //若Vj未访问过
		printf("%c",G->adjlist[p->adjvex].vertex);      //访问Vj
		visited[p->adjvex]=TRUE;
//以下3行代码有一处错误
		r=r+1; cq[r]=p->adjvex;            //访问过的Vj入队
	    }
	    p=p->next;               //找Vi的下一个邻接点
	}
    }//endwhile
}
//==========主函数===========
int main()
{
    int i;
    ALGraph *G;
    G=(ALGraph *)malloc(sizeof(ALGraph));
    CreatALGraph(G);
    printf("Print Graph DFS: ");
    DFS(G);
    printf("\n");
    printf("Print Graph BFS: ");
    BFS(G,3);
    printf("\n");
    return 0;
}

选做题

#include "stdio.h"
#include"stdlib.h"
#define MaxVertexNum 100
#define MaxEdgeNum 200
typedef struct{
    char vexs[MaxVertexNum];
    int edges[MaxVertexNum][MaxVertexNum];
    int n,e;
}MGraph;

typedef struct edge
{
    char p1;
    char p2;
    int weight;
}Edge;

typedef struct edges
{
    int num;
    Edge edge[MaxEdgeNum];
}Edges;

typedef enum{FALSE,TRUE} Boolean;
Boolean visited[MaxVertexNum];



//=========建立邻接矩阵=======
void CreatMGraph(MGraph *G)
{
     int i,j,k,l;
     char a;
     printf("Input VertexNum(n) and EdgesNum(e): ");
     scanf("%d,%d",&G->n,&G->e);         //输入顶点数和边数
     scanf("%c",&a);
     printf("Input Vertex string:");
     for(i=0;i<G->n;i++)
     {
         scanf("%c",&a);
         G->vexs[i]=a;             //读入顶点信息，建立顶点表
     }
     for(i=0;i<G->n;i++)
        for(j=0;j<G->n;j++)
            G->edges[i][j]=0;    //初始化邻接矩阵
    printf("Input edges,Creat Adjacency Matrix\n");
    for(k=0;k<G->e;k++)
    {       //读入e条边，建立邻接矩阵
         scanf("%d,%d,%d",&i,&j,&l);        //输入边（Vi，Vj）的顶点序号
         G->edges[i][j]=l;
         G->edges[j][i]=l; //若为无向图，矩阵为对称矩阵；若建立有向图，去掉该条语句
    }
}

int is_existed(char *arr,char c)
{
    int i;
    for(i=0;i<MaxEdgeNum;i++)
    {
        if(arr[i]=='#')
            return 0;
        if(arr[i]==c)
            return 1;
    }
    return 0;
}

int Init_Edge(Edge **edge)
{
    *edge=(Edge*)malloc(sizeof(Edge));
    (*edge)->p1='#';
    (*edge)->p2='#';
    (*edge)->weight=0;
    return 1;
}

int Edges_Init(Edges **edges)
{
    *edges=(Edges*)malloc(sizeof(Edges));
    (*edges)->num=0;
}

int Edges_Read(MGraph *G,Edges* E)
{
    int i,j;
    for(i=0;i<G->n;i++)
    {
        for(j=0;j<=i;j++)
        {
            if(G->edges[i][j]!=0)
            {
                E->edge[E->num].p1=G->vexs[i];
                E->edge[E->num].p2=G->vexs[j];
                E->edge[E->num].weight=G->edges[i][j];
                E->num++;
            }

        }
    }
    return 1;
}

int Edges_Delete(Edges* E,char a1,char a2)
{
    int i;
    int pos=-1;
    for(i=0;i<E->num;i++)
    {
        if((E->edge[i].p1==a1&&E->edge[i].p2==a2)||(E->edge[i].p1==a2&&E->edge[i].p2==a1))
        {
            pos=i;
            break;
        }
    }
    if(pos==-1)
        return 1;
    for(i=pos;i<E->num;i++)
    {
        E->edge[i]=E->edge[i+1];
    }
    E->num--;
    return 1;
}

int Edges_Sort(Edges* E)
{
    int i,j,pos,min;
    Edge temp;
    for(i=0;i<E->num-1;i++)
    {
        pos=i;
        min=E->edge[i].weight;
        for(j=i+1;j<E->num;j++)
        {
            if(E->edge[j].weight<min)
            {
                pos=j;
                min=E->edge[j].weight;
            }
        }
        temp=E->edge[i];
        E->edge[i]=E->edge[pos];
        E->edge[pos]=temp;
    }
    return 1;
}

int find_char(char M[MaxVertexNum][MaxVertexNum],char c)
{
    int i,j;
    for(i=0;i<MaxVertexNum;i++)
    {
        for(j=0;j<MaxVertexNum;j++)
        {
            if(M[i][j]=='#')
                break;
            if(M[i][j]==c)
                return i;
        }
    }
    return -1;
}

int delete_char(char *M,char c)
{
    int i;
    int pos=-1;
    for(i=0;i<MaxVertexNum;i++)
    {
        if(M[i]=='#')
            break;
        if(M[i]==c)
            pos=i;
    }
    if(pos==-1)
        return 1;
    for(i=pos;i<MaxVertexNum;i++)
    {
        if(M[i+1]!='#')
        {
            M[i]=M[i+1];
        }
        else
        {
            M[i]='#';
            break;
        }
    }
    return 1;
}

int Kruskal(MGraph *G,Edges *E_result)
{
    int i,j,is_p1,is_p2,flag,line1,line2,p,q,l;
    char connected[MaxVertexNum][MaxVertexNum];
    for(i=0;i<MaxVertexNum;i++)
    {
        for(j=0;j<MaxVertexNum;j++)
        {
            connected[i][j]='#';
        }
    }
    Edges *E;
    Edges_Init(&E);
    Edges_Read(G,E);
    Edges_Sort(E);
    int edge_count=0;
    while(edge_count<G->n-1)
    {
        i=0;
        while(i<G->n)
        {
            flag=0;
            for(j=0;j<G->n;j++)
            {
                is_p1=is_existed(connected[i],E->edge[0].p1);
                is_p2=is_existed(connected[i],E->edge[0].p2);
                if(is_p1==1&&is_p2==1)
                {
                    Edges_Delete(E,E->edge[0].p1,E->edge[0].p2);
                    flag=-1;
                    break;
                }
                if((is_p1==1&&is_p2==0)||(is_p1==0&&is_p2==1))
                {
                    if(is_p2==0)
                    {
                        for(q=0;q<G->n;q++)
                        {
                            if(is_existed(connected[q],E->edge[0].p2)==1)
                            {
                                flag=2;
                                break;
                            }
                        }
                        if(flag!=2)
                            flag=1;
                        break;
                    }
                    if(is_p1==0)
                    {
                        for(q=0;q<G->n;q++)
                        {
                            if(is_existed(connected[q],E->edge[0].p1)==1)
                            {
                                flag=3;
                                break;
                            }
                        }
                        if(flag!=3)
                            flag=4;
                        break;
                    }
                }
            }
            if(flag!=0)
                break;
            i++;
        }

        if(flag==-1)
        {
            continue;
        }
        else if(flag==2||flag==3)
        {
            line1=find_char(connected,E->edge[0].p1);
            line2=find_char(connected,E->edge[0].p2);
            l=get_length(connected[line2]);
            for(p=0;p<l;p++)
            {
                connected[line1][get_length(connected[line1])]=connected[line2][p];
                connected[line2][p]='#';
            }
            E_result->edge[E_result->num]=E->edge[0];
            E_result->num++;
            Edges_Delete(E,E->edge[0].p1,E->edge[0].p2);
            edge_count++;
            continue;
        }
        else if(flag==1)
        {
            line1=find_char(connected,E->edge[0].p1);
            connected[line1][get_length(connected[line1])]=E->edge[0].p2;
            E_result->edge[E_result->num]=E->edge[0];
            E_result->num++;
            Edges_Delete(E,E->edge[0].p1,E->edge[0].p2);
            edge_count++;
            continue;
        }
        else if(flag==4)
        {
            line2=find_char(connected,E->edge[0].p2);
            connected[line2][get_length(connected[line2])]=E->edge[0].p1;
            E_result->edge[E_result->num]=E->edge[0];
            E_result->num++;
            Edges_Delete(E,E->edge[0].p1,E->edge[0].p2);
            edge_count++;
            continue;
        }
        else if(flag==0)
        {
            for(p=0;p<MaxVertexNum;p++)
            {
                if(get_length(connected[p])==0)
                {
                    connected[p][0]=E->edge[0].p1;
                    connected[p][1]=E->edge[0].p2;
                    break;
                }
            }
            E_result->edge[E_result->num]=E->edge[0];
            E_result->num++;
            Edges_Delete(E,E->edge[0].p1,E->edge[0].p2);
            edge_count++;
            continue;
        }
    }

    printf("\nedges in minimum created tree is:\n");
    for(i=0;i<E_result->num;i++)
    {
        printf("%c,%c,%d\n",E_result->edge[i].p1,E_result->edge[i].p2,E_result->edge[i].weight);

    }

    return 1;

}


int get_length(char *arr)
{
    int i=0;
    for(i=0;i<MaxVertexNum;i++)
    {
        if(arr[i]=='#')
            return i;
    }
    return 0;
}

void init_Arr(char *arr)
{
    int i;
    for(i=0;i<MaxVertexNum;i++)
    {
        arr[i]='#';
    }
}



//==========main=====
void main()
{
    MGraph *G;
    G=(MGraph *)malloc(sizeof(MGraph));   //为图G申请内存空间
    CreatMGraph(G);          //建立邻接矩阵
    printf("\n");
    Edges *E_result;
    Edges_Init(&E_result);
    Kruskal(G,E_result);
}

求赞！！！

superlistboy
关注
专栏目录
头歌数据结构图的邻接矩阵存储及遍历操作
05-26
头歌数据结构图的邻接矩阵存储及遍历操作 第1关图的邻接矩阵存储及求邻接点操作 第2关图的深度优先遍历 第3关图的广度优先遍历 稳过
图和图的遍历实验操作
07-15
1.编写按键盘输入的数据建立图的邻接矩阵存储； 2.编写图的深度或广度优先编历程序；
CSDN简介
最新发布
ticketsge的博客
10-09 1831
CSDN（ChineseSoftwareDeveloperNetwork），全称“中国软件开发者网络”，是一个专注服务于IT专业人士及IT企业的知识传播、在线学习、职业发展等全生命周期服务的平台。CSDN成立于1999年，是中国最大的中文IT技术社区，隶属于北京创新乐知网络技术有限公司。该平台汇聚了大量的软件开发者和IT专业人士，成为中国乃至全球范围内重要的IT技术交流和学习平台。 CSDN的主要功能和特点 CSDN的主要功能和特点可以概括为以下几个方面： 知识传播与交流 CSDN拥有全球最大的中文
图的遍历 数据结构实验报告
06-27
利用邻接表实现图的遍历操作 附有源代码 数据结构课的实验报告
数据结构之实验三：图的遍历操作与拓扑排序算法
lynn_Dai的博客
07-10 1166
一、实验目的： 1．掌握图的存储定义； 2．掌握图的遍历操作； 3．掌握图的拓扑排序算法。 二、实验内容： 1． 利用图的邻接矩阵，实现图的深度优先遍历搜索。图结构如下 结果输出 2． 采用邻接表作为有向图的存储结构，编写图的拓扑排序程序实现下图的拓扑排序输出； 实验一：图的深度优先遍历操作 定义邻接矩阵 typedef struct{ int vex[MaxVertexNum]; int Edge[MaxVertexNum][MaxVertexNum]; int vexnum,
数据结构实验五(图的遍历)
JacinLee的博客
11-13 2050
题目描述： 分别用邻接矩阵和邻接表实现图的深度优先遍历和广度优先遍历。 下面邻接矩阵和邻接表均以下图为例，其中已标注了正确的dfs，bfs顺序图和相关的表示法。 几句话明白深度与广度搜索：深度优先就像你被困在了迷宫里面，想要出去必须一路走到底，直到走不通了才回溯，重点是回溯。而广度优先就像你丢了眼睛，看不清的时候满地寻找，辐射范围大。 上次实验四哈夫曼树全部完整代码见此处 邻接矩阵存储图 MGraph.cpp #include <iostream> #include <queue>
Prim 普里姆算法(邻接矩阵)C语言版
朱子恒的博客
12-10 2776
Prim算法的思维路线较为简单，百度基本都能看懂。但是编程还是有点难的。 整个围绕两个东西转，一个lowcost数组，一个adjvex数组，前者是用来保存当前生成树到其它顶点的权值的。 比如这个图，假设一开始是从0出发，那么首先将0这个点并入到我们的生成树中，顺便设置一遍 lowcost数组，也就是，从0开始到其它顶点的权重。那么，这里有个问题，将0并入到我们的生成树，用什么标记表示这个顶...
《数据结构》实验报告六：图的表示与遍历
Amentos的博客
11-26 1万+
《数据结构》实验报告：图的相关概念 + 深度/广度优先遍历算法 + 拓扑排序算法 + prim算法 + dijkstra算法
图的遍历实验
dearzcs的博客
04-07 891
图的遍历
《数据结构与算法设计》实验报告书之图的遍历操作
A_dmin的博客
12-12 1万+
《数据结构与算法设计》实验报告书之图的遍历操作 实验项目 图的遍历操作 实验目的 掌握有向图和无向图的概念；掌握邻接矩阵和邻接链表建立图的存储结构；掌握DFS及BFS对图的遍历操作；了解图结构在人工智能、工程等领域的广泛应用。 实验内容 采用邻接矩阵和邻接链表其中一种作为图的存储结构，完成有向图和无向图的DFS和BFS操作。 算法设计分析 （一）数据结构的定义 图遍历又称图的遍历，属于数据结构中的...
数据结构实验7---- 图的两种遍历方法及对应的生成树
qq_60737285的博客
07-16 1132
其中，深度优先遍历通过递归或栈实现，它会遍历图中所有的节点，并将它们标记为已经访问过，但并没有记录节点间的关系；广度优先遍历则通过队列实现，它同样会遍历图中所有的节点，但会先访问距离起始节点近的节点，并记录节点间的关系。本次实验通过深度优先生成树和广度优先生成树的实现，可以建立起基于图的树结构，便于对图的结构进行理解和处理。在实现本算法之前，我们需要图的基本运算算法和图的存储算法：本次用到的是邻接表类型存储的图并且添加了创建图的邻接表、输出图的邻接表、销毁图的邻接表等算法。图的两种遍历方法及对应的生成树。
吉林大学数据结构实验课源代码
04-28
吉林大学软件学院的数据结构实验源代码为学生们提供了一个宝贵的实践平台，使他们有机会亲手操作和理解这些重要概念。通过深入分析这些代码，不仅可以巩固课堂所学，还能为将来解决更复杂的问题打下坚实的基础。无论...
自存文件-数据结构实验课
10-25
在《数据结构》实验课中，学生将通过一系列设计型实验深入理解和应用数据结构的核心概念。实验涵盖了线性表、栈、字符串模式匹配、哈夫曼树、二叉树、Dijkstra算法、广度优先搜索以及排序算法等多个重要主题。这些...
数据结构与算法实验课资料
12-18
- 实验课的代码练习能帮助学生掌握如何在实际编程中应用这些数据结构和算法，例如使用C++、Java或Python实现各种数据结构和算法。 通过这门课程的学习，学生不仅能掌握数据结构和算法的基本原理，还能提升编程能力...
数据结构实验9、图的遍历
Scarlett的博客
12-13 4360
作者说： 这个实验的算法在数据结构课本的P156~P157、P161~P162、P169~P170。 我觉得做这个实验挺顺利的，因为大部分的算法在课本上都给出了，虽然不详细，但是设计思想已经给出来了，实现起来就比较容易了。这个实验也是比较综合一点的，用到了前面的队列知识，因为在二叉树那一个练习中，我已经重新修改了队列的函数部分，所以可以直接拿过来这个实验中运用，也没有出现问题，真不错，还好我上一个实验里修改的很仔细，没想到间接的也为这个实验做了准备。图的存储结构我用的是书上的数组表示法，构造图的时候.
数据结构与算法之图的深度优先遍历(DFS)
five-five
06-16 1843
学习图的深度优先遍历 (DFS)，先复习下 树的深度优先遍历(这里以先根遍历为例)。 这里的 和 同上文 方法说明 注意：树节点示意图 生成树示意图 同 广度优先生成森林 一样有向图&强连通图
【数据结构与算法】图的遍历（深度优先遍历DFS算法）
m0_61886762的博客
05-13 9514
1.1深度优先遍历 深度优先遍历（depth first search），也有称为深度优先搜索简称DFS。它的主要思想就是例如找钥匙一样。例如：我们的一把车钥匙被搞丢了但是可以确定的是它一定就在家里的某个位置，所以我们需要从房间开始寻找，可是我们是该在房间某一处寻找还是将一整个房间搜索完之后再找其他房间的地方呢？在深度优先遍历意思就是将一个房间的所有地方搜索完之后再进行其他房间的搜索，直至找到车钥匙为止。 假设你现在需要完成一个任务，要知道你在如下迷宫中，从顶点A开始要走遍所有图中的顶点并作上标记，注.
数据结构实验：C++实现邻接矩阵创建无向图以及BFS和DFS遍历
qq_45050714的博客
01-02 3085
数据结构实验四：利用邻接矩阵创建无向图，并实现BFS和DFS遍历 1.实验目的 采用邻接矩阵或邻接表进行图的存储 分别完成图的深度优先和宽度优先搜索 2.无向图类 #ifndef graph_h #define graph_h #include<iostream> #include<queue> #include<stack> #include<map> using namespace std; //利用邻接矩阵构造无向图，实现BFS和DFS遍历 clas
数据结构学习笔记——图的遍历算法（深度优先搜索和广度优先搜索）
热门推荐
小宇y的博客
08-18 3万+
若通过邻接表表示图，则每个顶点都入队一次，即所需时间为O(|V|)，搜索顶点的邻接顶点所需时间为O(|E|)，其时间复杂度为O(|V|+|E|)。若通过邻接表表示图，则查找所有顶点的邻接顶点所需时间为O(|E|)，访问顶点所需时间为O(|V|)，即总时间复杂度为O(|V|+|E|)。4、查看V7单链表，其邻接顶点为2，即V3，它已经被访问过，于是回到V3单链表，搜索下一个未被访问的邻接顶点；11、查看V8单链表，其邻接顶点为4，即V5，已经被访问过，于是回到V5单链表，搜索下一个未被访问的邻接顶点；....
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值