逐行翻译代码：typedef struct node { int adjvex; struct node *next; }node, *pointer; typedef struct node1 { int vex; int in; pointer link; }ALGraph; void createadlist(ALGraph G[], int n, int e) { int i, k, j; pointer q; for (i = 1; i <= n; i++) { G[i].vex = i; G[i].in=0; G[i].link = null; } for (k = 1; k <= e; k++) { scanf("%d%d", &i, &j); q = (pointer)malloc(sizeof(struct node)); q->adjvex = j; q->next = G[i].link; G[i].link = q; G[j].in++; } } void fun(ALGraph G[], int n, int v, int visit[]) { pointer p; int w; visit[v] = 1; printf("%3d", v); p = G[v].link; while (p != null) { w = p->adjvex; if (visit[w] == 0) { fun(G, n, w, visit); } p = p->next; } } int TopologicalSort(ALGraph G[],int &n) { SqStack S; InitSatack(S); for(int i=1;i<n;i++) { if(!G[i].in) Push(S,i); int count=0; while(!StackEmpty(S)) { Pop(S,i); printf(" %d ",i); ++count; pointer p; p=(pointer)malloc(sizeof(struct node)); for(p=G[i].link;p;p=p->next) { int k=p->adjvex; if(!(--G[k].in)) Push(S,k); } } if(count<G[i].in) printf("存在循环"); } return ok; }

这段代码是一个图的邻接表存储结构的实现。下面是逐行的代码翻译：

typedef struct node {
    int adjvex;
    struct node *next;
}node, *pointer;

typedef struct node1 {
    int vex;
    int in;
    pointer link;
}ALGraph;

定义了两个结构体，一个是邻接表中的节点，一个是邻接表中的图。

void createadlist(ALGraph G[], int n, int e) {
    int i, k, j;
    pointer q;
    for (i = 1; i <= n; i++)
    {
        G[i].vex = i;
        G[i].in=0;
        G[i].link = null;
    }
    for (k = 1; k <= e; k++)
    {
        scanf("%d%d", &i, &j);
        q = (pointer)malloc(sizeof(struct node));
        q->adjvex = j;
        q->next = G[i].link;
        G[i].link = q;
        G[j].in++;
    }
}

这个函数用于创建邻接表。首先对于每个节点，分别给它们赋值。然后遍历每一条边，读取起点和终点，为终点节点的入度加1，同时将起点节点作为终点节点的邻接表的头节点。

void fun(ALGraph G[], int n, int v, int visit[]) {
    pointer p;
    int w;
    visit[v] = 1;
    printf("%3d", v);
    p = G[v].link;
    while (p != null)
    {
        w = p->adjvex;
        if (visit[w] == 0)
        {
            fun(G, n, w, visit);
        }
        p = p->next;
    }
}

这个函数是深度优先遍历的实现。从给定的起点开始，访问该节点，并标记为已访问。然后遍历该节点的邻接表，如果邻接节点未被访问，则递归地访问该节点。

int TopologicalSort(ALGraph G[],int &n) {
    SqStack S;
    InitSatack(S);
    for(int i=1;i<n;i++)
    {
        if(!G[i].in)
            Push(S,i);
        int count=0;
        while(!StackEmpty(S))
        {
            Pop(S,i);
            printf(" %d ",i);
            ++count;
            pointer p;
            p=(pointer)malloc(sizeof(struct node));
            for(p=G[i].link;p;p=p->next)
            {
                int k=p->adjvex;
                if(!(--G[k].in))
                    Push(S,k);
            }
        }
        if(count<G[i].in)
            printf("存在循环");
    }
    return ok;
}

这个函数是拓扑排序的实现。首先建立一个栈，将所有入度为0的节点入栈。然后弹出栈顶元素，输出该节点，并将该节点指向的邻接节点的入度减1。如果邻接节点入度为0，则入栈。当栈为空时，如果输出的节点数小于节点总数，则说明存在环。最后返回ok表示排序完成。