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

图

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");
}