哈工大 数据结构与算法 作业4-图型结构及其应用

最新推荐文章于 2023-11-19 23:05:03 发布
最新推荐文章于 2023-11-19 23:05:03 发布
阅读量1.3k 收藏 31
点赞数 2
分类专栏： 数据结构 文章标签： 算法 数据结构 dfs bfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TC_Ning/article/details/120690556
版权

作业题目 1：图的存储结构的建立与搜索 图的搜索（遍历）

算法是图型结构相关算法的基础，本作业要求编写程序 演示无向图典型存储结构的建立和搜索（遍历）过程。

作业要求：

1．分别实现无向图的邻接矩阵和邻接表存储结构的建立算法，分析和比较各建 立算法的时间复杂度以及存储结构的空间占用情况；

2．实现无向图的邻接矩阵和邻接表两种存储结构的相互转换算法；

3．在上述两种存储结构上，分别实现无向图的深度优先搜索（递归和非递归) 和广度优先搜索算法。并以适当的方式存储和显示相应的搜索结果（深度优先或 广度优先生成森林（或生成树）、深度优先或广度优先序列和编号）；

4．分析搜索算法的时间复杂度和空间复杂度；

5．以文件形式输入图的顶点和边，并显示相应的结果。要求顶点不少于 10 个边 数不少于 15 条；

6．软件功能结构安排合理，界面友好，便于使用。 

