图->有向无环图->拓扑排序

文字描述

　　关于有向无环图的基础定义：

　　　　一个无环的有向图称为有向无环图，简称DAG图(directed acycline graph)。DAG图是一类较有向树更一般的特殊有向图。

　　

　　　　举个例子说明有向无环图的应用。假如有一个表达式: ((a+b)*(b*(c+d))+(c+d)*e)*((c+d)*e), 可以用之前讨论的二叉树来表示，也可以用有向无环图来表示，如下图。显然有向无环图实现了对相同子式的共享，从而比二叉树更节省空间。

　　

　　关于拓扑排序的基础定义:

　　　　由某个集合上的一个偏序得到该集合上的一个全须，这个操作称之为拓扑排序。理解起来可能有点费解，但是通俗的讲，就是如下几个操作步骤：

　　　　　　1 在有向图中选一个没有前驱的顶点且输出之

　　　　　　2 从图中删除该顶点和所有以它为尾的弧。

　　　　重复上述两步，直至全部顶点均已输出，或者当前图中不存在无前驱的顶点为止。后一种情况说明有向图中存在环。

　　备注：AOV-网(Activity On Vertex Network)的意思是用顶点表示活动，用弧表示活动间的优先关系的有向图称为顶点表示活动的网。

 

示意图：

 

 

 

算法分析

　　对n个顶点和e条弧的有向图而言，建立求各顶点的入度的时间复杂度为O(e)；建零入度顶点栈的时间复杂度为O(n)；在拓扑排序过程中，若有向图无环，则每个顶点进一次栈，出一次栈，入度减1的操作在while语句中总共进行e次，所以总的时间复杂度为O(n+e)。

 

代码实现

 

//
// Created by lady on 18-12-28.
//
#include <stdio.h>
#include <stdlib.h>
#define MAX_VERTEX_NUM 20 //最大顶点数
typedef enum {DG,DN, UDG, UDN} GraphKind; //{有向图，有向网，无向图，无向网}
typedef struct ArcNode{
    int adjvex;    //该弧所指向的顶点的位置
    struct ArcNode *nextarc;    //指向下一条弧的指针
    char info;    //该弧相关信息的指针
}ArcNode;
typedef struct VNode{
    char data[10];//顶点信息
    ArcNode *firstarcIN;//第一条以该顶点为弧头的弧结点，其他顶点->该结点
    ArcNode *firstarcOUT;//第一条以该顶点为弧尾的弧结点，该结点->其他顶点
}VNode, AdjList[MAX_VERTEX_NUM];
typedef struct{
    AdjList vertices;
    int vexnum;//图的顶点数
    int arcnum;//图的弧数
    int kind; //图的种类标志
}ALGraph;

//根据顶点信息，返回该顶点在图中的位置坐标。
int LocateVex(ALGraph *G, char data[])
{
    int i = 0;
    for(i=0; i<G->vexnum; i++){
        if(!strncmp(G->vertices[i].data, data, strlen(G->vertices[i].data))){
            return i;
        }
    }
    return -1;
}

//利用头插法，在弧结点链表头部，插入位置v的弧结点
int InsFirst(ArcNode *L, int v)
{
    if((L==NULL) || (v<0)){
        return -1;
    }
    ArcNode *n = (ArcNode *)malloc(sizeof(struct ArcNode));
    n->adjvex = v;
    n->nextarc = L->nextarc;
    L->nextarc = n;
    return 0;
}

