写一段C++代码，用栈保存边结点指针实现基于邻接表的DFS非递归算法

好的，以下是实现基于邻接表的DFS非递归算法的C代码：

#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 100

typedef struct EdgeNode{
    int adjvex; // 存储邻接点在顶点数组中的下标
    struct EdgeNode *next; // 指向下一个邻接点的指针
}EdgeNode;

typedef struct VertexNode{
    int data; // 存储顶点信息
    EdgeNode *firstedge; // 指向第一个邻接点的指针
}VertexNode, AdjList[MAX_SIZE];

typedef struct Graph{
    AdjList adjList;
    int numVertexes, numEdges; // 记录顶点数和边数
}Graph;

typedef struct Stack{
    int top;
    int data[MAX_SIZE]; // 存储元素的数组
}Stack;

// 初始化栈
void InitStack(Stack *S){
    S -> top = -1;
}

// 判断栈是否为空
int StackIsEmpty(Stack S){
    return S.top == -1;
}

// 判断栈是否已满
int StackIsFull(Stack S){
    return S.top == MAX_SIZE - 1;
}

// 入栈
void Push(Stack *S, int x){
    if(StackIsFull(*S)){
        printf("Stack is full.\n");
        exit(1);
    }else{
        S -> data[++S -> top] = x;
    }
}

// 出栈
int Pop(Stack *S){
    if(StackIsEmpty(*S)){
        printf("Stack is empty.\n");
        exit(1);
    }else{
        return S -> data[S -> top--];
    }
}

// 基于邻接表的DFS非递归算法
void DFS_no_recursion(Graph G, int start){
    int visited[MAX_SIZE] = {0}; // visited数组用于标记顶点是否被访问
    Stack S;
    EdgeNode *p;
    InitStack(&S);
    Push(&S, start); // 先将起始顶点入栈
    visited[start] = 1;
    printf("%d ", G.adjList[start].data); // 输出起始顶点
    while(!StackIsEmpty(S)){
        int v = Pop(&S); // 取出栈顶元素
        p = G.adjList[v].firstedge; // 找到第一个邻接点
        while(p){
            if(!visited[p -> adjvex]){ // 如果邻接点未被访问
                visited[p -> adjvex] = 1; // 标记该邻接点已被访问
                printf("%d ", G.adjList[p -> adjvex].data); // 输出该邻接点的数据
                Push(&S, p -> adjvex); // 将该邻接点入栈
                break;
            }
            p = p -> next; // 继续找下一个邻接点
        }
    }
}

int main(){
    Graph G;
    int start = 0;
    G.numVertexes = 5;
    G.numEdges = 6;
    for(int i = 0; i < G.numVertexes; i++){ // 初始化顶点和邻接表
        G.adjList[i].data = i;
        G.adjList[i].firstedge = NULL;
    }
    // 添加边
    EdgeNode *e1 = (EdgeNode *)malloc(sizeof(EdgeNode));
    e1 -> adjvex = 1;
    EdgeNode *e2 = (EdgeNode *)malloc(sizeof(EdgeNode));
    e2 -> adjvex = 2;
    EdgeNode *e3 = (EdgeNode *)malloc(sizeof(EdgeNode));
    e3 -> adjvex = 3;
    EdgeNode *e4 = (EdgeNode *)malloc(sizeof(EdgeNode));
    e4 -> adjvex = 0;
    EdgeNode *e5 = (EdgeNode *)malloc(sizeof(EdgeNode));
    e5 -> adjvex = 2;
    EdgeNode *e6 = (EdgeNode *)malloc(sizeof(EdgeNode));
    e6 -> adjvex = 4;
    e1 -> next = G.adjList[0].firstedge;
    G.adjList[0].firstedge = e1;
    e2 -> next = G.adjList[1].firstedge;
    G.adjList[1].firstedge = e2;
    e3 -> next = G.adjList[2].firstedge;
    G.adjList[2].firstedge = e3;
    e4 -> next = G.adjList[3].firstedge;
    G.adjList[3].firstedge = e4;
    e5 -> next = G.adjList[4].firstedge;
    G.adjList[4].firstedge = e5;
    e6 -> next = G.adjList[0].firstedge;
    G.adjList[0].firstedge = e6;
    // 调用基于邻接表的DFS非递归算法
    printf("DFS:\n");
    DFS_no_recursion(G, start);
    printf("\n");
    return 0;
}