输出DAG的所有拓扑排序序列

输出DAG的所有拓扑排序序列

1.课程设计内容与要求

用字符文件提供数据建立DAG（有向无环图）合适的存储结构。编写程序，输出所有可能的拓扑排序序列。要求输出的拓扑排序结果用顶点序号或字母表示。输出结果需存于字符文件。输出结果中应显示全部拓扑排序序列的数目。如果DAG存在环（即拓扑排序失败），输出结果中应显示拓扑排序序列的数目为0。

课程设计报告要求给出详细算法描述，在结论部分应分析算法的时间复杂度和空间复杂度，并给出分析的结果。

2.程序设计报告

2.1总体设计

首先创建有向图邻接表，从文件中读取邻接表的顶点和边数，然后再读取临接矩阵的边，每读取一条边，都将其插入到邻接矩阵中。

采用递归调用判断该邻接矩阵是否为有向无环图(DAG) ，如果是则找出邻接矩阵中所有的拓扑排序，并打印到屏幕上。若含有环，则不打印结果。

2.2详细数据结构设计

采用结构体存储邻接表的表结点，该结构包含两个整型数据域和两个该结构体的指针域。其结构如下：

typedef struct node

{

int i, j;//弧的端点下标

struct node *hlink;

struct node *vlink;

} OLANode;

采用结构体存储邻接表的头结点，该结构包含一个三个整型属于和两个表结点类型的指针域，其结构如下：

typedef struct

{

ElemTp data;//顶点数据(可选)

InfoTp info;//顶点信息(可选)

int i;//顶点下标

OLANode *firstin;

OLANode *firstout;

} OLHNode;

采用结构体存储邻接表，该结构包含一个头结点数组，和两个整型数据域，其结构如下：typedef struct

{

OLHNode h[MAX_N]; //头结点形成数组

int n, e; //n:实际顶点数; e:边或弧的数目

//Graphkind kind; //图类型(可选)

} OLGraph;

采用队列存储入度为零的表结点，队列的结构体包含一个整型数组，三个整型数据域，其结构如下：

typedef struct

{

ElemType *elem;

int n; //队列容量

int f; //队头指针

int r; //队尾指针

}SqQueue;

2.2详细算法设计

该程序的核心算法是拓扑排序，拓扑排序的算法如下：

（1）、采用邻接表作为有向图的存储结构。

（2）、用一个数组indegree[0..n-1]来保存各顶点的入度；

（3）、为避免检测入度为0的顶点，设置l个队列Q存放入度为0的顶点。并设置另一个队列S存放当前已经遍历过的顶点。

开始排序前，扫描indegree向量，将入度为0的顶点压入队列Q，每次输出入度为0的顶点时，只需要做出队操作即可。

删除入度为0的顶点以及所有以它为尾的弧，只需要将该顶点的所有邻接至顶点的入度减1，若减到0则入队Q。

队Q空时结束循环。

（4）、当采用递归调用的方法输出所有拓扑排序时，每递归一层都新建一个队列Q保存当前入度为0的顶点，在while循环中删除入度为0的顶点以及所有以它为尾的弧，只需要将该顶点的所有邻接至顶点的入度减1，若减到0则入队Q，此操作更新indegree数组。同时将遍历过的顶点入队S。

更新完indegree数组，调用递归函数，直至遍历所有点或队列为空时结束递归。

（5）、结束当前拓扑排序的递归时，判断是否遍历了所有点，若未遍历所有点，说明存在环，则不打印拓扑排序的结果。

若遍历了所有点，则打印拓扑排序的结果(即队列S中的元素)。递归函数回溯至上一级，并删除队列S中的队尾元素。判读当前递归函数内队列Q是否为空，若不为空则继续while循环，调用递归函数进入下一层次递归。若为空则继续回溯。

主要函数说明：

void initQueue(SqQueue &q) //初始化队列

void clearQueue(SqQueue &q) //清空队列

int empty(SqQueue &q) //判断队空

int full(SqQueue &q) //判断队满

int inQueue(SqQueue &q, ElemType e) //队头入队

int delTail(SqQueue &q) //删除队尾

int outQueue(SqQueue &q, ElemType &e) //队头出队，返回出队元素

void crtGraph1(OLGraph &G) //构建有向图邻接表

void copy(int indegree[],int degree[],int n) //将数组indegree复制给degree

void fun(OLGraph G,SqQueue S,int indegree[],int count,int &n) //递归调用函数，判断是否为

DAG

int TopologicalSort_Stack(OLGraph G) //拓扑排序子程序,返回拓扑排序的种数

3.程序测试报告

测试用例1：（预期结果）

文件输入的数据：

(8,10) //矩阵的顶点个数各边数

(0,1) //以下均为边

(1,2)

(2,3)

(4,1)

(4,2)

(4,5)

(5,6)

(6,7)

(6,3)

(2,6)

DAG结构：

运行结果：

测试用例2：（存在环时）文件输入：

(8,10)

(0,1)

(1,2)

(2,3)

(4,1)

(2,4)

(4,5)

(5,6)

(6,7)

(6,3)

(2,6)

图的结构：

运行结果：

4.结论

测试用例一分析：

如图所示，共有十四种拓扑排序结果

程序运行结果与上图一致，程序设计符合要求。

时间复杂度分析：

初始化indegree数组：n+e次循环

输出各顶点入读：n次循环

每次查询入度为0的顶点并入队：n次循环

输出所有顶点：e次循环

时间复杂度为：T(n,e) = Q(n+e)

空间复杂度分析：

递归的深度：n

空间复杂度为：S(n) = Q(n)

5.源程序附录

#include

#include

#include

#include