//采用邻接表存储方法，创建有向图
int CreateDG(ALGraph *G)
{
    printf("开始创建一个有向图,请输入顶点数，弧数:");
    int i = 0, j = 0, k = 0;
    char v1[10] = {0}, v2[10]={0};
    char tmp[20] = {0};
    G->kind = DG;
    scanf("%d,%d", &G->vexnum, &G->arcnum);
    for(i=0; i<G->vexnum; i++){
        printf("输入第%d个顶点: ", i+1);
        memset(G->vertices[i].data, 0, sizeof(G->vertices[i].data));
        scanf("%s", G->vertices[i].data);
        G->vertices[i].firstarcOUT = (struct ArcNode *)malloc(sizeof(struct ArcNode));
        G->vertices[i].firstarcOUT->adjvex = -1;
        G->vertices[i].firstarcOUT->nextarc = NULL;
        G->vertices[i].firstarcIN = (struct ArcNode *)malloc(sizeof(struct ArcNode));
        G->vertices[i].firstarcIN->adjvex = -1;
        G->vertices[i].firstarcIN->nextarc = NULL;
    }
    for(k=0; k<G->arcnum; k++)
    {
        printf("输入第%d条弧(顶点1, 顶点2): ", k+1);
        memset(tmp, 0, sizeof(tmp));
        scanf("%s", tmp);
        sscanf(tmp, "%[^','],%s[^\\n]", v1, v2);
        i = LocateVex(G, v1);
        j = LocateVex(G, v2);
        if(i<0 || j<0){
            printf("<%s,%s> is a invalid arch!\n", v1, v2);
            return -1;
        }
        InsFirst(G->vertices[i].firstarcOUT, j);
        InsFirst(G->vertices[j].firstarcIN, i);
    }
    return 0;
}

void printG(ALGraph *G)
{
    printf("\n");
    if(G->kind == DG){
        printf("类型：有向图；顶点数 %d, 弧数 %d\n", G->vexnum, G->arcnum);
    }else if(G->kind == DN){
        printf("类型：有向网；顶点数 %d, 弧数 %d\n", G->vexnum, G->arcnum);
    }else if(G->kind == UDG){
        printf("类型：无向图；顶点数 %d, 弧数 %d\n", G->vexnum, G->arcnum);
    }else if(G->kind == UDN){
        printf("类型：无向网；顶点数 %d, 弧数 %d\n", G->vexnum, G->arcnum);
    }
    int i = 0;
    ArcNode *p = NULL;
    printf("邻接表:\n");
    for(i=0; i<G->vexnum; i++){
        printf("(%d,%s)\t", i,G->vertices[i].data);
        p = G->vertices[i].firstarcOUT;
        while(p){
            if(p->adjvex >= 0)
                printf("(%d,%s)\t", p->adjvex, G->vertices[p->adjvex].data);
            p = p->nextarc;
        }
        printf("\n");
    }
    printf("逆邻接表:\n");
    for(i=0; i<G->vexnum; i++){
        printf("(%d,%s)\t", i,G->vertices[i].data);
        p = G->vertices[i].firstarcIN;
        while(p){
            if(p->adjvex >= 0)
                printf("(%d,%s)\t", p->adjvex, G->vertices[p->adjvex].data);
            p = p->nextarc;
        }
        printf("\n");
    }
    return;
}

#define STACK_INIT_SIZE 20  //栈的初始分配量大小
#define STACK_INCREMENT 5   //栈容量不足时需新增的容量大小
typedef struct {
    int *base;  //指向栈底指针
    int *top;   //指向栈顶指针
    int stacksize;  //栈的当前容量大小
}SqStack;

int InitStack(SqStack *s);  //初始化一个栈
int StackEmpty(SqStack *s); //判断栈是否为空
int Push(SqStack *S, int *e);  //入栈函数
int Pop(SqStack *S, int *e);    //出栈函数

//算法各个顶点的入度，并将结果存放在indegree数组中
int FindInDegree(ALGraph *G, int indegree[])
{
    printf("\n对各个顶点求入度...\n");
    int i = 0;
    ArcNode *p = NULL;
    for(i=0; i<G->vexnum; i++) {
        p = G->vertices[i].firstarcIN;
        while (p) {
            if (p->adjvex >= 0) {
                indegree[i] += 1;
            }
            p = p->nextarc;
        }
    }
    for(i=0; i<G->vexnum; i++){
        printf("(%d,%s)的入度为%d\n", i, G->vertices[i].data, indegree[i]);
    }
    return 0;
}

