圖的基本算法

　　近兩個星期，回顧數據結構時又把圖的相關知識復習了一下，順便為了提高編碼能力，將基本算法也都實現了一下。現將實例附錄如下：

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