合工大 宣区 数据结构 图实验

最新推荐文章于 2024-11-04 13:52:23 发布
最新推荐文章于 2024-11-04 13:52:23 发布
阅读量782 收藏 19
点赞数 4
分类专栏： 学海无涯 文章标签： 数据结构 算法 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AWP2020/article/details/128921598
版权

图

1.实验目标

(1) 掌握图的基本概念。
(2) 掌握图的存储结构的设计与实现，基本运算的实现。
(3) 熟练掌握图的两种遍历算法、遍历生成树及遍历算法的应用。

2.实验内容和要求

分别设计图（网）的邻接矩阵、邻接表存储结构，编写算法实现下列问题的求解。
1．打印出图（网）的两种遍历序。
实验测试数据基本要求：
第一组数据： udg8.grp
第二组数据： udg115.grp
第三组数据： dg6.grp
第四组数据： f14.grp

2．求给定图中的边（或弧）的数目。 实验测试数据基本要求：第一组数据： udg8.grp
第二组数据： udg115.grp
第三组数据： dg6.grp
第四组数据： f14.grp

3．对给定的图G及出发点v0，设计算法从V0出发深度优先遍历图G，并构造出相应的生成树或生成森林。
实验测试数据基本要求：
第一组数据： udg8.grp
第二组数据： dg6.grp
第三组数据： un8.grp
第四组数据： dn10.grp

4．对给定的图G及出发点v0，设计算法从V0出发广度优先遍历图G，并构造出相应的生成树或生成森林。
第一组数据： udg8.grp
第二组数据： dg6.grp
第三组数据： un8.grp
第四组数据： dn10.grp

5．实现Prim算法，求解下列给定图G的最小生成树。 实验测试数据基本要求：第一组数据： udn6.grp
第二组数据： un8.grp

6．实现Kruskal算法，求解下列给定图G的最小生成树。 实验测试数据基本要求：第一组数据： udn6.grp
第二组数据： un8.grp

7．实现Dijkstra算法，求解下列给定图G指定顶点到其余顶点之间的最短路径。 实验测试数据基本要求：第一组数据： udn6.grp
第二组数据： un8.grp
第三组数据： dn8.grp
第四组数据： dn10.grp

8．实现Floyd算法，求解下列给定图G各顶点之间的最短路径。 实验测试数据基本要求：第一组数据： udn6.grp
第二组数据： un8.grp
第三组数据： dn8.grp
第四组数据： dn10.grp

9．设计算法求解下列给定图G的拓扑序列。 实验测试数据基本要求：
第一组数据： top6dg1.grp
第二组数据： top7dg1.grp
第三组数据： dn8.grp
第四组数据： dn10.grp

10．设计算法求解下列给定AOE网的关键路径。 实验测试数据基本要求：
第一组数据： dn8.grp
第二组数据： dn10.grp

3.数据结构设计

#ifndef GRAPH_H_INCLUDED
#define GRAPH_H_INCLUDED
#include"makegraph1.h"
#include"makegraph2.h"
#define maxlen 100
typedef struct squeue
{
    int data[maxlen];
    int lfront;
    int lrear;
}seqqueue;

typedef struct tnode
{
    char data;
    struct tnode *firstson,*nextbrother;
}tnode;

typedef struct minEdgeType
{
    int v;
    int e;
    cellType eweight;
}minedgetype;

typedef struct edgetype
{
    int vbegin;
    int vend;
    eInfoType eweight;
}edgetype;

typedef struct iStack
{
    int data[maxlen];
    int top;
}seqstack;

seqqueue initialqueue(seqqueue q) //初始化一个队列。
{
    q.lfront = 0;
    q.lrear = 0;
    return q;
}

seqqueue enqueue(seqqueue q,int x) //入队
{
    if(((q.lrear+1)%maxlen)!=q.lfront)
    {
        q.lrear = ((q.lrear+1)%maxlen);
        q.data[q.lrear] = x;
    }
    return q;
}

seqqueue outqueue(seqqueue q) //出队
{
    if(((q.lrear+1)%maxlen)!=q.lfront)
    {
        q.lfront = (q.lfront+1)%maxlen;
    }
    return q;
}

int queueempty(seqqueue q) //判断是否队空。
{
    if(q.lfront==q.lrear)
    {
        return 1;//队列为空。
    }
    else
    {
        return 0;//队列不为空
    }
}

int queuefront(seqqueue q,int x) //取队头元素
{
    if(q.lfront==q.lrear)
    {
        x = -1;
    }
    else
    {
        x = q.data[(q.lfront+1)%maxlen];
    }
    return x;
}

tnode * makenode(char x)//构成结点
{
    tnode *t;
    t = (tnode *)malloc(sizeof(tnode));
    t->data = x;
    t->firstson = NULL;
    t->nextbrother = NULL;
    return t;
}