#include<stdio.h>
#include<stdlib.h>
#define MAX 50
typedef struct matrix
{
    int vertex[MAX];
    int edge[MAX][MAX];
    int vernum;
}MATRIX;
typedef struct node
{
    int index;
    struct node *next;
}EDGE;
typedef struct vertex
{
    int vertex;
    EDGE *next=NULL;
}VERTEX;
typedef struct list
{
    VERTEX verlist[MAX];
    int v,e;
}LIST;
int visited[MAX]={0};
int nvisited[MAX]={0};
void CreateMatrix(MATRIX &m,FILE *f);
void CreateList(LIST &L,FILE *f);
void Append(LIST &L,int i,int j);
void Display(MATRIX m);
void Display(LIST L);
LIST TransM_L(MATRIX m);
MATRIX TransL_M(LIST L);
void DFScomponents(MATRIX m);
void DFScomponents_list(LIST L);
void DFS(MATRIX m,int n);
void DFS_list(LIST L,int n);
void nDFS(MATRIX m,int n);
void nDFS_list(LIST L);
void BFS(MATRIX m,int n);
void BFS_list(LIST L,int n);
void BFScomponents(MATRIX m);
void BFScomponents_list(LIST L);
int main()
{
    MATRIX m,m2;LIST L,L2;
    FILE *f=NULL;
    if((f=fopen("graph.txt","r"))==NULL)
    {
        printf("Fail to open graph.txt!\n");
        exit(0);
    }
    CreateMatrix(m,f);
    Display(m);
    CreateList(L,f);
    Display(L);
    m2=TransL_M(L);
    printf("Transfer adjlist to adjmatrix:\n");
    Display(m2);
    L2=TransM_L(m);
    printf("Transfer adjmatrix to adjlist:\n");
    Display(L2);
    printf("DFS:");
    DFScomponents(m);
    printf("\nChoose a vertex to start nDFS(0~9):");
    int n=0;
    scanf("%d",&n);
    printf("NDFS:");
    nDFS(m,n);
    for(int i=0;i<m.vernum;i++)
    {
        visited[i]=0;
    }
    DFScomponents_list(L);
    nDFS_list(L);
    for(int i=0;i<m.vernum;i++)
    {
        visited[i]=0;
    }
    BFScomponents(m);
    BFScomponents_list(L);
    fclose(f);
}
void CreateMatrix(MATRIX &m,FILE *f)
{
    fscanf(f,"%d",&m.vernum);
    for(int i=0;i<m.vernum;i++)
    {
        fscanf(f,"%d",&m.vertex[i]);
    }
    for(int i=0;i<m.vernum;i++)
    {
        for(int j=0;j<m.vernum;j++)
        {
            fscanf(f,"%d",&m.edge[i][j]);
        }
    }
}
void Display(MATRIX m)
{
    printf("Vertex:\n");
    for(int i=0;i<m.vernum;i++)
    {
        printf("%d ",m.vertex[i]);
    }
    printf("\nEdge:\n");
    for(int i=0;i<m.vernum;i++)
    {
        for(int j=0;j<m.vernum;j++)
        {
            printf("%d ",m.edge[i][j]);
        }
        printf("\n");
    }
}
void CreateList(LIST &L,FILE *f)
{
    int temp=0,count=0;
    fscanf(f,"%d",&L.v);
    for(int i=0;i<L.v;i++)
    {
        fscanf(f,"%d",&L.verlist[i].vertex);
    }
    for(int i=0;i<L.v;i++)
    {
        for(int j=0;j<L.v;j++)
        {
            fscanf(f,"%d",&temp);
            if(temp==1)
            {
                Append(L,i,j);
                count++;
            }
        }
    }
    L.e=count/2;
}
void Append(LIST &L,int i,int j)
{
    EDGE *temp=NULL;
    temp=(EDGE *)malloc(sizeof(EDGE));
    temp->index=j;
    temp->next=NULL;
    if(L.verlist[i].next==NULL)
    {
        L.verlist[i].next=temp;
    }
    else
    {
        EDGE *p=L.verlist[i].next;
        while(p->next!=NULL)
        {
            p=p->next;
        }
        p->next=temp;
    }
    
}
void Display(LIST L)
{
    EDGE *p;
    for(int i=0;i<L.v;i++)
    {
        printf("NO.%d(%d) ",i,L.verlist[i].vertex);
        if(L.verlist[i].next==NULL)
        {
            printf("\n");
            break;
        }
        else
        {
            p=L.verlist[i].next;
            while(p!=NULL)
            {
                printf("%d ",p->index);
                p=p->next;
            }
            printf("\n");
        }
        
    }
}
MATRIX TransL_M(LIST L)
{
    MATRIX m;
    EDGE *p=NULL;
    m.vernum=L.v;
    for(int i=0;i<m.vernum;i++)
    {
        m.vertex[i]=L.verlist[i].vertex;
        for(int j=0;j<m.vernum;j++)
        {
            m.edge[i][j]=0;
        }
    }
    for(int i=0;i<L.v;i++)
    {
        p=L.verlist[i].next;
        while(p!=NULL)
        {
            m.edge[i][p->index]=1;
            p=p->next;
        }
    }
    return m;
}
LIST TransM_L(MATRIX m)
{
    LIST L;
    int count=0;
    L.v=m.vernum;
    for(int i=0;i<L.v;i++)
    {
        L.verlist[i].vertex=m.vertex[i];
        for(int j=0;j<L.v;j++)
        {
            if(m.edge[i][j]==1)
            {
                Append(L,i,j);
                count++;
            }
        }
    }
    L.e=count/2;
    return L;
}
void DFScomponents(MATRIX m)
{
    for(int i=0;i<m.vernum;i++)
    {
        if(visited[i]!=1)
        {
            DFS(m,i);
        }
    }
}
void DFS(MATRIX m,int n)
{
    visited[n]=1;
    printf("NO.%d(%d) ",n,m.vertex[n]);
    for(int j=0;j<m.vernum;j++)
    {
        if(m.edge[n][j]==1&&visited[j]!=1)
        {
            DFS(m,j);
        }
    }
}
void DFScomponents_list(LIST L)
{
    int n;
    printf("\nChoose a vertex to start DFS(list):");
    scanf("%d",&n);
    DFS_list(L,n);
    for(int i=0;i<L.v;i++)
    {
        if(visited[i]==0)
            DFS_list(L,i);
    }
}
void DFS_list(LIST L,int n)
{
    EDGE *p;
    visited[n]=1;
    printf("NO.%d(%d) ",n,L.verlist[n].vertex);
    if(L.verlist[n].next!=NULL)
    {
        p=L.verlist[n].next;
        while(p!=NULL&&visited[p->index]==0)
        {
            DFS_list(L,p->index);
            p=p->next;
        }
    }
}
void nDFS(MATRIX m,int n)
{
    int stack[MAX];
    int last=-1;
    int flag=0,i;
    stack[++last]=n;
    printf("No.%d(%d) ",n,m.vertex[n]);
    nvisited[n]=1;
    while(last>-1)
    {
        i=stack[last];
        flag=0;
        for(int j=0;j<m.vernum;j++)
        {
            if(m.edge[i][j]==1&&nvisited[j]==0)
            {
                stack[++last]=j;
                printf("No.%d(%d) ",j,m.vertex[j]);
                nvisited[j]=1;
                flag=1;
                break;
            }
        }
        if(flag==0)
        {
            last--;
        }
    }
}
void nDFS_list(LIST L)
{
    for(int i=0;i<L.v;i++)
    {
        visited[i]=0;
    }
    int stack[MAX];
    int last=-1;
    int flag=0;
    int n,i;
    EDGE *p;
    printf("\nChoose a vertex to start nDFS_list:");
    scanf("%d",&n);
    stack[++last]=n;
    printf("No.%d(%d) ",n,L.verlist[n].vertex);
    visited[n]=1;
    while(last>-1)
    {
        i=stack[last];
        flag=0;
        if(L.verlist[i].next!=NULL)
        {
            p=L.verlist[i].next;
            while(p!=NULL)
            {
                if(visited[p->index]==0)
                {
                    stack[++last]=p->index;
                    printf("No.%d(%d) ",p->index,L.verlist[p->index].vertex);
                    visited[p->index]=1;
                    flag=1;
                    break;
                }
                p=p->next;
            }
        }
        if(flag==0)
        {
            last--;
        }
    }
}
void BFScomponents(MATRIX m)
{
    int n;
    printf("\nChoose a vertex to start BFS:");
    scanf("%d",&n);
    BFS(m,n);
    for(int i=0;i<m.vernum;i++)
    {
        if(visited[i]==0)
            BFS(m,i);
    }
}
void BFScomponents_list(LIST L)
{
    for(int i=0;i<L.v;i++)
    {
        visited[i]=0;
    }
    int n;
    printf("\nChoose a vertex to start BFS_list:");
    scanf("%d",&n);
    BFS_list(L,n);
    for(int i=0;i<L.v;i++)
    {
        if(visited[i]==0)
            BFS_list(L,i);
    }
}
void BFS(MATRIX m,int n)
{
    int queue[MAX];
    int front=0,rear=0;
    int i;
    printf("No.%d(%d) ",n,m.vertex[n]);
    visited[n]=1;
    queue[rear++]=n;
    while(front!=rear)
    {
        i=queue[front++];
        for(int j=0;j<m.vernum;j++)
        {
            if(m.edge[i][j]==1&&visited[j]==0)
            {
                printf("No.%d(%d) ",j,m.vertex[j]);
                visited[j]=1;
                queue[rear++]=j;
            }
        }
    }

}
void BFS_list(LIST L,int n)
{
    EDGE *p;
    int queue[MAX];
    int front=0,rear=0;
    int i;
    printf("N0.%d(%d) ",n,L.verlist[n].vertex);
    visited[n]=1;
    queue[rear++]=n;
    while(front!=rear)
    {
        i=queue[front++];
        if(L.verlist[i].next!=NULL)
        {
            p=L.verlist[i].next;
            while(p!=NULL)
            {
                if(visited[p->index]==0)
                {
                    printf("No.%d(%d) ",p->index,L.verlist[p->index].vertex);
                    visited[p->index]=1;
                    queue[rear++]=p->index;
                }
                p=p->next;
            }
        }
    }
}

 

