基于邻接表的深度优先遍历 （非递归）

关键：利用栈来保存已经搜索到的顶点，利用top来返回上一个顶点。

描述

 

一个连通图采用邻接表作为存储结构。设计一个算法，实现从顶点v出发的深度优先遍历的非递归过程。

 

输入

多组数据，每组m+2数据行。第一行有两个数字n和m，代表有n个顶点和m条边。顶点编号为1到n。第二行到第m+1行每行有两个整数h和k，代表边依附的两个顶点。第m+2行有一个整数d，代表从d开始遍历。当n和m都等于0时，输入结束。

输出

每组数据输出一行，为深度优先搜索的遍历结果。每两个数字之间用空格隔开。

输入样例 1 

3 2
1 2
1 3
1
2 1
1 2
2
0 0

输出样例 1

1 2 3
2 1

 

 

#include<iostream>
#define maxn 100
using namespace std;
typedef struct node
{
    int data;
    struct node *next;
} Node;

void DFS(Node *V[], int d)
{
    Node *p;
    int visit[maxn];
    for (int i = 0; i < maxn; i++)
        visit[i] = 0;
    int Stack[maxn];
    int top = 0;
    cout << d;
    Stack[top++] = d;
    visit[d] = 1;
    while (top > 0)
    {
        p = V[Stack[top - 1]];
        int t = -1;
        while (p)
        {
            if (!visit[p->data])
            {
                t = p->data;
            }
            p = p->next;
        }
        if (t == -1)//说明这个点没有未被访问的邻接点
            top--;
        else
        {
            cout << " "<<t;
            Stack[top++] = t;
            visit[t] = 1;
        }
    }
    cout << endl;
}

int main()
{
    int n, m;
    int x, y, d;
    Node *p;
    Node *V[maxn];
    while (1)
    {
        cin >> n >> m;
        if (n == 0 && m == 0)
            break;
        for (int i = 0; i < maxn; i++)
        {
            V[i] = (Node *)malloc(sizeof(Node));
            V[i]->data = 0;
            V[i]->next = NULL;
        }
        while (m--)
        {
            cin >> x >> y;
            V[x]->data = x;
            V[y]->data = y;
            p = (Node *)malloc(sizeof(Node));
            p->data = y;
            p->next = V[x]->next;
            V[x]->next = p;
            p = (Node *)malloc(sizeof(Node));
            p->data = x;
            p->next = V[y]->next;
            V[y]->next = p;
        }
        cin >> d;
        DFS(V, d);
    }
    return 0;
}