算法导论 第22章 图论之拓扑排序

邻接表

    邻接矩阵用二维数组即可存取,比较简单,但除完全图外,一般的图不是任意两个顶点都相邻接,因此邻接矩阵也有很多零元素,特别是当n 较大而边数相对完全图的边(n-1)又少得多时,邻接矩阵仍是很稀疏,这样浪费存储空间。

    邻接表(Adjacency List)是图的一种顺序存储与链式存储结合的存储方法，类似于树的孩子链表表示法。由于它只考虑非零元素,因而节省了零元素所占的存储空间。它对于无向图和有向图都适用。

    邻接表示法就是对于图G中的每个顶点放到一个数组中，数组的每个元素存放一个结点并指向一个单链表的指针。链表中存储着与该顶点相邻接的顶点所在的数组元素的下标。在邻接表表示中有两种结点结构，如图6-9所示。

(a) 表头结点             (b) 边表结点

图6-9  邻接矩阵表示的结点结构

    在邻接表中，对图中每个顶点建立一个单链表。单链表有一个表头结点，表头结点的结构为图6-9（a）所示。其中，vertex域存放图中某个顶点vi 的信息，link为指针，指向对应单链表中的结点。

    单链表中的结点称为边表结点，边表结点结构如图6-9（b）所示。其中，adjvex域存放与顶点vi相邻接的顶点在二维数组中的序号，next域为指针，指向与顶点vi相邻接的下一个顶点的边表结点。

下图6-10给出无向图6-7对应的邻接表表示。

图6-10  图的邻接表表示

拓扑排序

拓扑排序是对有向无环图的一种排序。表示了顶点按边的方向出现的先后顺序。如果有环，则无法表示两个顶点的先后顺序。

通常我们把计划、施工过程、生产流程、程序流程等都当成一个工程，一个大的工程常常被划分成许多较小的子工程，这些子工程称为活动。这些活动完成时，整个工程也就完成了。

我们用一种有向图来表示这些工程、计划等，在这种有向图中，顶点表示活动，有向边表示活动的优先关系，这种用顶点表示活动，用弧来表示活动间的优先关系的有向图叫做顶点表示活动的网络(Actire On Vertices)简称为AOV网。

拓扑排序：

  假设G=(V，E)是一个具有n个顶点的有向图，V中顶点序列vl，v2，…，vn称做一个拓扑序列(Topological Order)，当且仅当该顶点序列满足下列条件：若在有向图G中存在从顶点vi到vj的一条路径，则在顶点序列中顶点vi必须排在顶点vj之前。通常，在AOV网中，将所有活动排列成一个拓扑序列的过程叫做拓扑排序(Topological Sort)。

在AOV网中不应该出现有向环。因为环的存在意味着某项活动将以自己为先决条件，显然无法形成拓扑序列。

   判定网中是否存在环的方法：对有向图构造其顶点的拓扑有序序列，若网中所有顶点都出现在它的拓扑有序序列中，则该AOV网中一定不存在环。

4、 拓扑排序的算法思想

    输入AOV网络。令 n 为顶点个数。      

（1）在AOV网络中选一个没有直接前驱的顶点，并输出之；

（2）从图中删去该顶点, 同时删去所有它发出的有向边；

    重复以上步骤，直到全部顶点均已输出，拓扑有序序列形成，拓扑排序完成；或图中还有未输出的顶点，但已跳出处理循环。这说明图中还剩下一些顶点，它们都有直接前驱，再也找不到没有前驱的顶点了。这时AOV网络中必定存在有向环。

 

 

c语言实现

头文件graph_adj.h：

#ifndef _GRAPH_ADJ_H
#define _GRAPH_ADJ_H
#define MAX_STR 20
typedef char Vertextype[MAX_STR];
#define maxvernum 100       //最大顶点数为100
typedef struct node         //边表结点
{ 
    int adjvex;             //邻接点域
    struct node  * next;    //指向下一个邻接点的指针域
}Edgenode;   
                  
typedef struct vnode        //表头结点
{ 
    Vertextype vertex;      //顶点域
    Edgenode  *link;        //边表头指针
 } Vexnode;
 
typedef Vexnode Adjlist[maxvernum];  //adjlist是邻接表类型

typedef struct
{  
    Adjlist adjlist;                     //邻接表
    int n,e;                             //顶点数和边数
} Adjgraph;                 // Adjgraph是以邻接表方式存储的图类型
#endif

实现文件topsort.c：

/*拓扑排序*/

#include "graph_adj.h"
#include "topsort.h"
#include "queue.h"
#include <stdio.h>
#include <stdlib.h>
/*scanf 
函数原型:
　　int scanf( const char *format, ... );
　　scanf()函数是格式化输入函数，它从标准输入设备(键盘) 读取输入的信息。
　　其调用格式为: scanf("<格式化字符串>"，<地址表>);
    函数 scanf() 是从标准输入流 stdin 中读内容的通用子程序，可以读入全部固有类型的数据并自动转换成机内形式。
返回值：
    函数返回成功赋值的数据项数，读到文件末尾出错时则返回EOF。*/