TC_Ning
关注
  • 2
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2020年秋哈工大数据结构作业4
07-12
图形结构及其应用
哈尔滨工业大学数据结构试题
03-27
本套试题中包含了所有的数据结构要点，是学习和巩固数据结构必备的宝典
哈工大数据结构作业4-图形结构及其应用
qq_45853731的博客
07-12 1484
  本文是笔者2020年秋哈工大数据结构作业3自己的代码，由于本人能力有限，可能存在一些错误，欢迎指出。   本次作业是有向图和无向图二选一，笔者选的是有向图。 完整源代码链接：https://download.csdn.net/download/qq_45853731/20213288?spm=1001.2014.3001.5503   本文仅供参考，严禁抄袭！ 文章目录作业题目：图的存储结构的建立与搜索存储结构分别实现有向图的邻接矩阵和邻接表存储结构的建立算法，分析和比较各建立算法的时间复杂度以及存储结
哈尔滨工业大学 数据结构期末总复习（二）
最新发布
m0_72741580的博客
11-19 318
在带权的有向图中，用顶点表示事件，边表示活动，权表示活动的持续时间。每个事件表示在它之前的活动已经完成，在它之后的活动可以开始。由于活动只有一个开始点和一个结束点，所以在正常情况下，AOE网只有一个入度为0的点，称为起始点（源点）；一个出度为0的点，称为结束点（汇点）。
无向图（无权值）的邻接矩阵与邻接表储存方式及其DFS，BFS遍历
Specif1c的博客
11-26 7254
求下图中无向图的邻接矩阵与邻接表储存方式及其DFS，BFS遍历 一、 无向图（无权值）的邻接矩阵存储方式及其DFS，BFS遍历 邻接矩阵的储存表示： 广度优先遍历需要用到队列操作，因此还需要定义一下队列的存储结构 具体代码： #include <stdio.h> #define MaxVex 100 //最大顶点数 #define TRUE 1 #define FALSE 0 typedef char VertexType;
哈工大数据结构实验三——图形结构及其应用
weixin_45406155的博客
11-03 6010
数据结构实验三目录0.实验要求1.实验思路1.1实现图的存储1.1.1 图的邻接矩阵存储1.1.2 使用图的邻接矩阵建立一个图1.1.3 图的邻接表存储1.1.4 使用图的邻接表建立一个图 0.实验要求 1.实验思路 1.1实现图的存储 1.1.1 图的邻接矩阵存储 图的邻接矩阵存储就是，把图看成是一个二维矩阵，矩阵A[i][j]的值就表示节点i和节点j之间的边的权重，如果顶点i和顶点j之间没有边，则设置A[i][j] = 正无穷大。 因此，用邻接矩阵的形式存储图的结构，我们需要以下三个信息 邻接矩阵
哈工大数据结构与算法实验4
阳光心态，健康人生的博客
09-14 1605
实验要求写一个快速排序算法，实现数据的快速排序思路随便网上都能找到快排算法，然后照抄就ok。。。当然理解快排是必要的，只是快排不是很好理解，详情请百度#include <iostream> using namespace std; void sort(int* a,int x,int y){ int xx=x,yy=y; int k=a[x]; if (x>
哈工大数据结构作业2-线性结构及其应用
qq_45853731的博客
07-12 649
  本文是笔者2020年秋哈工大数据结构作业1自己的代码，由于本人能力有限，可能存在一些错误，欢迎指出。   本文仅供参考，严禁抄袭！   2020年秋的作业2是二选一，笔者选的是算术表达式求值。由于撰写该篇博文时距编写该作业源代码已有半年多的时间，因此再看这些代码，思路早已不清晰。这里只将代码放上，恕难详细描述思路，希望有心的读者耐心阅读源码，若有不通之处可评论或私聊。 文章目录基本数据结构辅助函数从文本文件输入任意一个语法正确的（中缀）表达式，显示并保存该表达式利用栈结构，把上述（中缀）表达式转换成后缀
