#include <iostream>
#include <algorithm>
#include <iterator>

using namespace std;    

#define MAX_VERTEX_NUM 10

struct Node
{
    int adjvex;
    struct Node *next;
    int info;
};

typedef struct VNode
{
    char data;
    Node *first;
}VNode, AdjList[MAX_VERTEX_NUM];

struct Graph 
{
    AdjList vertices;
    int vexnum, arcnum;
};

int visited[MAX_VERTEX_NUM];

int locateVex(Graph G, char u)
{
    int i;
    for (i = 0; i < G.vexnum; i++)
    {
        if (u == G.vertices[i].data)
            return i;
    }

    if (i == G.vexnum)
    {
        printf("Error u!\n");
        exit(1);
    }

    return 0;
}

void createGraph(Graph &G)
{
    int i, j, k, w;
    char v1, v2, enter;

    Node *p;
    printf("input vexnum & arcnum:\n");
    scanf("%d", &G.vexnum);
    scanf("%d", &G.arcnum);
    printf("input vertices:\n");
    for (i = 0; i < G.vexnum; i++)
    {
        scanf("%c%c", &enter, &G.vertices[i].data);
        G.vertices[i].first = NULL;
    }

    printf("input Arcs(v1, v2, w):\n");
    for (k = 0; k < G.arcnum; k++)
    {
        scanf("%c%c", &enter, &v1);
        scanf("%c%c", &enter, &v2);
        scanf("%d", &w);
        i = locateVex(G, v1);
        j = locateVex(G, v2);
        p = (Node *)malloc(sizeof(Node));
        p->adjvex = j;
        p->info = w;
        p->next = G.vertices[i].first;
        G.vertices[i].first = p;
    }
}

void DFS(Graph &G, int v)
{
    Node *p;
    printf("%c", G.vertices[v].data);
    visited[v] = 1;
    p = G.vertices[v].first;

    while (p)
    {
        if (!visited[p->adjvex])
            DFS(G, p->adjvex);
        p = p->next;
    }
}

void DFSTranverse(Graph &G)
{
    for (int v = 0; v < G.vexnum; v++)
        visited[v] = 0;
    for (int v = 0; v < G.vexnum; v++)
    {
        if (!visited[v])
            DFS(G, v);
    }
}

int main()
{
    Graph G;
    createGraph(G);
    DFSTranverse(G);
}

换了一种方式来写DFS

代码如下：

#include <iostream>
#include <string>

using namespace std;

#define MAXLEN 10

struct Node
{
    int data;
    Node *next;
};

struct Link
{
    int count;
    string name;
    Node *head;
};

struct Graph
{
    Link link[MAXLEN];
    int vexnum;
    int arcnum;
};

int findIndex(Graph &G, string name)
{
    int index = -1;

    for (int i = 0; i < G.vexnum; i++)
    {
        if (G.link[i].name == name)
        {
            index = i;
            break;
        }
    }

    if (index == -1)
        cout << "error" << endl;
    
    return index;
}

void constructGraph(Graph &G)
{
    cout << "construct graph yooo" << endl;
    cout << "enter vexnum" << endl;
    cin >> G.vexnum;

    string array[] = {"v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8"};
    const int size = sizeof array / sizeof *array;

    for (int i = 0; i < G.vexnum; i++)
    {
        G.link[i].name = array[i];
        G.link[i].head = NULL;
    }

    string leftName;
    string rightName;

    cout << "enter a pair" << endl;
    cin >> leftName >> rightName;
    while (leftName != "end" && rightName != "end")
    {
        int leftIndex = findIndex(G, leftName);
        int rightIndex = findIndex(G, rightName);

        Node *node = new Node;
        node->data = rightIndex;
        node->next = NULL;

        node->next = G.link[leftIndex].head;
        G.link[leftIndex].head = node;

        cout << "enter a pair" << endl;
        cin >> leftName >> rightName;
    }
}

bool flag[MAXLEN];

void DFSTranverse(Graph &G, int num)
{
    cout << G.link[num].name << " ";
    flag[num] = true;

    Node *head = G.link[num].head;
    while (head != NULL)
    {
        int index = head->data;
        if (!flag[index])
            DFSTranverse(G, index);
        head = head->next;
    }
}

void main()
{
    Graph G;
    constructGraph(G);
    for (int i = 0; i < MAXLEN; i++)
        flag[i] = false;
    DFSTranverse(G, 0);
}

DFS的迭代遍历算法：

void DFS(Graph &G)
{
    stack<int> istack;
    istack.push(0);

    cout << G.link[0].name << " ";
    flag[0] = true;

    while (!istack.empty())
    {
        int index = istack.top();
        Node *head = G.link[index].head;

        while (head != NULL && flag[head->data] == true)
            head = head->next;

        if (head != NULL)
        {
            index = head->data;
            if (!flag[index])
            {
                cout << G.link[index].name << " ";
                flag[index] = true;
                istack.push(index);
            }
        }
        else
            istack.pop();
    }
}