2-3一个连通图采用邻接表作为存储结构，设计一个算法，实现从顶点v出发的深度优先遍历的非递归过程。用C语言实现，给出设计思路，给出时间复杂度，空间复杂度

设计思路：

1. 创建一个栈，并将起始顶点v压入栈中。

2. 当栈不为空时，取出栈顶元素，并将其标记为已访问。

3. 遍历与栈顶元素相连的未访问的顶点，将其压入栈中。

4. 重复步骤2和步骤3，直到栈为空。

时间复杂度：O(V+E)，其中V为顶点数，E为边数。

空间复杂度：O(V)，需要额外使用一个标记数组来记录每个顶点的访问状态。

C语言代码实现如下：

#include <stdio.h>
#include <stdlib.h>

#define MAX_VERTICES 100

typedef struct node {
    int vertex;
    struct node* next;
} Node;

typedef struct {
    Node* head;
} AdjList[MAX_VERTICES];

typedef struct {
    int visited[MAX_VERTICES];
    int vCount;
    AdjList adjList;
} Graph;

typedef struct {
    int items[MAX_VERTICES];
    int top;
} Stack;

void initGraph(Graph* g, int vCount) {
    g->vCount = vCount;
    for (int i = 0; i < vCount; i++) {
        g->visited[i] = 0;
        g->adjList[i].head = NULL;
    }
}

void addEdge(Graph* g, int src, int dest) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->vertex = dest;
    newNode->next = g->adjList[src].head;
    g->adjList[src].head = newNode;
}

void push(Stack* s, int item) {
    s->items[++s->top] = item;
}

int pop(Stack* s) {
    return s->items[s->top--];
}

int isEmpty(Stack* s) {
    return s->top == -1;
}

void dfsIterative(Graph* g, int start) {
    Stack stack;
    stack.top = -1;

    push(&stack, start);

    while (!isEmpty(&stack)) {
        int current = pop(&stack);

        if (!g->visited[current]) {
            printf("%d ", current);
            g->visited[current] = 1;
        }

        Node* temp = g->adjList[current].head;
        while (temp) {
            if (!g->visited[temp->vertex]) {
                push(&stack, temp->vertex);
            }
            temp = temp->next;
        }
    }
}

int main() {
    Graph g;
    int vCount = 6;
    initGraph(&g, vCount);

    addEdge(&g, 0, 1);
    addEdge(&g, 0, 2);
    addEdge(&g, 1, 3);
    addEdge(&g, 2, 3);
    addEdge(&g, 2, 4);
    addEdge(&g, 3, 5);

    printf("DFS Iterative: ");
    dfsIterative(&g, 0);

    return 0;
}