哈工大数据结构作业1-线性结构的存储结构与应用
qq_45853731的博客
07-12 726
 本文是笔者2020年秋哈工大数据结构作业1自己的代码，由于本人能力有限，可能存在一些错误，欢迎指出。 文章目录线性表的顺序存储结构顺序存储结构的定义删除给定元素的算法对于已排好序的线性表，删除所有重复元素的算法线性表“逆置”算法线性表循环左移/右移 k 位的算法合并两个已排好序的线性表的算法辅助函数主函数线性表的链式存储结构链式存储结构的定义删除给定元素的算法对于已排好序的线性表，删除所有重复元素的算法线性表“逆置”算法线性表循环左移/右移 k 位的算法合并两个已排好序的线性表的算法辅助函数主函数 线性表
哈工大数据结构作业5-查找结构与排序方法
qq_45853731的博客
07-12 785
  本文是笔者2020年秋哈工大数据结构作业5自己的代码，由于本人能力有限，可能存在一些错误，欢迎指出。   本次作业是二选一，临近期末，笔者就选了个比较水的败者树。 文章目录作业题目：利用败者树实现锦标赛排序（树形选择排序）设计败者树的存储结构利用败者树实现锦标赛排序 作业题目：利用败者树实现锦标赛排序（树形选择排序）   败者树实际上是一棵完全二叉树，可以看作是胜者树的一种变体。败者树简化了重构，败者树的重构只是与该结点的父结点的记录有关，而胜者树的重构还与该结点的兄弟结点有关。败者树作为一种重要的数据
