图的深度优先遍历，基于邻接链表的非递归实现

测试数据基于上图，新增4->1的路径。程序存在内存泄漏。

使用时可以修改depth_first_search第二个参数，指定开始遍历的结点，只适用与连通图。如果错误，欢迎指正！！

#include <iostream>

#include <stack>


using namespace std;


/***************************************
 * 图的深度优先遍历
 * 基于邻接链表的非递归实现
 **************************************/


typedef char vertex_t;  //结点数据类型


//边结点
typedef struct _tag_edge_node_t
{
    int node_num;  //边终点所在数组序号
    _tag_edge_node_t* next_node;  //下一条边
}edge_node_t;


//顶点结点
typedef struct _tag_head_node_t
{
    vertex_t data;  //结点数据
    edge_node_t* first_edge;  //第一条边
}head_node_t;


#define MAX_NUMBER 20  //图中最大结点数目


//图结构
typedef struct _tag_graph_t
{
    head_node_t head_data[MAX_NUMBER];  //顶点数组
    unsigned int head_node_count;  //顶点数目
}graph_t;


void create_adjacency_list(graph_t* graph)
{
    edge_node_t* p_edge = NULL;
    if (graph == NULL)
        return;


    graph->head_node_count = 6;
    for (unsigned int i = 0; i < graph->head_node_count; ++i)
    {
        graph->head_data[i].data = 'A' + i;
        graph->head_data[i].first_edge = NULL;
    }


    graph->head_data[0].first_edge = new edge_node_t;
    p_edge = graph->head_data[0].first_edge;
    p_edge->node_num = 2;
    
    p_edge->next_node = new edge_node_t;
    p_edge = p_edge->next_node;
    p_edge->node_num = 4;


    p_edge->next_node = new edge_node_t;
    p_edge = p_edge->next_node;
    p_edge->node_num = 5;
    p_edge->next_node = NULL;


    graph->head_data[1].first_edge = new edge_node_t;
    graph->head_data[1].first_edge->node_num = 2;
    graph->head_data[1].first_edge->next_node = NULL;


    graph->head_data[2].first_edge = new edge_node_t;
    graph->head_data[2].first_edge->node_num = 3;
    graph->head_data[2].first_edge->next_node = NULL;


    graph->head_data[3].first_edge = new edge_node_t;
    graph->head_data[3].first_edge->node_num = 5;
    graph->head_data[3].first_edge->next_node = NULL;


    graph->head_data[4].first_edge = new edge_node_t;
    graph->head_data[4].first_edge->node_num = 1;
    graph->head_data[4].first_edge->next_node = 
        new edge_node_t;


    p_edge = graph->head_data[4].first_edge->next_node;
    p_edge->node_num = 3;
    p_edge->next_node = new edge_node_t;


    p_edge = p_edge->next_node;
    p_edge->node_num = 5;
    p_edge->next_node = NULL;
}


void depth_first_search(graph_t* graph, int start_pos)
{
    stack<int> visit_node;
    bool is_visit[MAX_NUMBER];  //访问标志数组
    for (int i = 0; i < MAX_NUMBER; ++i)
        is_visit[i] = false;


    cout<<graph->head_data[start_pos].data<<endl;
    is_visit[start_pos] = true;
    visit_node.push(start_pos);  //将第一个元素压栈
    while (!visit_node.empty())
    {
        int num = visit_node.top();
        edge_node_t* next = graph->head_data[num].first_edge;
        for (; next != NULL; next = next->next_node)  //存在边，且该边的终点未被访问
        {
            if (!is_visit[next->node_num])
            {
            cout<<graph->head_data[next->node_num].data<<endl;
            is_visit[next->node_num] = true;
            visit_node.push(next->node_num);
            break;
            }
        }
        if (next == NULL)  //以该结点为起点的所有终点访问完毕
            visit_node.pop();
    }
}


int main(int argc, char* argv[])
{
    graph_t graph;
    create_adjacency_list(&graph);
    depth_first_search(&graph, 0);
    return 0;

}