/*（1）输入一组顶点，建立有向图的邻接表,进行DFS（深度优先遍历）和BFS（广度优先遍历）。
写出深度优先遍历的递归和非递归算法。
（2）根据建立的有向图，判断该图是否是有向无环图，若是，则输出其一种拓扑有序序列。*/
#include<stdio.h>
#include<stdlib.h>
#define max 20
#define SIZE 20
#define MORE 10
typedef struct ArcNode{
    int adjvex; //该弧所指向的顶点的位置
    struct ArcNode *nextarc; //指向下一条弧的指针 
}ArcNode;
typedef struct VNode{
    char data;  //顶点信息
    ArcNode *firstarc; //指向第一条依附该顶点的弧的指针  
}VNode,AdjList[max];
typedef struct{
    AdjList vertices;
    int vexnum,arcnum;
}ALGraph;

typedef struct{
    int *base;
    int *top;
    int stacksize;
}SqStack;
void InitStack(SqStack &S){
    //构造一个空栈 
    S.base=(int *)malloc(SIZE*sizeof(int));
    if(!S.base) return ;
    S.top=S.base;
    S.stacksize=SIZE;
}
int StackEmpty(SqStack &S){
    //判空 是返回1 否返回0
    if(S.top==S.base) return 1;
    else return 0;	
} 
void Push(SqStack &S,int e){
    //入栈 
    if(S.top-S.base>=S.stacksize){
        S.base=(int *)realloc(S.base,(S.stacksize+MORE)*sizeof(int));
        if(!S.base) exit(0);
        S.top=S.base+S.stacksize;
        S.stacksize+=MORE;
    }
    *S.top++=e;
}
void Pop(SqStack &S,int &e){
    //出栈
    if(S.top==S.base) exit(0);
    else
        e=*--S.top; 
}
void GetTop(SqStack S,int &e){
    //取栈顶元素 
    if(S.top==S.base)  exit(0);
    else
        e=*(S.top-1);
}
void CreatGraph(ALGraph &G){
    int i,s,e;
    ArcNode *p,*q;
    printf("输入结点数目和边数：");
    scanf("%d%d",&G.vexnum,&G.arcnum);
    getchar();
    printf("输入顶点信息：\n");
    for(i=1;i<=G.vexnum;i++){
        scanf("%c",&G.vertices[i].data);
        G.vertices[i].firstarc=NULL;
    } 
    getchar();
    printf("输入一条边依附的起点序号和终点序号：\n");
    for(i=1;i<=G.arcnum;i++){
        scanf("%d%d",&s,&e);
        getchar();
        p=(ArcNode *)malloc(sizeof(ArcNode));
        p->nextarc=NULL;
        p->adjvex=e;
        q=G.vertices[s].firstarc;
        if(!q)
            G.vertices[s].firstarc=p;
        else{
            while(q->nextarc){
                q=q->nextarc;
            }
            q->nextarc=p;
        }
    }
}
void PrintGraph(ALGraph G){
    int i;
    printf("打印有向图：\n");
    for(i=1;i<=G.vexnum;i++){
        printf("%3c",G.vertices[i].data);
        if(G.vertices[i].firstarc==NULL){
            printf("\n");
            continue;
        }
        while(G.vertices[i].firstarc){
            printf("%3d",G.vertices[i].firstarc->adjvex);
            G.vertices[i].firstarc=G.vertices[i].firstarc->nextarc;
        }
        printf("\n");
    }
}
int visited1[max];
void Dfs(ALGraph G,int v){
    ArcNode *p;
    int w;
    visited1[v]=1;
    printf("%c",G.vertices[v].data);
    p=G.vertices[v].firstarc;
    while(p){
        w=p->adjvex;
        if(!visited1[w])
            Dfs(G,w);
            p=p->nextarc;
    }
}
void DfsTraverse(ALGraph G){
    //深度优先遍历递归算法 
    int v;
    for(v=1;v<=G.vexnum;v++){
        visited1[v]=0;
    } 
    for(v=1;v<=G.vexnum;v++){
        if(!visited1[v])
            Dfs(G,v);
    }	
}
void DfsTraverse2(ALGraph G,int v){
    //从第v个顶点进行深度优先遍历（非递归） 
    int visited2[max],n,i;
    for(i=1;i<=G.vexnum;i++)
        visited2[i]=0;
    ArcNode *p;
    SqStack S;
    InitStack(S);
    visited2[v]=1;
    printf("%c",G.vertices[v].data);
    Push(S,v);
    while(!StackEmpty(S)){
        GetTop(S,v);
        p=G.vertices[v].firstarc;
        while(p)
            if(visited2[p->adjvex])
                p=p->nextarc;
            else{
                printf("%c",G.vertices[p->adjvex].data);
                visited2[p->adjvex]=1;
                Push(S,p->adjvex);
                p=G.vertices[p->adjvex].firstarc;
            }
        if(!StackEmpty(S)){
            Pop(S,n);
        }
    }
}
int q[max],f=0,r=0;
int visited2[max];
void BfsTraverse(ALGraph G,int s){
    //广度优先遍历的递归算法 
    ArcNode *p;
    if(!visited2[s]){
        printf("%c",G.vertices[s].data);
        visited2[s]=1;
        p=G.vertices[s].firstarc;
        while(p){
            if(!visited2[p->adjvex])
                q[r++]=p->adjvex;
            p=p->nextarc;
        }
    }
    while(f<r){
       BfsTraverse(G,q[f++]);
    }
}
void FindInDegree(ALGraph G,int indegree[]){
    //求顶点入度
    ArcNode *p;
    int i;
    for(i=1;i<=G.vexnum;i++) //初始化
        indegree[i]=0;
    for(i=1;i<=G.vexnum;i++){
        p=G.vertices[i].firstarc;
        while(p){
            indegree[p->adjvex]++;
            p=p->nextarc;
        }
    } 
}
void TopologicalSort(ALGraph G){
    //拓扑排序
    ArcNode *p;
    SqStack S;
    int count;
    int i,k,indegree[max];
    FindInDegree(G,indegree); //求入度 
    InitStack(S);
    for(i=1;i<=G.vexnum;i++)// 将入度为零的点压入栈
        if(!indegree[i]) Push(S,i);
    count=0;
    while(!StackEmpty(S)){
        Pop(S,i);
        printf("%c",G.vertices[i].data);
        count++;
        for(p=G.vertices[i].firstarc;p;p=p->nextarc){
            k=p->adjvex;
            if(!(--indegree[k])) Push(S,k);
        }
    }
    if(count<G.vexnum){
        printf("该图有回路\n");
        exit(0);
    }
}
int main(){
    ALGraph G;
    CreatGraph(G);
    PrintGraph(G);
    printf("\nDfs(递归):");
    DfsTraverse(G);
    printf("\nDfs(非递归):");
    DfsTraverse2(G,1);
    printf("\nBfs:");
    BfsTraverse(G,1);
    printf("\n拓扑排序：\n");
    TopologicalSort(G);
    return 0;
}