数据结构作业4
m0_60538401的博客
12-30 716
4
哈工大数据结构作业树部分
05-17
哈工大数据结构
哈工大数据结构实验三_图形结构及其应用
03-26
实验项目：图型结构的建立与搜索 实验题目：图的存储结构的建立与搜索 实验内容 1： 图的搜索（遍历）算法是图型结构相关算法的基础，本实验要求编写程序 演示无向图典型存储结构的建立和搜索（遍历）过程。 实验...
作业4-图型结构及其应用1
08-03
1．分别实现无向图的邻接矩阵和邻接表存储结构的建立算法，分析和比较各建 2．实现无向图的邻接矩阵和邻接表两种存储结构的相互转换算法 3．在上述两种存储结构上，分
约瑟夫生者死者游戏-Python数据结构与算法实战项目完整源码与界面资源
07-01
约瑟夫生者死者问题是数据结构与算法中的经典问题，本项目基于单向循环链表这一数据结构实现，并使用 tkinter技术 实现约瑟夫问题的可视化。项目使用了图形用户界面GUI技术，使用的开发工具为PyCharm 2021.3。实现了...
作业3-图型结构及其应用1
08-03
1． 实现单源最短路径的 Dijkstra 算法，输出源点及其到其他顶点的最短路径长 2． （选做）利用堆结构，改进和优化 Dijkstra 算法的实现 4．
C++数据结构之图的存储结构——邻接矩阵和邻接表实现无向图
m0_56398315的博客
08-15 7706
本文通过两种方式：1.邻接矩阵2.邻接表 构建无向图，其中对邻接表构建无向图有详细的介绍、流程图、和相关代码图示。
数据结构与算法--图型结构的建立与搜索
djj810625的博客
03-05 438
**课程名称：数据结构与算法 课程类型：必修 实验项目：图型结构的建立与搜索 实验题目：图的存储结构的建立与搜索 实验日期：2017/12/3** 一、实验目的 图的搜索（遍历）算法是图型结构相关算法的基础，本实验要求编写程序演示无向图三种典型存储结构的建立和搜索（遍历）过程。让我们在这个过程中熟悉这些操作之间的关系和内...
数据结构算法与应用c 语言描述答案
10-12
数据结构算法是计算机科学中的一个基础概念，是解决问题和优化计算机程序的关键。而C语言是一种广泛应用于系统开发和高性能应用程序的编程语言。在C语言中，可以使用各种数据结构和算法来实现一些特定的应用。 数据结构就是存储和组织数据的方式，它决定了数据的访问和操作效率。C语言提供了很多基本的数据结构，例如数组、链表、栈和队列等。这些数据结构在C语言中可以用结构体或者指针的方式实现。通过使用这些数据结构，可以更加高效地存储和管理数据。 算法是解决问题的步骤和方法，可以用来处理各种各样的问题。在C语言中，可以使用不同的算法来实现对数据的操作。例如，排序算法可以对一组数据进行排序，搜索算法可以在一组数据中查找指定的元素。通过选择合适的算法，可以提高程序的性能和效率。 数据结构和算法的应用非常广泛。在系统开发中，可以使用数据结构和算法来实现文件系统、图形界面和数据库等。在游戏开发中，可以使用数据结构和算法来处理游戏场景、物理模拟和碰撞检测等。在网络通信中，可以使用数据结构和算法来处理数据包的传输和接收。 总之，数据结构算法与C语言的应用密切相关。通过学习和掌握数据结构和算法，并使用C语言进行描述和实现，可以提高程序的性能和效率，解决各种问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值