【数据结构】DFS求有向图的强连通分量

用十字链表结构写的，根据数据结构书上的描述和自己的理解实现。但理解的不透彻，所以不知道有没有错误。但实验了几个都ok.

#include <iostream>
#include <vector>
using namespace std;

//有向图十字链表表示
#define MAX_VERTEX_NUM 20

typedef struct ArcBox{
    int tailvex, headvex; //该弧尾和头顶点的位置
    struct ArcBox *hlink, *tlink; //分别指向弧头相同和弧尾相同的弧的链域
}ArcBox;

typedef struct VexNode{
    int data;
    ArcBox *firstin, *firstout;//分别指向该顶点的第一条入弧和出弧
}VexNode;

typedef struct{
    VexNode xlist[MAX_VERTEX_NUM]; //表头向量
    int vexnum, arcnum; //有向图的顶点数和弧数
}OLGraph;

//定位顶点在xlist中的位置
int LocateVex(OLGraph G, int data)
{
    for(int i = 0; i < G.vexnum; i++)
    {
        if(G.xlist[i].data == data)
        {
            return i;
        }
    }
    cout << "error the vertex "<< data << " is not in the list"<<endl;
    return -1;
}

//有向图十字链表创建
void CreateDG(OLGraph &G)
{
    cout << "please input the number of vertex, the number of arc:";
    cin >> G.vexnum >> G.arcnum;

    for(int i = 0; i < G.vexnum; i++)
    {
        cout << "please input vertex data:";
        cin >> G.xlist[i].data;

        G.xlist[i].firstin = NULL;  //初始化指针
        G.xlist[i].firstout = NULL;
    }

    for(int k = 0; k < G.arcnum; k++)
    {
        int v1, v2; //弧的尾和头
        cout << "please input the tail and head vertex of each tail:";
        cin >> v1 >> v2;

        int i = LocateVex(G, v1);
        int j = LocateVex(G, v2);
        ArcBox * p = new ArcBox;
        p->headvex = j;
        p->tailvex = i;
        p->hlink = G.xlist[j].firstin;
        p->tlink = G.xlist[i].firstout;

        G.xlist[j].firstin = p;
        G.xlist[i].firstout = p;
    }
}

//单向深度优先搜索
//输入: 图G, 开始遍历点v, 遍历标志visited, 遍历方向dir 0 表示从尾向头遍历 1表示从头到尾遍历, vecor存放跳出遍历的顺序
void DFS(OLGraph G, int v, int * visited, int dir, vector<int> * vec)
{
    visited[v] = 1;
    (*vec).push_back(v);
    if(dir == 0) //从尾向头遍历
    {
        ArcBox * w = G.xlist[v].firstout;
        while(w != NULL ) //注意 这里的while
        {
            if(visited[w->headvex] == 1)
            {
                w = w->tlink;
            }
            else//未访问过该点 递归遍历该点
            {
                DFS(G, w->headvex, visited, dir, vec);
                w = w->tlink;
            }
        }
    }
    else //从头向尾遍历
    {
        ArcBox * w = G.xlist[v].firstin;
        while(w != NULL)//查找下一个遍历点
        {
            if((visited[w->tailvex]) == 1)
            {
                w = w->hlink;
            }
            else//未访问过该点 递归遍历该点
            {
                DFS(G, w->tailvex, visited, dir, vec);
                w = w->hlink;
            }
        }
    }
}

//查找有向图强连通分量
vector<vector<int>> FindConnectedPart(OLGraph G)
{
    vector<vector<int>> ConnectedPart;
    vector<vector<int>> finished;
    int* visited = new int[G.vexnum];
    memset(visited, 0, G.vexnum * sizeof(int)); //初始化为全部没有访问过

    //从尾向头遍历
    for(int v = 0; v < G.vexnum; v++)
    {
        if(visited[v] == 0) //没有被访问过
        {
            vector<int> vec;
            DFS(G, v, visited, 0, &vec);
            finished.push_back(vec);
        }
    }

    //从头向尾遍历
    memset(visited, 0, G.vexnum * sizeof(int));
    vector<int>::iterator it;
    vector<vector<int>>::iterator it2;
    int* find = new int[G.vexnum]; //find标识顶点实际上是否被查找过
    for(int i = 0; i < G.vexnum; i++)
    {
        find[i] = 0;
        visited[i] = 1;
    }
    for(it2 = finished.begin(); it2 < finished.end(); it2++)
    {
        //已经遍历过的部分visited不变，即都是1； find[i]= 0的表示本次遍历时不遍历结点i,为了跳过i，设它们的visited[i]=1; 但实际上，它们还没有被访问到
        //比如从尾到头遍历时得到两个分量 （1,2,3,4）（5）
        //那么为了找到重连通分量，从头到尾遍历4,3,2,1时不应该经过5 即可能从头到尾遍历时的分量是（1 2 3 5）（4）
        // 但实际上重连通分量为(1,2,3)(4)(5)三个
        for(it = it2->begin(); it < it2->end(); it++)
        {
            visited[*it] = 0; //只把本次遍历考虑到的顶点的visited设为0，其他为1，就不会加人遍历了
            find[*it] = 1;
        }

        for(it = it2->begin(); it < it2->end(); it++)
        {
            if(visited[*it] == 0) //没有被访问过
            {
                vector<int> vec;
                DFS(G, *it, visited, 1, &vec);
                ConnectedPart.push_back(vec);
            }
        }
    }

    //输出重连通分量
    int n = 0;
    cout << "重连通分量有：" << endl;
    for(it2 = ConnectedPart.begin(); it2 < ConnectedPart.end(); it2++)
    {
        cout << ++n << ":";
        for(it = it2->begin(); it < it2->end(); it++)
        {
            cout << G.xlist[*it].data << " ";
        }
        cout<< endl;
    }

    delete [] visited;
    delete [] find;
    return ConnectedPart;
}

int main()
{
    OLGraph G;
    CreateDG(G);
    FindConnectedPart(G);

    return 0;
}

http://blog.csdn.net/wsniyufang/article/details/6604458里面有将更好的算法。我还没看。