图的基本算法

　　近两个星期，回顾数据结构时又把图的相关知识复习了一下，顺便为了提高编码能力，将基本算法也都实现了一下。现将实例附录如下：

1)要实现的算法

①建立图的存储结构

②深度优先搜索和广度优先搜索

③求图的最小生成树

④拓扑排序

⑤最短路径

2)存储结构设计

　　本系统采用图结构（mgraph）存储抽象操作的信息。其中，各结点间的邻接关系用图的邻接矩阵类型（adjmatrix）存储。顶点信息用结构数组（vexs）存储。其中每个数据元素师一个结构变量，包括一些基本信息。

此外，本系统还设置了三个全局变量：visited[]数组用于存储顶点是否被访问标记；d[]用于存放边上的权值或者是存储查找路径顶点的编号；campus是一个图结构的全局变量

3)功能设计

　　本程序一共设置了9个子功能菜单，图的初始化由函数initgraph（）实现，依据读入的图的顶点个数和边的个数。分别初始化图结构中图的顶点向量数组和图的邻接矩阵。9个功能设计描述如下：

①建立有向图。有向图的建立有由BuildAdjacencyList()实现。当用户选择该功能时，用户要手动输入该图的信息。从而建立有向图。

②输出邻接表。邻接表的输出有函数ShowAdjacencyList()实现。当用户选择该项功能时，系统即以邻接表的形式输出各顶点所连接的点。

③输出顶点的度。顶点读的输出由函数ShowAdjacencyListDegree()实现。当用户选择该功能时，系统即将每个顶点的度以数字的形式输出。

④进行拓扑排序。拓扑排序功能的实现由函数TopologicalSortAdjacencyList()完成。一旦选择，就会进行排序并输出。

⑤深度优先遍历。采用DFS算法进行深度优先遍历，遍历完成后，将遍历得到的结点有序输出。

⑥广度优先遍历。采用BFS算法进行广度优先遍历，遍历完成后，将遍历得到的结点有序输出。

⑦无向图最小生成树。最小生成树的算法实现由函数AdjacencyListPrim()完成。该函数采用Prim算法对邻接矩阵求最小生成树并输出。

⑧有向图求最短路径。最短路径的实现采用函数AdjacencyListDijkstra()完成。该函数采用的是Dijkstra 算法对邻接矩阵对各顶点到其他顶点的最短距离。并依次输出。

4)测试结果

①菜单界面

 

②建立有向图

 

 

③输出该邻接表

 

④输出顶点的度

 

⑤进行拓扑排序

 

⑥深度优先搜索

 

⑦广度优先搜索

 

⑧最短路径

5)源代码附录

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define MAX_VERTEX_NUM 100
#define MAX 1000000000
typedef struct Arcnode     /////邻接表除头结点以外的结点
{
    int adjvex;
    struct Arcnode *nextarc;
    int weight;
}ArcNode;
typedef struct Vnode   /////邻接表的头结点
{
    int data;
    struct Arcnode *fistarc;
}Vnode;
Vnode AdjList[MAX_VERTEX_NUM];   ////有多个头结点，定义为数组形式了

int flag[MAX_VERTEX_NUM];
int count[MAX_VERTEX_NUM];
int map[MAX_VERTEX_NUM][MAX_VERTEX_NUM];    ///////无向图邻接矩阵
int map2[MAX_VERTEX_NUM][MAX_VERTEX_NUM];  ////////有向图的邻接矩阵
int map3[MAX_VERTEX_NUM][MAX_VERTEX_NUM];   ///////"临时"的邻接矩阵
int topocount[MAX_VERTEX_NUM];
int topoflag[MAX_VERTEX_NUM];
int num[MAX_VERTEX_NUM];                    /////用于存储深度优先遍历和广度优先遍历的结果

int K;                                     //////表示遍历过的节点数
int choose;                                //////主菜单选择变量
int Num,Number;   //////Num表示顶点的个数，number表示的为边的个数


