数据结构实验——图的基本操作(未完待续）

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

int indegree[Maxsize],outdegree[Maxsize];  
  
typedef char InfoType;///图的邻接表存储结构  
typedef char VertexType; ///节点数据为字符型  
typedef struct ArcNode ///表节点  
{  
    int adjvex; ///存放结点的下标  
    struct ArcNode *nextarc;///指向下一条边或弧的指针域  
    InfoType *info;///其他信息  
} ArcNode;  
typedef struct VNode ///头结点  
{  
    VertexType data;  
    ArcNode *firstarc;  
} VNode,AdjList[Maxsize];  
typedef struct ///图结构  
{  
    AdjList vertices;  
    int vexnum,arcnum;///图中顶点个数和边的个数  
    int kind; ///kind==0表示无向图，kind==1表示有向图  
} ALGraph;  
  
int visited[Maxsize];  
  
void Create(ALGraph &G)  
{  
    char ch1,ch2;  
    int k1,k2;  
    printf("Please Input the Vexnum & Arcnum:\n");  
    scanf("%d%d",&G.vexnum,&G.arcnum);  
    printf("Please Input the Vexnums:\n");  
    for(int i=1; i<=G.vexnum; i++) ///图结构的下标从1开始用  
    {  
        scanf(" %c",&G.vertices[i].data);  
        G.vertices[i].firstarc=NULL;  
    }  
    printf("Please Input the Arcnums:\n");  
    for(int i=1; i<=G.arcnum; i++)  
    {  
        scanf(" %c %c",&ch1,&ch2);  
        for(int p=1; p<=G.arcnum; p++)  
        {  
            if(G.vertices[p].data==ch1)  
            {  
                k1=p;  
                break;  
            }  
        }  
        for(int p=1; p<=G.arcnum; p++)  
        {  
            if(G.vertices[p].data==ch2)  
            {  
                k2=p;  
                break;  
            }  
        }  
        ArcNode *pp;///申请一个表节点之后进行前插,前插，特别注意  
        pp=(ArcNode*)malloc(sizeof(ArcNode));  
        pp->adjvex=k2;  
        pp->nextarc=G.vertices[k1].firstarc;  
        G.vertices[k1].firstarc=pp;  
    }  
}  
  
void Dfs(ALGraph G,VertexType x)///深搜,从节点元素为x开始搜索  
{  
    //ALGraph G=GG;  
    int k1;  
    for(int i=1; i<=G.vexnum; i++)  
    {  
        if(G.vertices[i].data==x)  
        {  
            k1=i;  
            break;  
        }  
    }  
    printf("%c ",G.vertices[k1].data);  
    visited[k1]=1;  
    ArcNode *p;  
    p=G.vertices[k1].firstarc;  
    while(p)///如果该点的第一邻接点存在  
    {  
        if(visited[p->adjvex]==0) ///如果第一邻接点没有被遍历过  
        {  
            Dfs(G,G.vertices[p->adjvex].data); ///就去图中以该点的元素为起始点深度优先遍历  
        }  
        p=p->nextarc;///不然的话，即如果说该点已经被遍历过了，就让p指针后移  
    }  
}  
  
void Bfs(ALGraph G,VertexType x)///按广度非递归优先遍历图G  
{  
    struct  
    {  
        ArcNode *Q[Maxsize];  
        int front,rear;  
    } QQ; ///队列中存放的是表节点的地址  
    ArcNode *p;  
    QQ.front=QQ.rear=0;///队列初始化  
    int k1;  
    for(int i=1; i<=G.vexnum; i++)  
    {  
        if(G.vertices[i].data==x) ///在图中遍历找到元素值为x的点，返回其下标k1  
        {  
            k1=i;  
            break;  
        }  
    }  
    visited[k1]=1;  
    printf("%c ",G.vertices[k1].data);  
    QQ.rear=(QQ.rear+1)%Maxsize;  
    QQ.Q[QQ.rear]=G.vertices[k1].firstarc;  
    while(QQ.rear!=QQ.front)  
    {  
        QQ.front=(QQ.front+1)%Maxsize;  
        p=QQ.Q[QQ.front];  
        while(p)  
        {  
            if(visited[p->adjvex]==0)///visited[]中的下标即为每个节点的标号，和图中的下标相对应  
            {  
                visited[p->adjvex]=1;  
                printf("%c ",G.vertices[p->adjvex].data);  
                QQ.rear=(QQ.rear+1)%Maxsize;  
                QQ.Q[QQ.rear]=G.vertices[p->adjvex].firstarc;  
            }  
            p=p->nextarc;  
        }  
    }  
}  
  
void Output(ALGraph G)  
{  
    for(int i=1; i<=G.vexnum; i++)  
    {  
        printf("%c ",G.vertices[i].data);  
        ArcNode *pp;  
        pp=G.vertices[i].firstarc;  
        while(pp)  
        {  
            printf("%c ",G.vertices[pp->adjvex].data);  
            pp=pp->nextarc;  
        }  
        printf("\n");  
    }  
}  
  
void Degree(ALGraph G)  
{  
    ArcNode *pp=NULL;  
    for(int i=1; i<=G.vexnum; i++)  
    {  
        pp=G.vertices[i].firstarc;  
        while(pp)  
        {  
            indegree[pp->adjvex]++;  
            outdegree[i]++;  
            pp=pp->nextarc;  
        }  
    }  
}  
  
int TopologicalSort(ALGraph G)  
{  
    int S[Maxsize];  
    int top=0;  
    for(int i=1; i<=G.vexnum; i++)  
    {  
        if(indegree[i]==0)  
        {  
            top++;  
            S[top]=i;  
        }  
    }  
    int countt=0;  
    int ii=1;  
    ArcNode *pp=NULL;  
    while(top!=0)  
    {  
        ii=S[top];  
        top--;  
        printf("%d %c     ",ii,G.vertices[ii].data);  
        countt++;  
        for(pp=G.vertices[ii].firstarc; pp; pp=pp->nextarc)  
        {  
            int k=pp->adjvex;  
            indegree[k]--;  
            if(indegree[k]==0)  
            {  
                top++;  
                S[top]=k;  
            }  
        }  
    }  
    if(countt