#define MAX_N 20//最大顶点数

#define Queue_size 20

typedef int ElemTp;

typedef int ElemType;

typedef char InfoTp;

//表结点结构

typedef struct node

{

//double w;//弧的权重(可选)

//InfoTp info;//弧的信息(可选)

int i, j;//弧的端点下标

struct node *hlink;

struct node *vlink;

} OLANode;

//头结点结构

typedef struct

{

ElemTp data;//顶点数据(可选)

InfoTp info;//顶点信息(可选)

int i;//顶点下标

OLANode *firstin;

OLANode *firstout;

} OLHNode;

//十字链表结构

typedef struct

{

OLHNode h[MAX_N]; //头结点形成数组

int n, e; //n:实际顶点数; e:边或弧的数目

//Graphkind kind; //图类型(可选)

} OLGraph;

typedef struct

{

ElemType *elem;

int n; //队列容量

int f; //队头指针

int r; //队尾指针

}SqQueue;

//初始化队列

void initQueue(SqQueue &q)

{

q.n = Queue_size;

q.r = q.f = -1;//初始化指针

q.elem = (ElemType *)malloc(q.n * sizeof(ElemType)); }

//清空队列

void clearQueue(SqQueue &q)

{

q.r=q.f=-1;

/*r=f=-1~n-1区间的任一

整数均可*/

}

//判断队空

int empty(SqQueue &q)

{

return q.f==q.r;

}

//判断队满

int full(SqQueue &q)

{

return(q.r+1)%q.n==(q.f+q.n)%q.n;

}

//队尾入队

int inQueue(SqQueue &q, ElemType e)

{

if((q.r+1)%q.n==(q.f+q.n)%q.n)

{

printf("队满\n");

exit(0);

}

q.r=(q.r+1)%q.n;

q.elem[q.r]=e;

return 1; //入队成功返回1

}

//删除队尾

int delTail(SqQueue &q)

{

if(q.r==q.f)

{

printf("队空\n");

exit(0);

}

q.r=(q.r-1)%q.n;

return 1; //入队成功返回1

}

//队头出队

int outQueue(SqQueue &q, ElemType &e) {

if(q.r==q.f)

{

printf("队空\n");

exit(0);

}

q.f=(q.f+1)%q.n;

e=q.elem[q.f];

return 1; //出队成功返回1

}

//构建有向图邻接表

void crtGraph1(OLGraph &G)

{

int i, j, k;

FILE *f;

char c = 'a';

if((f = fopen("input.txt","r")) == NULL)

{

printf("文件打开失败!\n");

exit(0);

}

if(!f) return;

fscanf(f,"(%d,%d)\n",&G.n,&G.e); //读入顶点数和弧数

for(i=0; i

{

G.h[i].i=i; //初始化顶点序号

G.h[i].info = c;

c++;

G.h[i].firstin=G.h[i].firstout=NULL;

}

for(k=0; k

{

fscanf(f,"(%d,%d)\n",&i,&j); //读入弧的始点和终点序号

OLANode *pr, *p, *q=new OLANode;

q->i=i;

q->j=j;

q->hlink=q->vlink=NULL;

//水平链表按弧头序号升序

pr=NULL;

p=G.h[i].firstout;

while(p&&p->j

{

pr=p;

p=p->hlink;

}

if(pr==NULL)

{

q->hlink=p;

G.h[i].firstout=q;

}

else

{

pr->hlink=q;

q->hlink=p;

}

//垂直链表按弧尾序号升序

pr=NULL;

p=G.h[i].firstin;

while(p&&p->i

{

pr=p;

p=p->vlink;

}

if(pr==NULL)

{

q->vlink=p;

G.h[i].firstin=q;

}

else

{

pr->vlink=q;

q->vlink=p;

}

} // 建立表结点循环结束

fclose(f);

} //函数结束

//将数组indegree复制给degree

void copy(int indegree[],int degree[],int n) {

for(int i=0; i

degree[i] = indegree[i];

}

//递归函数

void fun(OLGraph G,SqQueue S,int indegree[],int count,int &n) {

int i;

if(count == G.n)

{

n++;

cout<<"第"<

while(!empty(S))

{

outQueue(S,i);

cout<

}

cout<

return;

}

SqQueue Q;

OLANode *p;

initQueue(Q);

for(i=0; i

{

if(!indegree[i])

{

inQueue(Q, i);

}

}

while(!empty(Q))

{

int *degree = new int[G.n];

copy(indegree, degree, G.n);

outQueue(Q,i);

inQueue(S,i);

degree[i] = -1;

count++;

for(p=G.h[i].firstout; p; p=p->hlink)

{--degree[p->j];}

fun(G,S,degree,count,n);

delete []degree;

count--;

delTail(S);

}

clearQueue(Q);

}

//拓扑排序，返回true，表示拓扑排序成功；返回false表示有环int TopologicalSort_Stack(OLGraph G)

{

//首先创建并初始化indegree数组

int *indegree=new int[G.n];

int i, count=0;

int n=0;

OLANode *p;

SqQueue S;

for(i=0; i

indegree[i]=0;

//给indegree数组赋值,并输出各个顶点的入度

cout<

for(i=0; i

for(p=G.h[i].firstout; p!=NULL; p=p->hlink)

{

indegree[p->j]++;

cout<"<j].info<

}

cout<

for(i=0; i

cout<

cout<

initQueue(S);

fun(G,S,indegree,count,n);

delete []indegree;

clearQueue(S);

return n;

}

int main()

{

OLGraph Mat;

crtGraph1(Mat);

printf("邻接表构建成功!\n");

TopologicalSort_Stack(Mat);

return 0;

}