void Build_VAdjacencyList() ///////建立并初始化头结点
{
    int i;
    for(i=0;i<Num;i++)
    {
        AdjList[i].data=i+1;
        AdjList[i].fistarc=NULL;
    }
}
void BuildAdjacencyList()        ///////////建立邻接表，当然，在建立邻接表的同时也建立了此图的图的有向图邻接矩阵以及无向图的邻接矩阵
{
    int a,b,c,i,j;
    ArcNode *p,*s;
    printf("请输入图中顶点的个数：\n");
    scanf("%d",&Num);
    Build_VAdjacencyList();
    for(i=0;i<Num;i++)
    {
        for(j=0;j<Num;j++)
            if(i==j)
            {
                map[i][j]=0;
                map2[i][j]=0;
            }
            else
            {
                map[i][j]=MAX;
                map2[i][j]=MAX;
            }
    }
    printf("请输入图中边的个数：\n");
    scanf("%d",&Number);
    printf("请输入各条边的两个顶点以及边的权值:\n");
    for(i=0;i<Number;i++)
    {
        scanf("%d%d%d",&a,&b,&c);
        if(map2[a-1][b-1]>c)              ///////建立此图的有向图的邻接矩阵
        {
            map2[a-1][b-1]=c;
        }


        if(map[a-1][b-1]>c)               /////这里的2个if为建立此图的无向图的邻接矩阵
            map[a-1][b-1]=c;
        if(map[b-1][a-1]>c)              /////
            map[b-1][a-1]=c;


        p=AdjList[a-1].fistarc;         /////以下是建立邻接表
        if(p==NULL)
        {
            s=(ArcNode *)malloc(sizeof(ArcNode));
            s->adjvex=b-1;
            s->weight=c;
            s->nextarc=NULL;
            AdjList[a-1].fistarc=s;
        }
        else
        {
            while(p->nextarc!=NULL)
            {
                p=p->nextarc;
            }
            s=(ArcNode *)malloc(sizeof(ArcNode));
            s->adjvex=b-1;
            s->weight=c;
            s->nextarc=NULL;
            p->nextarc=s;
        }
    }
    
} 
void ShowAdjacencyList()        ///////以邻接表的形式输出各顶点所连接的点
{
    if(Num==0)
        printf("请先建立有向图!\n");
    else
    {
        int i;
        ArcNode *p;
        for(i=0;i<Num;i++)
        {
            printf("从%d直接可达的点有:",i+1);
            p=AdjList[i].fistarc;
            while(p!=NULL)
            {
                printf("%d、",p->adjvex+1);
                p=p->nextarc;
            }
            printf("\n");
        }
    }
}
void ShowAdjacencyListDegree()       //////////////////以邻接表的形式输出各顶点的度
{
    if(Num==0)
        printf("请先建立有向图!\n");
    else
    {
        int i,j,sum;
        ArcNode *p;
        for(i=0;i<Num;i++)
        {
            sum=0;
            p=AdjList[i].fistarc;
            //出度
            while(p!=NULL)
            {
                sum++;
                p=p->nextarc;
            }
            //入度
            for(j=0;j<Num;j++)
            {
                if(j!=i)
                {
                    p=AdjList[j].fistarc;
                    while(p!=NULL)
                    {
                        
                        if(p->adjvex==i)
                            sum++;
                        p=p->nextarc;
                    }                            
                }
            }
            printf("顶点%d的度为:%d\n",i,sum);
        }
    }
}
void TopologicalSortAdjacencyList()     ///////邻接表的拓扑排序
{
    if(Num==0)
        printf("请先建立有向图!\n");
    else
    {
        memset(topocount,0,sizeof(topocount));
        memset(topoflag,0,sizeof(topoflag));
        int i,sum,k=0;
        ArcNode *p;
        sum=0;
        while(sum<Num)
        {
            for(i=0;i<Num;i++)
            {
                if(topoflag[i]==0)
                {
                    p=AdjList[i].fistarc;
                    while(p!=NULL)
                    {
                        topoflag[p->adjvex]=1;
                        p=p->nextarc;
                    }
                }
            }
            for(i=0;i<Num;i++)
            {
                if(topoflag[i]==0)
                {
                    topoflag[i]=2;
                    topocount[sum]=i+1;
                    sum++;
                    break;
                }
            }
            if(i==Num+1)
            {
                printf("此有向图有环!\n");
                k=1;
                break;
            }
            for(i=0;i<Num;i++)
            {
                if(topoflag[i]==1)
                    topoflag[i]=0;
            }
        }
        if(k==0)
        {
            for(i=0;i<Num;i++)
                printf("%d ",topocount[i]);
            printf("\n");
        }
    }
}
void DFS(ArcNode *s)
{
    ArcNode *p;
    while(s!=NULL)
    {
        if(flag[s->adjvex]==0)
            s=s->nextarc;
        else
        {
            flag[s->adjvex]=0;
            num[K]=s->adjvex;
            K++;
            p=AdjList[s->adjvex].fistarc;
            DFS(p);
            s=s->nextarc;    
        }
    }        
}
void DFSAdjacencyList()      ///////////////////对邻接表进行深度优先遍历
{
    if(Num==0)
        printf("请先建立有向图!\n");
    else
    {
        int i,k;
        K=0;
        ArcNode *p;
        for(i=0;i<Num;i++)
            flag[i]=1;
        for(k=0;k<Num;k++)
        {
            if(flag[k]==1)
            {
                num[K]=k;
                K++;
                p=AdjList[k].fistarc;
                DFS(p);
            }
        }
        printf("深度优先遍历的顺序为:\n");
        for(i=0;i<Num;i++)
            printf("%d ",num[i]+1);
        printf("\n");
    }
}
void BFSAdjacencyList()                ///////对邻接表进行广度优先遍历
{
    if(Num==0)
        printf("请先建立有向图!\n");
    else
    {
        int i,j;
        ArcNode *p;
        K=0;
        j=0;
        for(i=0;i<Num;i++)
            flag[i]=1;
        memset(count,0,sizeof(count));
        for(i=0;i<Num;i++)
        {
            if(flag[i]==1)
            {
                flag[i]=0;
                num[K]=i;
                K++;
                while(j<K)
                {
                    p=AdjList[num[j]].fistarc;
                    j++;
                    while(p!=NULL)
                    {
                        if(flag[p->adjvex]==1)
                        {
                            num[K]=p->adjvex;
                            K++;
                            flag[p->adjvex]=0;
                        }
                        p=p->nextarc;
                    }
                }
            }
        }
        printf("广度优先遍历的顺序为:\n");
        for(i=0;i<Num;i++)
            printf("%d ",num[i]+1);
        printf("\n");
    }
}
void AdjacencyListPrim()             ///////////////////用Prim算法对邻接矩阵求最小生成树
{
    if(Num==0)
        printf("请先建立有向图!\n");
    else
    {
        int min1,pi,i,j,ans=0;
        for(i=0;i<Num;i++)
        {
            flag[i]=0;
            count[i]=map[0][i];
        }
        flag[0]=1;
        count[0]=0;
        for(i=1;i<Num;i++)
        {
            min1=MAX;
            for(j=0;j<Num;j++)
            {
                if(flag[j]==0&&count[j]<min1)
                {
                    min1=count[j];
                    pi=j;
                }
            }
            if(min1==MAX)
            {
                printf("图不连通!\n");
                return;
            }
            flag[pi]=1;
            for(j=0;j<Num;j++)
            {
                if(flag[j]==0&&count[j]>map[pi][j])
                    count[j]=map[pi][j];
            }
        }
        for(i=0;i<Num;i++)  
        {
            ans+=count[i];
        }       
        printf("%d\n",ans);
    }
}
void AdjacencyListDijkstra()        ////////////对邻接矩阵对各顶点到其他顶点的最短距离，在此用的是Dijkstra 算法
{
    if(Num==0)
        printf("请先建立有向图!\n");
    else
    {
        int min1,pi,i,j,k;
        for(k=0;k<Num;k++)
        {
            memset(flag,0,sizeof(flag));
            memset(count,0,sizeof(count));
            for(i=0;i<Num;i++)
            {
                flag[i]=0;
                count[i]=map2[k][i];
            }
            flag[k]=1;
            count[k]=0;
            for(i=1;i<Num;i++)
            {
                min1=MAX;
                for(j=0;j<Num;j++)
                {
                    if(flag[j]==0&&count[j]<min1)
                    {
                        min1=count[j];
                        pi=j;
                    }
                }
                flag[pi]=1;
                for(j=0;j<Num;j++)
                {
                    if(flag[j]==0&&count[j]>count[pi]+map2[pi][j])
                        count[j]=count[pi]+map2[pi][j];
                }
            }
            for(i=0;i<Num;i++)  
            {
                map3[k][i]=count[i];
            }       
        }
        for(i=0;i<Num;i++)
        {
            for(j=0;j<Num;j++)
            {
                if(i==j)
                    continue;
                if(map3[i][j]!=MAX)
                    printf("顶点%d与顶点%d之间的最短距离为:%d\n",i+1,j+1,map3[i][j]);
                else 
                    printf("顶点%d与顶点%d之间的最短距离为:+∞\n",i+1,j+1);
            }
            
        }
    }
}
void ShowMenu()           //////////////////////菜单
{
    printf("-----------------------------------------------------\n");
    printf("|对图的操作如下:                                    |\n");
    printf("-----------------------------------------------------\n");
    printf("| 1.建立有向图         ;  2.输出该临接表            |\n");
    printf("| 3.输出个顶点的度     ;  4.进行拓扑排序            |\n");
    printf("| 5.深度优先遍历       ;  6.广度优先遍历            |\n");
    printf("| 7.无向图最小生成树   ;  8.有向图求最短路径        |\n");
    printf("| 0.退出                                            |\n");
    printf("-----------------------------------------------------\n");
    printf("请选择想要进行的操作:\n");
    scanf("%d",&choose);
    
}
int main()                 ///////////////////////////////////主函数
{
    Num=0;
    Number=0;
    ShowMenu();
    while(1)
    {
        if(choose==0)
            break;
        else if(choose==1)
        {
            BuildAdjacencyList();
            ShowMenu();
        }
        else if(choose==2)
        {
            ShowAdjacencyList();
            ShowMenu();        
        }
        else if(choose==3)
        {
            ShowAdjacencyListDegree();
            ShowMenu();
        }
        else if(choose==4)
        {
            TopologicalSortAdjacencyList();
            ShowMenu();
        }
        else if(choose==5)
        {
            DFSAdjacencyList();
            ShowMenu();
        }
        else if(choose==6)
        {
            BFSAdjacencyList();
            ShowMenu();
        }
        else if(choose==7)
        {
            AdjacencyListPrim();
            ShowMenu();
        }
        else if(choose==8)
        {
            AdjacencyListDijkstra();
            ShowMenu();            
        }
        
    }
    return 0;
}