《软件技术基础》实验指导实验六-优快云博客

本文介绍了一个关于图的遍历算法的实验，包括深度优先搜索和两种广度优先搜索的实现方式。实验通过邻接矩阵存储无向图，并从不同顶点出发进行遍历，演示了图的基本操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

图

实验六图

一、实验目的

熟悉图的邻接矩阵和邻接表的存储结构
熟悉图的邻接矩阵和邻接表的建立算法
掌握图的遍历算法

二、实验内容

无向图采用邻接矩阵存储，编写深度优先搜索遍历算法，从不同的顶点出发对无向图进行遍历。

Tips

可采用深度优先搜索 6.1 和广度优先搜索 6.2 进行遍历
广度优先搜索可使用 6.2.1 递归或 6.2.2 运用队列循环的方式实现

Answer

6.1

#include<stdio.h>
//图的邻接矩阵类型定义
const int n=8;
const int e=10;
typedef char vextype;
typedef int adjtype;
typedef struct
{
    vextype vexs[n];
    adjtype arcs[n][n];
}graph;
graph*g=new graph;
void creatgraph();
void dfsa(int);
int visited[n];

//void main()
int main()
{
    creatgraph();
    int i;
    while(1)
    {
        for(i=0;i<n;i++)
        {
            visited[i]=0;
        }
        printf("输入出发点序号（0-7），输入-1结束：");
        scanf("%d",&i);
        if(i==-1)
        {
            break;
        }
        dfsa(i);
    }
    return 0;
}

//建立无向图邻接矩阵
void creatgraph()
{
    int i,j,k;
    char ch;
    printf("输入8个顶点的字符数据信息:\n");
    for(i=0;i<n;i++)
    {
        if((ch=getchar())!='\n') g->vexs[i]=ch;
    }
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        {
            g->arcs[i][j]=0;
        }
    }
    printf("输入10条边的起、终点i,j:\n"); 
    for(k=0;k<e;k++)
    {
        scanf("%d,%d",&i,&j); //顶点序号从0开始
        g->arcs[i][j]=g->arcs[j][i]=1;
    }
}

//深度优先搜索遍历

void dfsa(int i)
{
    int j;
    printf("Node %c\n",g->vexs[i]);
    visited[i]=1;
    for(j=0;j<n;j++)
    {
        if(g->arcs[i][j]==1&&visited[j]==0)
        {
            dfsa(j);
        }
    }
}

6.2.1

#include<stdio.h>
//图的邻接矩阵类型定义
const int n=8;
const int e=10;
typedef char vextype;
typedef int adjtype;
typedef struct
{
    vextype vexs[n];
    adjtype arcs[n][n];
}graph;
graph*g=new graph;
void creatgraph();
void bfsa(int);
int visited[n];

//void main()
int main()
{
    creatgraph();
    int i;
    while(1)
    {
        for(i=0;i<n;i++)
        {
            visited[i]=0;
        }
        printf("输入出发点序号（0-7），输入-1结束：");
        scanf("%d",&i);
        if(i==-1)
        {
            break;
        }
        bfsa(i);
    }
    return 0;
}

//建立无向图邻接矩阵
void creatgraph()
{
    int i,j,k;
    char ch;
    printf("输入8个顶点的字符数据信息:\n");
    for(i=0;i<n;i++)
    {
        if((ch=getchar())!='\n') g->vexs[i]=ch;
    }
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        {
            g->arcs[i][j]=0;
        }
    }
    printf("输入10条边的起、终点i,j:\n"); 
    for(k=0;k<e;k++)
    {
        scanf("%d,%d",&i,&j); //顶点序号从0开始
        g->arcs[i][j]=g->arcs[j][i]=1;
    }
}

//广度优先搜索遍历 递归
void bfsa(int i)
{
    int j;
    //判断根节点是否已经遍历
    if(visited[i]==0)
    {
        printf("Node %c\n",g->vexs[i]);
        visited[i]=1;
    }
    //遍历根节点的邻接点
    for(j=0;j<n;j++)
    {
        if(g->arcs[i][j]==1&&visited[j]==0)
        {
            printf("Node %c\n",g->vexs[j]);
            visited[j]=1;
            //递归遍历邻接点
            bfsa(j);
        }
    }
}

6.2.2

#include<stdio.h>
//图的邻接矩阵类型定义
const int n=8;
const int e=10;
typedef char vextype;
typedef int adjtype;
typedef struct
{
    vextype vexs[n];
    adjtype arcs[n][n];
}graph;
graph*g=new graph;
void creatgraph();
void bfsb(int);
int visited[n];

//void main()
int main()
{
    creatgraph();
    int i;
    while(1)
    {
        for(i=0;i<n;i++)
        {
            visited[i]=0;
        }
        printf("输入出发点序号（0-7），输入-1结束：");
        scanf("%d",&i);
        if(i==-1)
        {
            break;
        }
        bfsb(i);
    }
    return 0;
}

//建立无向图邻接矩阵
void creatgraph()
{
    int i,j,k;
    char ch;
    printf("输入8个顶点的字符数据信息:\n");
    for(i=0;i<n;i++)
    {
        if((ch=getchar())!='\n') g->vexs[i]=ch;
    }
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        {
            g->arcs[i][j]=0;
        }
    }
    printf("输入10条边的起、终点i,j:\n"); 
    for(k=0;k<e;k++)
    {
        scanf("%d,%d",&i,&j); //顶点序号从0开始
        g->arcs[i][j]=g->arcs[j][i]=1;
    }
}

//广度优先遍历 循环
void bfsb(int i)
{
    int q[2*n],Fq=0,Rq=0;
    int node,j;
    q[Rq++] = i;
    while(Fq < Rq)
    {
        node = q[Fq++];
        if(visited[node]==0)
        {
            printf("Node %c\n",g->vexs[node]);
            visited[node] = 1;
            //将顶点node的邻接点入队列
            for(int j = 0; j < n; j++)
            {
                if(g->arcs[node][j]==1&&visited[j]==0)
                {
                    q[Rq++] = j;
                }
            }
        }
    }
}

转载于:https://www.cnblogs.com/vanlion/p/datastructure-exp-6.html