//进行拓扑排序
int ToplogicalSort(ALGraph *G)
{
    int i = 0;
    int k = 0;
    int count = 0;
    int indegree[MAX_VERTEX_NUM] = {0};
    ArcNode *p = NULL;
    SqStack S;
    //求各个顶点的入度
    FindInDegree(G, indegree);
    if(InitStack(&S) <0){
        return -1;
    }
    //将入度为0的顶点入栈.
    for(i=0; i<G->vexnum; i++){
        if(!indegree[i]) {
            Push(&S, &i);
        }
    }
    printf("\n进行拓扑排序:");
    while(StackEmpty(&S)){
        //如果栈不为空
        Pop(&S, &i);
        //输入i号顶点并计数
        printf("(%d,%s)\t", i, G->vertices[i].data);
        ++count;
        for(p=G->vertices[i].firstarcOUT; p; p=p->nextarc){
            //对i号顶点的每个邻接点的入度减1
            k = p->adjvex;
            if(!(--indegree[k])) {
                //若入度减为0,则入栈
                Push(&S, &k);
            }
        }
    }
    printf("\n");
    if(count < G->vexnum){
        printf("警告：该图有环路!!\n");
        return -1;
    }else{
        return 0;
    }
}

int main(int argc, char *argv[])
{
    ALGraph G;
    //创建有向图
    if(CreateDG(&G)<0){
        printf("创建有向图时出错!\n");
        return -1;
    }
    //打印图
    printG(&G);
    //进行拓扑排序
    ToplogicalSort(&G);
    return 0;
}


int InitStack(SqStack *S){
    S->base = (int *) malloc(STACK_INIT_SIZE * sizeof(int));
    if(!S->base){
        return -1;
    }
    S->top = S->base;
    S->stacksize = STACK_INIT_SIZE;
    return 0;
}

int StackEmpty(SqStack *s){
    if(s->base == s->top){
        return 0;
    }else{
        return -1;
    }
}

int Push(SqStack *s, int *e){
    if((s->top-s->base) >= s->stacksize){
        s->base = (int*)realloc(s->base, (s->stacksize+STACK_INCREMENT)*(sizeof(int)));
        if(!s->base){
            return -1;
        }
        s->top = s->base + s->stacksize;
        s->stacksize += STACK_INCREMENT;
    }
    if(e == NULL){
        return -1;
    }else{
        *s->top = *e;
    }
    s->top += 1;
    return 0;
}

int Pop(SqStack *s, int *e)
{
    if(s->top == s->base) {
        return -1;
    }else{
        s->top -=1;
        *e = *s->top;
        return 0;
    }
}

 

 

代码运行

 

/home/lady/CLionProjects/untitled/cmake-build-debug/untitled
开始创建一个有向图,请输入顶点数，弧数:6,8
输入第1个顶点: V1
输入第2个顶点: V2
输入第3个顶点: V3
输入第4个顶点: V4
输入第5个顶点: V5
输入第6个顶点: V6
输入第1条弧(顶点1, 顶点2): V1,V2
输入第2条弧(顶点1, 顶点2): V1,V3
输入第3条弧(顶点1, 顶点2): V1,V4
输入第4条弧(顶点1, 顶点2): V3,V2
输入第5条弧(顶点1, 顶点2): V3,V5
输入第6条弧(顶点1, 顶点2): V4,V5
输入第7条弧(顶点1, 顶点2): V6,V4
输入第8条弧(顶点1, 顶点2): V6,V5

类型：有向图；顶点数 6, 弧数 8
邻接表:
(0,V1)    (3,V4)    (2,V3)    (1,V2)    
(1,V2)    
(2,V3)    (4,V5)    (1,V2)    
(3,V4)    (4,V5)    
(4,V5)    
(5,V6)    (4,V5)    (3,V4)    
逆邻接表:
(0,V1)    
(1,V2)    (2,V3)    (0,V1)    
(2,V3)    (0,V1)    
(3,V4)    (5,V6)    (0,V1)    
(4,V5)    (5,V6)    (3,V4)    (2,V3)    
(5,V6)    

对各个顶点求入度...
(0,V1)的入度为0
(1,V2)的入度为2
(2,V3)的入度为1
(3,V4)的入度为2
(4,V5)的入度为3
(5,V6)的入度为0

进行拓扑排序:(5,V6)    (0,V1)    (2,V3)    (1,V2)    (3,V4)    (4,V5)    

Process finished with exit code 0