void init_graph(Adjgraph *g) 
{
    int i,j,k;
    Edgenode * s;
    printf("请输入顶点数和边数(输入格式为:顶点数,边数)：\n");
    scanf("%d,%d",&(g->n),&(g->e));     //读入顶点数和边数
    printf("请输入顶点信息(输入格式为:顶点号<CR>)：\n");
    for (i=0;i<g->n;i++)                //建立有n个顶点的顶点表
    { 
        scanf("%s",&(g->adjlist[i].vertex));  //读入顶点信息   g->adjlist[i].link=NULL;     //顶点的边表头指针设为空
        g->adjlist[i].link = NULL;//链接初始化
        printf("%s\t", &(g->adjlist[i].vertex));
    }
    printf("\n");
    printf("请输入边的信息(输入格式为:i,j)：\n");
    for (k=0;k<g->e;k++)                //建立边表
    { 
        scanf("%d,%d",&i,&j);         //读入边<vi,vj>的顶点对应序号
        printf("%d -> %d\t", i, j);
        s=(Edgenode*)malloc(sizeof(Edgenode));  //生成新边表结点s
        s->adjvex=j;                      //邻接点序号为j
        //将新边表结点s插入到顶点vi的边表头部
        s->next=g->adjlist[i].link;      
        g->adjlist[i].link=s;
    }  
    printf("\n");
}
//拓扑排序
int* topsort(Adjgraph *g)
{
    Queue Q;
    Edgenode *e;
    Vexnode V,W;
    int *Indegree, *TopNum, i, counter = 0, v;
    Indegree = (int *)malloc(sizeof(int) * g->n);
    TopNum = (int *)malloc(sizeof(int) * g->n);
    if(Indegree == NULL)
    {
        printf("Failed to malloc Indegree\n");
        return;
    }
    for(i = 0; i < g->n; i ++)        //对每个顶点的入度数初始化为零
        Indegree[i] = 0;
    for(i = 0; i < g->n; i ++)        //统计每个顶点的入度数
    {    
        e = g->adjlist[i].link;
        while(e != NULL)
        {
            Indegree[e->adjvex] ++;
            e = e->next;
        }
    }
    printf("Indegree:\n");            //打印每个顶点的入度数
    for(i = 0; i < g->n; i ++)
        printf("%s:[%d]\t", g->adjlist[i].vertex, Indegree[i]);
    printf("\n");
    Q = createqueue(g->n);            //开辟队列
    makeempty(Q);                    //队列初始化
    for(i = 0; i < g->n; i ++)        //将所有入度为0的结点压入队列
        if(Indegree[i] == 0)
        {
            printf("%s enqueue\n", g->adjlist[i].vertex);
            enqueue(i, Q);
        }
    while(!isempty(Q))
    {
        v = frontanddequeue(Q);
        printf("%s dequeue\n", g->adjlist[v].vertex);
        TopNum[v] = ++counter;
        e = g->adjlist[v].link;
        while(e != NULL)
        {
            Indegree[e->adjvex] = Indegree[e->adjvex] - 1;
            if( Indegree[e->adjvex] == 0)
            {
                //打印每个顶点的入度数//////////////
                printf("Indegree:\n");
                for(i = 0; i < g->n; i ++)
                        printf("%s:[%d]\t", g->adjlist[i].vertex, Indegree[i]);
                printf("\n");
                printf("%s enqueue\n",  g->adjlist[e->adjvex].vertex);
                ////////////////////////////////////
                enqueue(e->adjvex, Q);
                
            }
            e = e->next;    
        }
    }
    if(counter != g->n)
    {
        printf("Graph has a cycle\n");
        return NULL;
    }
    disposequeue(Q);
    return TopNum;
}

队列头文件queue.h：

#ifndef _Queue_h
#define _Queue_h
typedef int ElementType;
struct QueueRecord;
typedef struct QueueRecord *Queue;
int isfull(Queue Q);
int isempty(Queue Q);
Queue createqueue(int MaxElement);
void disposequeue(Queue Q);
void makeempty(Queue Q); 
void enqueue(ElementType X, Queue Q);
ElementType front(Queue Q);
void dequeue(Queue Q);
ElementType frontanddequeue(Queue Q);
#endif

队列实现头文件queue.c

#include "queue.h"
#include <stdlib.h>
#include <stdio.h>
struct QueueRecord
{
        int capacity;
        int front;
        int rear;
        int size;
        ElementType *array;
};

int isempty(Queue Q)
{
    return Q->size == 0;
}

int    isfull(Queue Q)
{
    return Q->size == Q->capacity;
}