void printforestnode(tnode *t,int i) //先序输出结点值及其层次号。
{
    int a;
    if(t!=NULL)
    {
        a = i+1;
        printf("%c\t%d\n",t->data,i);
        printforestnode(t->firstson,a);
        printforestnode(t->nextbrother,i);
    }
}

void destorybitree(tnode *t) //销毁二叉树
{
    if(t!=NULL)
    {
        destorybitree(t->firstson);
        destorybitree(t->nextbrother);
        free(t);
    }
}

tnode * searchnode(tnode *t,char x)//在二叉树中寻找结点
{
    tnode *p,*q;
    if(t!=NULL)
    {
        if(t->data==x)
        {
            return t;
        }
        p = searchnode(t->firstson,x);
        q = searchnode(t->nextbrother,x);
        if(p!=NULL)
        {
            return p;
        }
        else
        {
            return q;
        }
    }
    else
    {
        return NULL;
    }
}

int stackfull(seqstack s)//判断栈满
{
    if(s.top==maxlen-1)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

seqstack pushstack(seqstack s,int x)//入栈
{
    if(stackfull(s)==0)
    {
        s.top++;
        s.data[s.top] = x;
        return s;
    }
}

int stackempty(seqstack s)//判断栈空
{
    if(s.top==-1)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

int popstack(seqstack s,int x)//出栈
{
    if(stackempty(s)==0)
    {
        x = s.data[s.top];
        s.top--;
        return x;
    }
}
//*****************************************************************************************************************************************************
void dfs(Graph g,int ver) //邻接矩阵 1．打印出图（网）的两种遍历序。深度优先
{
    int w;
    printf("%c\t",g.Data[ver]);
    visited[ver] = 1;
    for(w=1;w<=g.VerNum;w=w+1)
    {
        if((g.AdjMatrix[ver][w]>=1)&&(g.AdjMatrix[ver][w]<INF))
        {
            if(visited[w]==0)
            {
                dfs(g,w);
            }
        }
    }
}

void dfst(Graph g)
{
    int i;
    for(i=1;i<=g.VerNum;i=i+1)
    {
        visited[i] = 0;
    }
    for(i=1;i<=g.VerNum;i++)
    {
        if(visited[i]==0)
        {
            dfs(g,i);
        }
    }
}

void bfst(Graph g)//广度遍历
{
    int i,u,w;
    seqqueue q;
    q = initialqueue(q);
    for(i=0;i<=MaxVerNum;i=i+1)
    {
        visited[i] = 0;
    }
    for(i=1;i<=g.VerNum;i=i+1)
    {
        if(visited[i]==0)
        {
            printf("%c\t",g.Data[i]);
            visited[i] = 1;
            q = enqueue(q,i);

            while(queueempty(q)==0)
            {
                u = queuefront(q,u);
                q = outqueue(q);

                for(w=1;w<=g.VerNum;w=w+1)
                {
                    if((g.AdjMatrix[u][w]>=1)&&(g.AdjMatrix[u][w]<INF)&&(visited[w]==0))
                    {
                        printf("%c\t",g.Data[w]);
                        visited[w] = 1;
                        q = enqueue(q,w);
                    }
                }
            }
        }
    }
}

int Edgenum(Graph g) //2．求给定图中的边（或弧）的数目。
{
    int i,j,Enum=0;
    for(i=1;i<=g.VerNum;i++)
    {
        for(j=1;j<=g.VerNum;j++)
        {
            if((g.AdjMatrix[i][j]>=1)&&(g.AdjMatrix[i][j]<INF))
            {
                Enum++;
            }
        }
    }
    Enum = Enum/2;
    return Enum;
}

tnode * maketreefromgraphdfs(Graph g,int v0)//3．对给定的图G及出发点v0，设计算法从V0出发深度优先遍历图G，并构造出相应的生成树或生成森林。
{
    tnode *t,*p,*q;
    int i,w,j,k;

    for(i=0;i<MaxVerNum;i=i+1)
    {
        visited[i] = 0;
    }

    t = makenode(g.Data[v0]);
    visited[v0] = 1;
    for(w=1;w<=g.VerNum;w=w+1)
    {
        if((g.AdjMatrix[v0][w]>=1)&&(g.AdjMatrix[v0][w]<INF)&&(visited[w]==0))
        {
            p = makenode(g.Data[w]);
            visited[w] = 1;
            q = t;
            if(q->firstson==NULL)
            {
                q->firstson = p;
            }
            else
            {
                q = q->firstson;
                while(q->nextbrother!=NULL)
                {
                    q = q->nextbrother;
                }
                q->nextbrother = p;
            }
        }
    }

    q = NULL;
    for(i=1;i<=g.VerNum;i=i+1)
    {
        if(visited[i]==0)
        {
            p = makenode(g.Data[i]);
            visited[i] = 1;

            for(k=1;k<=g.VerNum;k++)
            {
                if(g.AdjMatrix[k][i]>0 && g.AdjMatrix[k][i]<INF && visited[k]==1)
                {
                    q = searchnode(t,g.Data[k]);
                    if(q->firstson==NULL)
                    {
                        q->firstson = p;
                    }
                    else
                    {
                        q = q->firstson;
                        while(q->nextbrother!=NULL)
                        {
                            q = q->nextbrother;
                        }
                        q->nextbrother = p;
                    }
                    break;
                }
            }

            if(q==NULL)
            {
                q = t;
                while(q->nextbrother!=NULL)
                {
                    q = q->nextbrother;
                }
                q->nextbrother = p;
            }

            for(w=1;w<=g.VerNum;w=w+1)
            {
                if((g.AdjMatrix[i][w]>=1)&&(g.AdjMatrix[i][w]<INF)&&(visited[w]==0))
                {
                    p = makenode(g.Data[w]);
                    visited[w] = 1;
                    q = searchnode(t,g.Data[i]);

                    if(q->firstson==NULL)
                    {
                        q->firstson = p;
                    }
                    else
                    {
                        q = q->firstson;
                        while(q->nextbrother!=NULL)
                        {
                            q = q->nextbrother;
                        }
                        q->nextbrother = p;
                    }
                }
            }
        }
    }
    return t;
}

tnode * maketreefromgraphbfs(Graph g,int v0)//4．对给定的图G及出发点v0，设计算法从V0出发广度优先遍历图G，并构造出相应的生成树或生成森林。
{
    tnode *t,*p,*m;
    int u,w,i,k;
    seqqueue q;

    for(i=0;i<=MaxVerNum;i=i+1)
    {
        visited[i] = 0;
    }
    q = initialqueue(q);

    t = makenode(g.Data[v0]);
    visited[v0] = 1;
    q = enqueue(q,v0);

    while(queueempty(q)==0)
    {
        u = queuefront(q,u);
        q = outqueue(q);

        for(w=1;w<=g.VerNum;w=w+1)
        {
            if((g.AdjMatrix[u][w]>=1)&&(g.AdjMatrix[u][w]<INF)&&(visited[w]==0))
            {
                p = makenode(g.Data[w]);
                visited[w] = 1;
                q = enqueue(q,w);
                m = searchnode(t,g.Data[u]);

                if(m->firstson==NULL)
                {
                    m->firstson = p;
                }
                else
                {
                    m = m->firstson;
                    while(m->nextbrother!=NULL)
                    {
                        m = m->nextbrother;
                    }
                    m->nextbrother = p;
                }
            }
        }
    }
    return t;
}

int path[MaxVerNum],dist[MaxVerNum];
void Dijkstra(Graph g,int vid)//7．实现Dijkstra算法，求解下列给定图G指定顶点到其余顶点之间的最短路径。
{
    int solved[MaxVerNum];
    int i,j,v;
    cellType mindist;

    for(i=1;i<=g.VerNum;i++)
    {
        for(j=1;j<=g.VerNum;j++)
        {
            if(g.AdjMatrix[i][j]==0)
            {
                g.AdjMatrix[i][j] = INF;
            }
        }
    }

    for(i=1;i<=g.VerNum;i=i+1)
    {
        solved[i] = 0;
        dist[i] = g.AdjMatrix[vid][i];

        if((dist[i]!=INF)&&(dist[i]!=0))
        {
            path[i] = vid;
        }
        else
        {
            path[i] = -1;
        }
    }
    solved[vid] = 1;
    dist[vid] = 0;
    path[i] = -1;

    for(i=1;i<g.VerNum;i++)
    {
        mindist = INF;
        for(j=1;j<=g.VerNum;j++)
        {
            if(solved[j]==0 && dist[j]<mindist && dist[j]>0)
            {
                v = j;
                mindist = dist[j];
            }
        }

        if(mindist==INF)
        {
            continue;
        }
        printf("选择顶点：%c\t距离：%d\n",g.Data[v],mindist);
        solved[v] = 1;

        for(j=1;j<=g.VerNum;j++)
        {
            if(solved[j]==0 && (mindist+g.AdjMatrix[v][j])<dist[j])
            {
                dist[j] = mindist+g.AdjMatrix[v][j];
                path[j] = v;
            }
        }
    }
}

void printDijkstra(Graph g,int vid)
{
    int spath[MaxVerNum];
    int vpre;
    int top = -1;
    int i,j;

    for(i=1;i<=g.VerNum;i++)
    {
        printf("%c to %c\n",g.Data[vid],g.Data[i]);
        if(dist[i]==INF || vid==i)
        {
            printf("无可达路径。\n");
        }
        else
        {
            printf("最短路径：%d\n",dist[i]);
            printf("路 径：\n");
        }

        top++;
        spath[i] = i;
        vpre = path[i];

        while(vpre!=-1)
        {
            top++;
            spath[top] = vpre;
            vpre = path[vpre];
        }

        if(dist[i]!=INF)
        {
            for(j=top;j>=0;j--)
            {
                printf("%c\t",g.Data[spath[j]]);
            }
        }
        printf("\n\n");
        top = -1;
    }
}

int Dist[MaxVerNum][MaxVerNum];
void Floyd(Graph g)//8．实现Floyd算法，求解下列给定图G各顶点之间的最短路径。
{
    int i,j,m,n;

    for(i=1;i<=g.VerNum;i++)
    {
        for(j=1;j<=g.VerNum;j++)
        {
            Dist[i][j] = g.AdjMatrix[i][j];
            if(Dist[i][j]==0)
            {
                Dist[i][j] = INF;
            }

            if(i==j)
            {
                Dist[i][j] = 0;
            }
        }
    }

    for(n=1;n<=g.VerNum;n++)
    {
        for(i=1;i<=g.VerNum;i++)
        {
            for(m=1;m<=g.VerNum;m++)
            {
                for(j=1;j<=g.VerNum;j++)
                {
                    if(Dist[i][j]>Dist[i][m]+Dist[m][j])
                    {
                        Dist[i][j] = Dist[i][m]+Dist[m][j];
                    }
                }
            }
        }
    }

    printf("起点：\t终点：\t最短距离：\n");
    for(i=1;i<=g.VerNum;i++)
    {
        for(j=i+1;j<=g.VerNum;j++)
        {
            if(Dist[i][j]<INF)
            {
                printf("%d\t%d\t%d\n",i,j,Dist[i][j]);
            }
        }
    }
}

int inds[MaxVerNum];
void getindegree(Graph g)//9．设计算法求解下列给定图G的拓扑序列。
{
    int i,j;
    for(j=1;j<=g.VerNum;j++)
    {
        for(i=1;i<=g.VerNum;i++)
        {
            if(g.AdjMatrix[i][j]>0 && g.AdjMatrix[i][j]<INF)
            {
                inds[j]++;
            }
        }
    }
}

int topolist[MaxVerNum];
int topologicalsort(Graph g)
{
    seqstack s;
    int i,v;
    int vcount=0;

    s.top = -1;
    for(i=1;i<=g.VerNum;i++)
    {
        inds[i] = 0;
    }

    for(i=1;i<=g.VerNum;i++)
    {
        topolist[i] = -1;
    }

    getindegree(g);
    for(i=1;i<=g.VerNum;i++)
    {
        if(inds[i]==0)
        {
            s = pushstack(s,i);
        }
    }

    while(stackempty(s)==0)
    {
        v = popstack(s,v);
        s.top--;
        topolist[vcount] = v;
        vcount++;

        for(i=1;i<=g.VerNum;i++)
        {
            if(g.AdjMatrix[v][i]>=1 && g.AdjMatrix[v][i]<INF && inds[i]>0)
            {
                inds[i]--;
                if(inds[i]==0)
                {
                    s = pushstack(s,i);
                }
            }
        }
    }

    if(vcount==g.VerNum)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

void findkeyroad(Graph g) //10．设计算法求解下列给定AOE网的关键路径。
{
    int a,i,j,k=1;
    int havecross[MaxVerNum][MaxVerNum];
    minedgetype road[MaxVerNum],x[MaxVerNum];

    a = topologicalsort(g);

    if(a==0)
    {
        printf("有回路。\n");
        return;
    }
    for(i=1;i<=g.VerNum;i++)
    {
        for(j=1;j<=g.VerNum;j++)
        {
            havecross[i][j] = 0;
        }
    }

    for(i=1;i<=g.VerNum;i++)
    {
        for(j=1;j<=g.VerNum;j++)
        {
            if(g.AdjMatrix[i][j]>0 && g.AdjMatrix[i][j]<INF)
            {
                road[k].eweight = g.AdjMatrix[i][j];
                road[k].v = i;
                road[k].e = j;

                x[k].eweight = g.AdjMatrix[i][j];
                x[k].v = i;
                x[k].e = j;
                k++;
            }
        }
    }
    a = k;
    j = 1;

    for(k=1;k<=a;k++)
    {
        havecross[k][j] = x[k].v;
        j++;
        havecross[k][j] = x[k].e;
        j++;

        for(i=1;i<=a;i++)
        {
            if(x[k].e==road[i].v)
            {
                x[k].e = road[i].e;
                x[k].eweight = x[k].eweight+road[i].eweight;
                havecross[k][j] = road[i].e;
                j = j+1;
                i = 1;
            }
        }
        j = 1;
    }

    k = x[1].eweight;
    for(i=1;i<=a;i++)
    {
        if(k<x[i].eweight)
        {
            k = x[i].eweight;
            j = i;
        }
    }

    printf("关键路径的长度为：%d\n",k);
    printf("经过的路径为：\n");
    for(i=1;i<=g.VerNum;i++)
    {
        if(havecross[j][i]!=0)
        {
            printf("%d\t",havecross[j][i]);
        }
    }
}
//*****************************************************************************************************************************************************
int HasEdge(Graphe g,int vbegin,int vend,int eweight) //5．实现Prim算法，求解下列给定图G的最小生成树。
{//判断两点之间是否相连，并返回边的权值。
    EdgeNode *p;
    int f=0;
    eweight = INF;
    p = g.VerList[vbegin].firstEdge;

    while(p!=NULL)
    {
        if(p->adjVer==vend)
        {
            eweight = p->eInfo;
            f = eweight;
            break;
        }
        p = p->next;
    }
    return f;
}

void InitialTE(Graphe g,minedgetype te[],int vid)//初始化数组te
{
    int i;
    int eweight;
    for(i=1;i<=g.VerNum;i++)
    {
        if(HasEdge(g,vid,i,eweight)!=0)
        {
            eweight = HasEdge(g,vid,i,eweight);
            te[i-1].v = vid;
            te[i-1].e = i;
            te[i-1].eweight = eweight;
        }
        else
        {
            te[i-1].eweight = INF;
        }
    }
}

int getminedge(Graphe g,minedgetype te[])//获取权值最小的边
{
    eInfoType eMin=INF;
    int i,j=0;

    for(i=1;i<=g.VerNum;i++)
    {
        if((visited[i]==0)&&(te[i-1].eweight<eMin))
        {
            j = i;
            eMin = te[i-1].eweight;
        }
    }
    return j;
}

void updatete(Graphe g,minedgetype te[],int vid)//当顶点vid被选中后变为已选顶点，更新选边集合。
{
    int i,j;
    eInfoType eweight;

    for(i=1;i<=g.VerNum;i++)
    {
        if(visited[i]==0)
        {
            if((HasEdge(g,vid,i,eweight)!=0)&&(eweight<te[i-1].eweight))
            {
                eweight = HasEdge(g,vid,i,eweight);
                te[i-1].v = vid;
                te[i-1].e = i;
                te[i-1].eweight = eweight;
            }
        }
    }
}

void Prim(Graphe g,int vid)//从vid开始的prim算法
{
    minedgetype te[MaxVerNum+1];
    int i,cur;

    for(i=0;i<=MaxVerNum;i=i+1)
    {
        visited[i] = 0;
    }

    InitialTE(g,te,vid);
    visited[vid] = 1;

    for(i=1;i<=g.VerNum;i=i+1)
    {
        cur = getminedge(g,te);
        visited[cur] = 1;
        updatete(g,te,cur);
    }

    printf("起 点：\t终 点：\t选定的边的权值:\n");
    for(i=1;i<g.VerNum;i=i+1)
    {
        printf("%d\t%d\t%d\n",te[i].v,te[i].e,te[i].eweight);
    }
}

void getedges(Graphe g,edgetype edges[])//6．实现Kruskal算法，求解下列给定图G的最小生成树。
{//从原联通网中读取边的信息，并储存。
    int i,k=0;
    EdgeNode *p;

    for(i=1;i<=g.VerNum;i++)
    {
        p = g.VerList[i].firstEdge;
        while(p!=NULL)
        {
            edges[k].vbegin = LocateVertexe(g,g.VerList[i].data);
            edges[k].vend = p->adjVer;
            edges[k].eweight = p->eInfo;
            p = p->next;
            k++;
        }
    }
}

int n=0;
edgetype getminedgewithedgetype(Graphe g,edgetype edges[],int edgeused[])//获取最小的边
{
    edgetype minedge;
    cellType wmin=INF;
    int i,m;

    if(g.gKind==UDG || g.gKind==UDN)
    {
        m = g.ArcNum*2;
    }
    else
    {
        m = g.ArcNum;
    }

    for(i=1;i<=m;i++)
    {
        if((edgeused[i]==0)&&(edges[i].eweight<wmin))
        {
            wmin = edges[i].eweight;
            minedge.eweight = edges[i].eweight;
            minedge.vbegin = edges[i].vbegin;
            minedge.vend = edges[i].vend;
            n = i;
        }
    }
    return minedge;
}

void Kruskal(Graphe g)
{
    int converid[MaxVerNum+1];
    edgetype edges[MaxVerNum*MaxVerNum];
    edgetype treeedges[MaxVerNum+1];
    int edgeused[MaxVerNum*MaxVerNum];

    edgetype minedge;
    int i,j,k=0;
    int conid,m;
    n = 0;

    getedges(g,edges);
    if(g.gKind==UDG || g.gKind==UDN)
    {
        m = g.ArcNum*2;
    }
    else
    {
        m = g.ArcNum;
    }

    for(i=0;i<=m;i++)
    {
        edgeused[i] = 0;
    }
    for(i=1;i<=g.VerNum;i++)
    {
        converid[i] = i;
    }

    for(i=1;i<=g.VerNum;i++)
    {
        minedge = getminedgewithedgetype(g,edges,edgeused);
        while(converid[minedge.vbegin]==converid[minedge.vend])
        {
            edgeused[n] = 1;
            minedge = getminedgewithedgetype(g,edges,edgeused);

        }
        treeedges[i] = minedge;
        conid = converid[minedge.vend];
        for(j=1;j<g.VerNum;j++)
        {
            if(converid[j]==conid)
            {
                converid[j] = converid[minedge.vbegin];
            }
        }
        edgeused[n] = 1;
    }

    printf("起 点：\t终 点:\t边的权值：\n");
    for(i=1;i<g.VerNum;i++)
    {
        printf("%d\t%d\t%d\n",treeedges[i].vbegin,treeedges[i].vend,treeedges[i].eweight);
    }
}
#endif // GRAPH_H_INCLUDED


#include"graph.h"

int main(void)
{
    char filename[20];
    Graph g;
    Graphe G;
    int m;

    ss:
    printf("图实验任务:\n");
    printf("1．打印出图（网）的两种遍历序。\n");
    printf("2．求给定图中的边（或弧）的数目。\n");
    printf("3．对给定的图G及出发点v0，设计算法从V0出发深度优先遍历图G，并构造出相应的生成树或生成森林。\n");
    printf("4．对给定的图G及出发点v0，设计算法从V0出发广度优先遍历图G，并构造出相应的生成树或生成森林。\n");
    printf("5．实现Prim算法，求解下列给定图G的最小生成树。\n");
    printf("6．实现Kruskal算法，求解下列给定图G的最小生成树。\n");
    printf("7．实现Dijkstra算法，求解下列给定图G指定顶点到其余顶点之间的最短路径。\n");
    printf("8．实现Floyd算法，求解下列给定图G各顶点之间的最短路径。\n");
    printf("9．设计算法求解下列给定图G的拓扑序列。\n");
    printf("10．设计算法求解下列给定AOE网的关键路径。\n");
    printf("\n");

    printf("11.清屏。\n");
    printf("12.退出。\n");
    printf("\n");

    scanf("%d",&m);
    printf("\n");
    getchar();

    printf("\n");
    switch(m)
    {
    case 1:
        {
            printf("输入文件名。\n");
            gets(filename);
            g = CreateGrpFromFile(filename,g);
            printGraph(g);
            printf("\n");

            dfst(g);
            printf("\n");
            bfst(g);
            printf("\n");
            goto ss;
        }
    case 2:
        {
            int a;
            printf("输入文件名。\n");
            gets(filename);
            g = CreateGrpFromFile(filename,g);
            printGraph(g);
            printf("\n");

            a = Edgenum(g);
            printf("%d\n",a);
            goto ss;
        }
    case 3:
        {
            printf("输入文件名。\n");
            gets(filename);
            g = CreateGrpFromFile(filename,g);
            printGraph(g);
            printf("\n");

            tnode *t;
            int n;
            printf("输入出发点的编号：\n");
            scanf("%d",&n);
            t = maketreefromgraphdfs(g,n);
            printforestnode(t,1);
            destorybitree(t);
            goto ss;
        }
    case 4:
        {
            printf("输入文件名。\n");
            gets(filename);
            g = CreateGrpFromFile(filename,g);
            printGraph(g);
            printf("\n");

            tnode *t;
            int n;
            printf("输入出发点的编号：\n");
            scanf("%d",&n);
            t = maketreefromgraphbfs(g,n);
            printforestnode(t,1);
            destorybitree(t);
            goto ss;
        }
    case 5:
        {
            printf("输入文件名。\n");
            gets(filename);
            G = CreateGraphFromFile(filename,G);
            printGraphe(G);
            printf("\n");

            Prim(G,1);
            DestroyGraph(G);
            goto ss;
        }
    case 6:
        {
            printf("输入文件名。\n");
            gets(filename);
            G = CreateGraphFromFile(filename,G);
            printGraphe(G);
            printf("\n");

            Kruskal(G);
            DestroyGraph(G);
            goto ss;
        }
    case 7:
        {
            printf("输入文件名。\n");
            gets(filename);
            g = CreateGrpFromFile(filename,g);
            printGraph(g);
            printf("\n");

            int n;
            printf("输入指定结点的编号：\n");
            scanf("%d",&n);
            Dijkstra(g,n);
            printDijkstra(g,n);
            goto ss;
        }
    case 8:
        {
            printf("输入文件名。\n");
            gets(filename);
            g = CreateGrpFromFile(filename,g);
            printGraph(g);
            printf("\n");

            Floyd(g);
            goto ss;
        }
    case 9:
        {
            printf("输入文件名。\n");
            gets(filename);
            g = CreateGrpFromFile(filename,g);
            printGraph(g);
            printf("\n");

            int a;
            a = topologicalsort(g);
            if(a==1)
            {
                printf("拓扑序列为：\n");
                for(a=0;a<g.VerNum;a++)
                {
                    printf("%d\t",topolist[a]);
                }
                printf("\n");
            }
            else if(a==0)
            {
                printf("有回路，不能产生拓扑序列。\n");
            }
            goto ss;
        }
    case 10:
        {
            printf("输入文件名。\n");
            gets(filename);
            g = CreateGrpFromFile(filename,g);
            printGraph(g);
            printf("\n");

            findkeyroad(g);
            printf("\n");
            goto ss;
        }
    case 11:
        {
            system("cls");
            goto ss;
        }
    case 12:
        {
            goto mmo;
        }
    default:
        {
            printf("输入错误。\n");
            goto ss;
        }
    }
    mmo: system("cls");
}
AWP2020
关注
专栏目录
合肥工业大学 宣城校区 数据结构与算法实验 顺序表、单链表和栈
AWP2020的博客
02-07 506
大学实验
合肥工业大学 宣城校区 数据结构与算法实验 队列、二叉树、查找和排序
AWP2020的博客
02-07 1558
大学实验
合肥工业大学数据结构查找实验
12-27
数据结构查找实验代码 (1) 对下列数据表，分别采用二分查找算法实现查找，给出查找过程依次所比较的元素（的下标），并以二分查找的判定树来解释。 第一组测试数据： 数据表为 (1,2,3,4,6,7,8,9,10,11,12,13,17,18,19,20,24,25,26,30,35,40,45,50,,100) 查找的元素分别为： 2，8，20, 30，50，5，15，33，110 第二组数据： 数据表为 (2,3,5,7,8,10,12,15,18,20,22,25,30,35,40,45,50,55,60, 80,100) 查找的元素分别为： 22，8，80，3，100，1，13，120 (2) 设计出在二叉排序树中插入结点的算法，在此基础上实现构建二叉排序树的算法。 测试数据：构建二叉排序树的输入序列如下： 第一组数据： 100，150，120，50，70，60，80，170，180，160，110，30，40，35，175 第二组数据： 100，70，60，80，150，120，50，160，30，40，170，180，175，35 (3) 设计算法在二叉排序树中查找指定值的结点。 测试数据：在任务中第一组测试数据所构造的二叉排序树中，分别查找下列元素： 150，70，160，190，10，55，175 (4) 设计算法在二叉排序树中删除特定值的结点。 测试数据：在任务(1)中第一组测试数据所构造的二叉排序树中，分别删除下列元素：30，150，100 (5) 已知整型数组A[1..26]递增有序，设计算法以构造一棵平衡的二叉排序树来存放该数组中的所有元素。 测试数据：数组元素分别为： 第一组数据： （1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26） 第二组数据： （1,3,6,10,15,21,28,36,45,55,66,78,91,105,120,136,153,171,190,210,231,253,277,302,328）
合肥工业大学数据结构实验.zip
11-24
合肥工业大学数据结构实验仅供参考,所有报告全部写好，代码齐全，包括所有实验，都可以运行，方便使用，实验报告注意自行修改润色
java实验报告合肥工业大学_合肥工业大学数据结构上机实验代码与实验报告（全）github地址...
weixin_34094282的博客
03-02 468
C&plus;&plus;实现链队类——合肥工业大学数据结构实验5：链式队列实验5 5.1 实验目的 熟练掌握队列的顺序链式存储结构. 熟练掌握队列的有关算法设计,并在链队列上实现. 根据具体给定的需求,合理设计并实现相关结构和算法. 5.2 实验要求 5.2.1链队列实验要 ...20172328《程序设计与数据结构》实验四 Android程序设计报告20172328实验四 A...
合工大 宣区 程序设计艺术与方法 实验
AWP2020的博客
02-07 1282
大学实验
合工大 宣区 python语言与系统设计 实验
AWP2020的博客
02-08 1539
大学实验
合工大 宣区 程序设计与算法训练 课设
AWP2020的博客
02-07 253
大学实验
合肥工业大学编译原理实验三 LR(1)分析法
一个苦逼研究僧的博客
11-06 5189
前言 刚开始的时候觉得这个东西不好写，估计花的时间比前一个LL1更长，但后来转念一想，UI可以挪用上次的，改个标题，换点控件，换个总控程序不就可以了吗。剩下的问题就是用python的哪个数据结构来表示和存储LR文法的一些东西，比如项目怎么表示、项目集怎么表示、文法怎么表示、哪个数据结构能最大程度方便编程。 把这些问题都解决了之后就好办了。也许是我太菜了，光是想这些都用了一个晚上，第二天才开始写代码...
怎样做研究（转载哈工大刘挺教授博客内容）
wqe198612的专栏
10-10 2381
几年前，我写了一套胶片，题目是《怎样做研究》，多次在实验室内部给学生们做报告，也曾对外讲过一次，听众反应良好。也有网友读过这套胶片，给我来信称有所收获。然而，胶片中的文字毕竟只是提纲携领，无法充分阐述我的想法，为此，借周末一点闲暇，把《怎样做研究》写成一篇文章，与师友切磋。什么是科学科学是分科的学问，客观地说，是起源于西方的。中国只有经验科学，典型的如中医。我的母亲是学中医的，我从小就对中医耳濡目
合肥工业大学七次数据结构实验汇总
03-22
合肥工业大学七次数据结构实验汇总，包括队列，二叉树，图等等
合工大数据结构试验
10-27
本实验为合工大数据结构试验，有兴趣自行下载，代码另附
vue面试题目|vue组件化理解，v-for,v-model
2301_79125431的博客
04-29 1041
最近鼠鼠收到了上海追势科技的实习offer，bg双非本9硕，0项目0实习，数学系。已经跟hr确认了offer和报道时间，但可能不想去的话，可以不去吗，虽然实习offer而已，好像没有。腾讯自从上周四二面完，既不挂我，也不约面，，能不能给我个痛快，不行就赶紧挂了，我还说不定能赶上最后一。本人第一次面试，遇到了个很好的技术面试官，本人是个菜鸡，面试官一直引导我给我提示，还给我建议，受益匪。笔试全英文，五个大题，一个BCI测试相关的，一个buck电路相关的，再就是一些零零散散硬件、射频的知。
20位大佬，勾勒出一个中国网络安全江湖
xueshenlaila的博客
06-28 4724
文章目录一、为大家介绍20位大佬？一 西安：西交大、西电、西工大360 集团董事长兼 CEO：周鸿祎赛博英杰 CEO：谭晓生腾讯副总裁：丁珂阿里云：吴翰清知道创宇 CTO&COO：杨冀龙二 合肥：中科大、安医大深信服 CEO：何朝曦360 首席科学家：潘剑锋腾讯安全：TK 教主云深互联 CEO：陈本峰三 哈尔滨：哈工大、哈工程安天集团：肖新光360 集团首席安全官：杜跃进安芯网盾 CEO、CTO：姜向前、姚纪卫四 上海：复旦、同济、上海交大腾讯安全：吴石启明星辰集团 CEO：严望佳同济：季昕华五 .
数据结构实验9：图的相关操作
u25th_engineer的博客
01-05 6080
                                                目录                                                  实验9 8.1 实验目的 8.2 实验任务 8.3 实验说明 1. 数据文件格式设计 2. 从数据文件创建邻接矩阵表示的图 3. 从数据文件创建邻接表表示的图 4. 图的销毁 8...
合肥工业大学数据结构上机实验代码与实验报告（全）github地址
u25th_engineer的博客
01-11 7785
        我已经将这个学期的所有数据结构上机实验的代码与报告上传到github上了，一直都有这个想法，但没抽出时间来学习git。经过上周简单的练习后，我已经基本学会运营自己的代码仓库了。所有代码都是C++写的类。         个人github主页、数据结构上机实验的代码与报告。...
通用型函数——冒泡排序
2401_84654619的博客
10-29 553
计算机中，任何数据最终都是二进制数，故只需有足够的空间，就可以将任何数据存储起来，相应的，读取时使用数据类型容器识别就可还原原本的意思。memcpy函数用于将指定数量的字节从源内存地址（src）复制到目标内存地址（dest）。n : 要复制的字节数，类型为size_t表示要复制的字节的数量。代码：（char型）
【数据结构】插入排序和希尔排序
wheeldown的博客
11-01 439
这种方法通过分组和逐步缩小增量的方式，提高了排序效率。综合来看，希尔排序的效率明显高于直接插入排序算法。重复步骤 2-4，直到 gap = 1，此时相当于直接插入排序。当gap > 1时都是预排序，⽬的是让数组更接近于有序。1.元素集合越接近有序，直接插⼊排序算法的时间效率越⾼。的了，这样就会很快。这样整体⽽⾔，可以达到优化的效果。选定一个整数（通常是 gap = n/3 + 1）。将待排序记录分成若干组，每组内记录的距离相等。缩小增量：gap = gap/3 + 1。希尔排序是对直接插⼊排序的优化。
探索数据结构：数组与链表
最新发布
qq_36287830的博客
11-04 431
数组和链表是两种基本但重要的数据结构。选择合适的数据结构对于优化程序性能至关重要。理解它们的特点和适用场景可以帮助开发者做出更好的设计决策。希望本文能为你提供有关数组和链表的清晰认识。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值