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

TC_Ning

墨衍会员 · AI 创作全网分发码龄6年

关注

原创最新推荐文章于 2026-06-19 11:38:32 发布 1.7k 阅读 AI 写同款· GEO 优化 ›

数据结构与算法作业1——线性结构的存储结构与应用（SeqList） 哈工大数据结构与算法作业1中顺序存储部分，小白一枚，仅以此博客记录学习过程，恳请批评指正。阅读详情

作业题目 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;
            }
        }
    }
}

收录于