Queue createqueue(int MaxElement)
{
    ElementType *array;
    Queue queue;
    queue = (Queue)malloc(sizeof(struct QueueRecord));
    if(queue == NULL)
    {
        printf("Failed to malloc queue\n");
        return NULL;
    }
    array = (ElementType *) malloc(sizeof(ElementType) * MaxElement);
    if(array == NULL)
    {
        printf("Failed to malloc queue\n");
        free(queue);
        return NULL;
    }
    queue->array = array;
    queue->capacity = MaxElement;
    return queue;
}


void disposequeue(Queue Q)
{
    if(Q != NULL && Q->array != NULL)
    {
        free(Q->array);
        Q->array = NULL;
    }
    else if( Q != NULL)
    {
        free(Q);
        Q = NULL;
    }
}
void makeempty(Queue Q)
{
    Q->size = 0;
    Q->front = 1;
    Q->rear = 0;
}

void enqueue(ElementType X, Queue Q)
{
    if(isfull(Q))
    {
        printf("Full Queue\n");
        return;
    }
    else
    {
        Q->size ++;
        if(Q->rear != Q->capacity - 1)
            Q->rear ++;
        else 
            Q->rear = 0;
        /*printf("%d -> Q[%d]\n", X, Q->rear);*/
        Q->array[Q->rear] = X;
    }
}

ElementType front(Queue Q)
{
    if(isempty(Q))
        return -1;
    else
        return Q->array[Q->front];
}

void dequeue(Queue Q)
{
    if(isempty(Q))
    {
        printf("Empty Queue\n");
        return;
    }
    else
    {
        Q->size --;
        /*printf("out <- Q[%d]\n", Q->front);*/
        if(Q->front != Q->capacity - 1)
            Q->front ++;
        else
            Q->front = 0;
        
    }
}
/**/
ElementType frontanddequeue(Queue Q)
{
    ElementType value;
    if(isempty(Q))
    {
        printf("Empty Queue\n");
        return -1;
    }
    else
    {
        value = front(Q);
        dequeue(Q);
        return value;
    }
}

主函数topsort_main.c

#include "graph_adj.h"
#include "topsort.h"
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    Adjgraph *g;
    int i;
    int *topnum;
    g = (Adjgraph *)malloc(sizeof(Adjgraph));
    init_graph(g);
    topnum = topsort(g);
    printf("拓扑排序：（格式为：结点名称:结点id:排序序号）\n");
    if(topnum != NULL)
    {
        for(i = 0;i < g->n; i++)
            printf("%s:%d:%d\n", g->adjlist[i].vertex, i, topnum[i]);
    }
    free(topnum);
}

按照上图拓扑顺序输入数据：

7,12
v1
v2
v3
v4
v5
v6
v7
0,3
0,1
0,2
1,3
1,4
2,5
3,2
3,5
3,6
4,3
4,6
6,5

运行结果如下：

请输入顶点数和边数(输入格式为:顶点数,边数)：
请输入顶点信息(输入格式为:顶点号<CR>)：
v1    v2    v3    v4    v5    v6    v7    
请输入边的信息(输入格式为:i,j)：
0 -> 3    0 -> 1    0 -> 2    1 -> 3    1 -> 4    2 -> 5    3 -> 2    3 -> 5    3 -> 6    4 -> 3    4 -> 6    6 -> 5    
Indegree:
v1:[0]    v2:[1]    v3:[2]    v4:[3]    v5:[1]    v6:[3]    v7:[2]    
v1 enqueue
v1 dequeue
Indegree:
v1:[0]    v2:[0]    v3:[1]    v4:[3]    v5:[1]    v6:[3]    v7:[2]    
v2 enqueue
v2 dequeue
Indegree:
v1:[0]    v2:[0]    v3:[1]    v4:[2]    v5:[0]    v6:[3]    v7:[2]    
v5 enqueue
v5 dequeue
Indegree:
v1:[0]    v2:[0]    v3:[1]    v4:[0]    v5:[0]    v6:[3]    v7:[1]    
v4 enqueue
v4 dequeue
Indegree:
v1:[0]    v2:[0]    v3:[1]    v4:[0]    v5:[0]    v6:[3]    v7:[0]    
v7 enqueue
Indegree:
v1:[0]    v2:[0]    v3:[0]    v4:[0]    v5:[0]    v6:[2]    v7:[0]    
v3 enqueue
v7 dequeue
v3 dequeue
Indegree:
v1:[0]    v2:[0]    v3:[0]    v4:[0]    v5:[0]    v6:[0]    v7:[0]    
v6 enqueue
v6 dequeue
拓扑排序：（格式为：结点名称:结点id:排序序号）
v1:0:1
v2:1:2
v3:2:6
v4:3:4
v5:4:3
v6:5:7
v7:6:5