dfs 邻接表表示的无向无权图（栈和递归方法）

相比　　　　邻接表LINk　　

完善数据结构：结点名字ElemType

 

　　上图：

 

 

 　　上码：

// vs 2015
// 邻接表 无向不带权


#include <iostream>
#include <stack>

using namespace std;
#define MAX 10

typedef int ElemType;            //结点被标记的类型
//弧结点
typedef struct ArcNode {
    ElemType name;                //与顶点相连的弧name
    struct ArcNode *next;        //下一个兄弟弧
} ArcNode;
//顶点信息
typedef struct VNode {
    ElemType name;                //顶点被标记名字
    ArcNode * firstarc;            //顶点连接的第一条弧（左右不敏感）
} VNode, AdjList[MAX];
//邻接表
typedef struct {
    AdjList vertinfo;            //hash表
    int vexnum;                    //顶点数
    int arcnum;                    //弧数
} AdjGraph;


int visited[MAX];
void dfs_byecursion(AdjGraph G, ElemType stapos)
{
    //-------增强健壮性，主要检测第一个stapos是否在图中------

    bool isIn = false;        //判断stapos结点是否在图中
    int pos = 0;            //记录结点在vertinfo中的索引
    for (int i = 0; i < G.vexnum; i++)
        if (stapos == G.vertinfo[i].name) {
            isIn = true;
            pos = i;
            break;
        }
    if (!isIn)
        return;                //不在图中，跳出

    visited[pos] = 1;        //若在图中，则操作此结点后进行标记
                            //此后pos无用，用来记录邻接点在vertinfo中的位置
    cout << G.vertinfo[pos].name << '	';
        /*
            function();        //这里仅仅输出
        */
    //------------------------------------------------------
    
    ArcNode *temp;            //临时弧指针，指向stapos结点的邻接点
    temp = G.vertinfo[pos].firstarc;
    while (temp != NULL)
    {
        for (int i = 0; i < G.vexnum; i++) {
            if (temp->name == G.vertinfo[i].name)
            {
                pos = i;
                break;
            }
        }
        // temp->name 代表的是结点的邻接点名字，要判断visited则要找到在vertinfo中的下标

        //--------------------------------------------
        if (!visited[pos])
            dfs_byecursion(G, temp->name);
        temp = temp->next;
    }
}
void travelallnodes_dfs_byecrusion(AdjGraph G) {
    cout << "dfs all nodes :" << endl;
    int partnum = 1;
    for (int i = 0; i < G.vexnum; i++) {
        if (!visited[i]) {
            cout << "part " << partnum++ << " :" << endl;
            dfs_byecursion(G, G.vertinfo[i].name);
            cout << endl;
        }
    }
    cout << "-----dfs all nodes over!" << endl;
}
int main()
{
    AdjGraph ag;

    ag.vexnum = 6, ag.arcnum = 5;
    ArcNode acn[10];
    ag.vertinfo[0].name = 1;
    acn[0].name = 2, acn[1].name = 3, acn[2].name = 5;
    ag.vertinfo[0].firstarc = &acn[0];
    acn[0].next = &acn[1], acn[1].next = &acn[2], acn[2].next = NULL;
    
    ag.vertinfo[1].name = 2;
    acn[3].name = 1, acn[4].name = 4;
    ag.vertinfo[1].firstarc = &acn[3];
    acn[3].next = &acn[4], acn[4].next = NULL;
    
    ag.vertinfo[2].name = 3;
    acn[5].name = 1, acn[6].name = 5;
    acn[5].next = &acn[6], acn[6].next = NULL;
    ag.vertinfo[2].firstarc = &acn[5];
    
    ag.vertinfo[3].name = 4;
    acn[7].name = 2, acn[7].next = NULL;
    ag.vertinfo[3].firstarc = &acn[7];
    
    ag.vertinfo[4].name = 5;
    acn[8].name = 3, acn[9].name = 1;
    acn[8].next = &acn[9], acn[9].next = NULL;
    ag.vertinfo[4].firstarc = &acn[8];
    
    ag.vertinfo[5].name = 5;
    ag.vertinfo[5].firstarc = NULL;

    for (int i = 0; i < ag.vexnum; i++)
        visited[i] = 0;        //初始化递归方法需要使用的visited全局数组
    
    //第二个参数：结点名字
    dfs_byecursion(ag, 2);
    travelallnodes_dfs_byecrusion(ag);

    return 0;
}

栈 方法遍历图：

 

void dfs_bystack(AdjGraph G, ElemType stapos)
{
    bool isIn = false;                                                //判断stapos结点是否在图中
    int pos = 0;                                                    //记录结点在vertinfo中的索引
    for (int i = 0; i < G.vexnum; i++)
        if (stapos == G.vertinfo[i].name) {
            isIn = true;
            pos = i;
            break;
        }
    if (!isIn)
        return;                                                        //不在图中，跳出

    int visited[MAX];
    for (int i = 0; i < G.vexnum; i++) visited[i] = 0;

    stack<int> index;                                                //记录顶点索引的栈

    for(int i=0; i<G.vexnum; i++)                                    //找到开始点，并标记，打印，入栈
        if (G.vertinfo[i].name == stapos) {
            cout << stapos << "	";
            visited[i] = 1;
            index.push(i);
            break;
        }

    while (!index.empty())
    {
        ArcNode *ptemp = G.vertinfo[index.top()].firstarc;        //栈顶顶点弧指针
        int isPushed = 0;                                        //是否有邻接点入栈
        while (ptemp != NULL)                                    //找栈顶顶点未访问的邻接点
        {
            for (int i = 0; i < G.vexnum; i++)
            {
                if (ptemp->name == G.vertinfo[i].name && visited[i]) {
                    ptemp = ptemp->next;
                    break;
                }
                if (ptemp->name == G.vertinfo[i].name && !visited[i]) {
                    cout << G.vertinfo[i].name << '	';
                    index.push(i);
                    visited[i] = 1;
                    isPushed = 1;
                    break;
                }
            }
            if (isPushed)                                        //找到邻接点，出循环
                break;
        }

        if (!isPushed)                                            //无邻接点或邻接点全部被访问，栈顶索引出栈
        {
            index.pop();
        }
    }
}