图相关算法（BFS,DFS等）

1. 首先代码如下：

#ifndef __GRAPH_H__
#define __GRAPH_H__

#include <vector>
#include <queue>
#include <stack>
#define  IN
#define OUT
#define INOUT
using namespace std;

namespace graphspace
{
    template <typename weight>
    struct Edge 
    {
        int nDestVertex;            //边的另一个顶点位置
        weight edgeWeight;            //边的权重
        Edge<weight> *pNextEdge;    //下一条边链指针

        Edge(int d, weight c, Edge<weight> *p = NULL)
            :nDestVertex(d), edgeWeight(c), pNextEdge(p)
        {}
    };

    template <typename vertexNametype, typename weight>
    struct Vertex
    {
        vertexNametype vertexName;        //顶点名字
        Edge<weight> *pAdjEdges;        //顶点所拥有的边

        Vertex(vertexNametype x, Edge<weight> *p = NULL)
            :vertexName(x), pAdjEdges(p)
        {}
    };

    //adjacency list based graph
    template <typename vertexNametype, typename weight>
    class ALGraph
    {
    public:
        explicit ALGraph();            //explicit修饰的构造函数不能担任转换函数
        ~ALGraph();
    public:


        bool insertAVertex(IN const vertexNametype vertexName);

        bool insertAEdge(IN const vertexNametype vertexName1, IN const vertexNametype vertexName2, IN const weight edgeWeight);

        bool removeAEdge(IN const vertexNametype vertexName1, IN const vertexNametype vertexName2, IN const weight edgeWeight);

        weight getMinWeight(IN const vertexNametype vertexName1, IN const vertexNametype vertexName2);

        int getVertexIndex(IN const vertexNametype vertexName);

        int getVertexNumber();

        vertexNametype getData(IN int index);

        int Dijkstra(IN const vertexNametype vertexName1);

        void DijkstraPrint(IN int index, IN int sourceIndex, IN vector<int> vecPreVertex);
        void DFS();            //递归深度优先搜索
        void NRDFS();        //非递归深度优先搜索    
        void NRBFS();        //非递归广度优先搜索
        friend ostream& operator<<(OUT ostream &out, IN const ALGraph<vertexNametype,weight> &graphInstance);   

    public:

        weight getEdgeWeight(IN const Edge<weight> *pEdge);

        void getVertexEdgeWeight(IN const int v1, OUT vector<weight> &DistanceArray);
        //存储顶点的vector
        vector< Vertex<vertexNametype, weight> > m_vertexArray;
    private:
        void DFS(int vertexNumber,bool visited[]);    
        void NRDFS(int vertexNumber,bool visited[]);    
        void NRBFS(int VertexNumber,bool visited[]);
    };

#include "graph_realize.h"

}

#endif

#ifndef __GRAPH_REALIZE__H_
#define __GRAPH_REALIZE__H_

/*#define VERTEXARRAYITE (vector< Vertex<vertexNametype, weight> >::iterator) */

template<typename vertexNametype, typename weight>
ALGraph<vertexNametype, weight>::ALGraph()
{
    if (!m_vertexArray.empty())
    {
        m_vertexArray.clear();
    }

}

template<typename vertexNametype, typename weight>
ALGraph<vertexNametype, weight>::~ALGraph()
{
    vector< Vertex<vertexNametype, weight> >::iterator iter;
    //遍历图中所有的顶点
    for(iter = m_vertexArray.begin(); iter != m_vertexArray.end(); iter++)
    {
        Edge<weight> *p = iter->pAdjEdges;
        //删除顶点的所有邻接边
        while(NULL != p)
        {
            iter->pAdjEdges = p->pNextEdge;
            delete p;
            p = iter->pAdjEdges;
        }
    }
    //清空存储顶点的vector
    if (!m_vertexArray.empty())
    {
        m_vertexArray.clear();
    }
}

//插入顶点
template<typename vertexNametype, typename weight>
bool ALGraph<vertexNametype, weight>::insertAVertex(IN const vertexNametype vertexName)
{
    Vertex<vertexNametype, weight> VertexInstance(vertexName, NULL);
    m_vertexArray.push_back(VertexInstance);

    return true;
}

template<typename vertexNametype, typename weight>
bool ALGraph<vertexNametype, weight>::insertAEdge(IN const vertexNametype vertexName1, 
                                                  IN const vertexNametype vertexName2, IN const weight edgeWeight)
{
    int v1 = getVertexIndex(vertexName1);
    if (-1 == v1)
    {
        cerr << "There is no vertex 1" << endl;
        return false;
    }

    int v2 = getVertexIndex(vertexName2);
    if (-1 == v2)
    {
        cerr << "There is no vertex 2" << endl;
        return false;
    }

    Edge<weight> *p = m_vertexArray.at(v1).pAdjEdges;
    while(p != NULL && p->nDestVertex != v2)
    {
        p = p->pNextEdge;
    }

    if (NULL == p)
    {
        //v2是边的另一个顶点，edgeWeight是边v1v2的权重，m_vertexArray.at(v1).pAdjEdges
        //是顶点v1的邻接边指针，此时边p的指向的下一个节点既是m_vertexArray.at(v1).pAdjEdges
        p = new Edge<weight>(v2, edgeWeight, m_vertexArray.at(v1).pAdjEdges);        //总是加入到链表头
        m_vertexArray.at(v1).pAdjEdges = p;
        return true;
    }
    if (v2 == p->nDestVertex)
    {
        Edge<weight> *q = p;
        p = new Edge<weight>( v2, edgeWeight, q->pNextEdge );            //允许两个节点之间有多条边，加入到同名节点边之后
        q->pNextEdge = p;
        return true;
    }

    return false;
}

template<typename vertexNametype, typename weight>
bool ALGraph<vertexNametype, weight>::removeAEdge(IN const vertexNametype vertexName1, 
                                                  IN const vertexNametype vertexName2, IN const weight edgeWeight)
{
    int v1 = getVertexIndex(vertexName1);
    if (-1 == v1)
    {
        cerr << "There is no vertex 1" << endl;
        return false;
    }

    int v2 = getVertexIndex(vertexName2);
    if (-1 == v2)
    {
        cerr << "There is no vertex 2" << endl;
        return false;
    }

    Edge<weight> *p = m_vertexArray.at(v1).pAdjEdges;
    Edge<weight> *q = NULL;
    while(p != NULL && p->nDestVertex != v2 )
    {
        q = p;
        p = p->pNextEdge;
    }
    if (NULL == p)
    {
        cerr << "Edge is not found" << endl;
        return false;
    }
    while( edgeWeight != p->edgeWeight && p->nDestVertex == v2)            
    {
        q = p;
        p = p->pNextEdge;
    }
    if (v2 != p->nDestVertex)
    {
        cerr << "Edge is not found" << endl;
        return false;
    }
    q->pNextEdge = p->pNextEdge;
    delete p;

    return true;
}

//返回一条边的权重
template<typename vertexNametype, typename weight>
weight ALGraph<vertexNametype, weight>::getEdgeWeight(IN const Edge<weight> *pEdge)
{
    return pEdge->edgeWeight;
}


//返回一个顶点所有边的权重，使用vector存储，vector的下标为边中
//目标顶点的索引
template<typename vertexNametype, typename weight>
void ALGraph<vertexNametype, weight>::getVertexEdgeWeight(IN const int v1, OUT vector<weight> &DistanceArray)
{
    Edge<weight> *p = m_vertexArray.at(v1).pAdjEdges;
    int prevIndex = -1;
    weight tmp;

    while(NULL != p)
    {
        //考虑两个顶点之间有相同的边只是权重不同
        //选择权重中最小的
        if (prevIndex == p->nDestVertex)
        {
            if (tmp > p->edgeWeight)
            {
                DistanceArray[prevIndex] = p->edgeWeight;
            }
        }
        else
        {
            DistanceArray[p->nDestVertex] = p->edgeWeight;
            prevIndex = p->nDestVertex;
            tmp = p->edgeWeight;
        }

        p = p->pNextEdge;
    }
}


//返回两点之间边的最小权值
template<typename vertexNametype, typename weight>
weight ALGraph<vertexNametype, weight>::getMinWeight(IN const vertexNametype vertexName1, 
                                                     IN const vertexNametype vertexName2)
{
    Edge<weight> *pEdge = NULL;
    int v1 = getVertexIndex(vertexName1);
    if (-1 == v1)
    {
        cerr << "There is no vertex 1" << endl;
        return false;
    }

    int v2 = getVertexIndex(vertexName2);
    if (-1 == v2)
    {
        cerr << "There is no vertex 2" << endl;
        return false;
    }

    Edge<weight> *p = m_vertexArray.at(v1).pAdjEdges;
    while (p != NULL && p->nDestVertex != v2)
    {
        p = p->pNextEdge;
    }
    if (NULL == p)
    {
        pEdge = NULL;
        return weight(0);
    }
    weight tmp = getEdgeWeight(p);
    pEdge = p;
    while (NULL != p && v2 == p->nDestVertex)
    {
        if (tmp > getEdgeWeight(p))
        {
            tmp = getEdgeWeight(p);
            pEdge = p;
        }
        p = p->pNextEdge;
    }
    return tmp;
}

//返回顶点在vector中的下标
template<typename vertexNametype, typename weight>
int ALGraph<vertexNametype, weight>::getVertexIndex(IN const vertexNametype vertexName)
{
    for (int i = 0; i < m_vertexArray.size(); i++)
    {
        if (vertexName == getData(i))
        {
            return i;
        }
    }
    return -1;
}

//返回顶点个数
template<typename vertexNametype, typename weight>
int ALGraph<vertexNametype, weight>::getVertexNumber()
{
    return m_vertexArray.size();
}

//返回vector中第i个顶点的名称
template<typename vertexNametype, typename weight>
vertexNametype ALGraph<vertexNametype, weight>::getData(IN int index)
{
    return m_vertexArray.at(index).vertexName;
}

//单源最短路径算法
template<typename vertexNametype, typename weight>
int ALGraph<vertexNametype, weight>::Dijkstra(IN const vertexNametype vertexName1)
{
    int sourceIndex = getVertexIndex(vertexName1);
    if (-1 == sourceIndex)
    {
        cerr << "There is no vertex " << endl;
        return false;
    }
    int nVertexNo = getVertexNumber();

    //the array to record the points have been included, if included the value is true
    //else is false
    //节点是否访问初始化
    vector<bool> vecIncludeArray;
    vecIncludeArray.assign(nVertexNo, false);
    vecIncludeArray[sourceIndex] = true;

    //the array to record the distance from vertex1
    //节点距离初始化
    vector<weight> vecDistanceArray;
    vecDistanceArray.assign(nVertexNo, weight(INT_MAX));
    vecDistanceArray[sourceIndex] = weight(0);

    //prev array to record the previous vertex
    //记录到达本节点的上一个节点，记录信息，用来输出最短路径
    vector<int> vecPrevVertex;
    vecPrevVertex.assign(nVertexNo, sourceIndex);

    getVertexEdgeWeight(sourceIndex, vecDistanceArray);

    int vFrom, vTo;

    while(1)
    {
        weight minWeight = weight(INT_MAX);
        vFrom = sourceIndex;
        vTo = -1;
        //找到没有访问过的且权值最小的边，vFrom记录
        //这条边的目标点。
        for (int i = 0; i < nVertexNo; i++)
        {
            if (!vecIncludeArray[i] && minWeight > vecDistanceArray[i])
            {
                minWeight = vecDistanceArray[i];
                vFrom = i;
            }
        }
        //如果最小的边权值是INT_MAX，说明再也没有可达的边，跳出循环
        if (weight(INT_MAX) == minWeight)
        {
            break;
        }
        //将最小的边的目标顶点加入到vecIncludeArray，
        //具体操作为将vecIncludeArray[vFrom] 置为true
        vecIncludeArray[vFrom] = true;

        Edge<weight> *p = m_vertexArray[vFrom].pAdjEdges;
        while (NULL != p)
        {
            weight wFT = p->edgeWeight;
            vTo = p->nDestVertex;
            if (!vecIncludeArray[vTo] && vecDistanceArray[vTo] > wFT + vecDistanceArray[vFrom])
            {
                vecDistanceArray[vTo] = wFT + vecDistanceArray[vFrom];
                vecPrevVertex[vTo] = vFrom;
            }
            p = p->pNextEdge;
        }
    }

    //print the shortest route of all vertexes
    for (int i = 0; i < nVertexNo; i++)
    {
        if (weight(INT_MAX) != vecDistanceArray[i])
        {
            cout << getData(sourceIndex) << "->" << getData(i) << ": ";
            DijkstraPrint(i, sourceIndex, vecPrevVertex);
            cout << "  " << vecDistanceArray[i];
            cout << endl;
        }
    }
    return 0;
}

template<typename vertexNametype, typename weight>  
void ALGraph<vertexNametype, weight>::DijkstraPrint(IN int index, IN int sourceIndex, IN vector<int> vecPreVertex)
{
    if (sourceIndex != index)
    {
        DijkstraPrint(vecPreVertex[index], sourceIndex, vecPreVertex);
    }
    cout << getData(index) << " ";
}

//非递归深度优先搜索
template<typename vertexNametype, typename weight>
void ALGraph<vertexNametype, weight>::NRDFS()
{
    int n=getVertexNumber();
    bool *visited=new bool[n];
    for (int i=0;i<n;i++)
    {
        visited[i]=false;
    }
    for (int i=0;i<n;i++)
    {
        if (!visited[i])
        {
            NRDFS(i,visited);
            cout<<endl;
        }
    }
    delete[] visited;
}

//非递归深度优先搜索
template<typename vertexNametype, typename weight>
void ALGraph<vertexNametype, weight>::NRDFS(int vertexNumber,bool visited[])
{
    stack<int> st;
    vector<int> vec;
    visited[vertexNumber]=true;
    st.push(vertexNumber);
    while(!st.empty())
    {
        int tmpVertexNumber=st.top();
        st.pop();
        vec.push_back(tmpVertexNumber);
        cout<<getData(tmpVertexNumber)<<"  ";
        Edge<weight> *pE=m_vertexArray.at(tmpVertexNumber).pAdjEdges;
        int flag=0;
        while(pE)
        {
            int tmpDesVertex=pE->nDestVertex;
            if (!visited[tmpDesVertex])
            {
                visited[tmpDesVertex]=true;
                st.push(tmpDesVertex);
            }
            pE=pE->pNextEdge;
        }
    }
}

//递归深度优先搜索
template<typename vertexNametype, typename weight>
void ALGraph<vertexNametype, weight>::DFS()
{
    int n=getVertexNumber();
    bool *visited=new bool[n];
    for (int i=0;i<n;i++)
    {
        visited[i]=false;
    }
    for (int i=0;i<n;i++)
    {
        if (!visited[i])
        {
            DFS(i,visited);
            cout<<endl;
        }
    }
    delete[] visited;
}


template<typename vertexNametype, typename weight>
void ALGraph<vertexNametype, weight>::DFS(int vertexNumber,bool visited[])
{
    cout<<getData(vertexNumber)<<"  ";
    visited[vertexNumber]=true;
    Edge<weight> *p=m_vertexArray.at(vertexNumber).pAdjEdges;
    while(p!=NULL)
    {
        if (!visited[p->nDestVertex])
        {
            DFS(p->nDestVertex,visited);
        }
        p=p->pNextEdge;
    }
}

//非递归广度优先搜索
template<typename vertexNametype, typename weight>
void ALGraph<vertexNametype, weight>::NRBFS()
{
    int n=getVertexNumber();
    bool *visited=new bool[n];
    for (int i=0;i<n;i++)
    {
        visited[i]=false;
    }
    for (int i=0;i<n;i++)
    {
        if (!visited[i])
        {
            NRBFS(i,visited);
            cout<<endl;
        }
    }
    delete[] visited;
}

//非递归广度优先搜索实现
template<typename vertexNametype, typename weight>
void ALGraph<vertexNametype, weight>::NRBFS(int VertexNumber,bool visited[])
{
    int n=getVertexNumber();
    cout<<getData(VertexNumber)<<"  ";
    visited[VertexNumber]=true;
    queue<int> q;
    q.push(VertexNumber);
    while(!q.empty())
    {
        VertexNumber=q.front();
        q.pop();
        Edge<weight> *p=m_vertexArray.at(VertexNumber).pAdjEdges;
        while(p!=NULL)
        {
            if (!visited[p->nDestVertex])
            {
                cout<<getData(p->nDestVertex)<<"  ";
                visited[p->nDestVertex]=true;
                q.push(p->nDestVertex);
            }
            p=p->pNextEdge;
        }
    }
}

template<typename vertexNametype, typename weight>   
ostream& operator<<(OUT ostream &out, IN  ALGraph<vertexNametype,weight> &graphInstance)
{
    int vertexNo = graphInstance.getVertexNumber();
    out << "This graph has " << vertexNo << "vertexes" << endl;

    for(int i = 0; i < vertexNo; i++)
    {
        vertexNametype x1 = graphInstance.getData(i);
        out << x1 << ":    ";

        Edge<weight> *p = graphInstance.m_vertexArray.at(i).pAdjEdges;
        while (NULL != p)
        {
            out << "(" << x1 << "," << graphInstance.getData(p->nDestVertex) << "," << p->edgeWeight << ")  ";
            p = p->pNextEdge;
        }
        out << endl;
    }
    return out;
}




#endif

#include <iostream>
#include "graph.h"
#include <fstream>
#include <string>
using namespace std;
using namespace graphspace;

void main()
{
    ALGraph<char, int> g;   
    char vertex;
    ifstream infile;
    infile.open("components.txt");
    //先读节点
    while (infile>>vertex && vertex!='q')
    {
        g.insertAVertex(vertex);
    }
    char source,dest;
    int weight;
    //接着读边
    while(infile>>source>>dest>>weight)
    {
        g.insertAEdge(source,dest,weight);
    }

    cout << g << endl << endl; 
    g.Dijkstra('A');
    cout<<"深度优先搜索："<<endl;
    g.DFS();
    cout<<"广度优先搜索："<<endl;
    g.NRBFS();

    cout<<"非递归深度优先搜索："<<endl;
    g.NRDFS();
    return;
}

测试文件：components.txt

A B C D E F G H I J K L M N O q
A B 1
A C 5 
A D 4
A E 3
B F 2
E F 1
E G 2
F G 7
H I 5
H J 8
I J 3
K L 1
K M 3
K N 5
L O 2
M O 4
B A 1
C A 5
D A 4
E A 3
F B 2
F E 1
G E 2
G F 7
I H 5
J H 8
J I 3
L K 1
M K 3
N K 5
O L 2
O M 4

运行结果：

2. 在上述代码中主要有图的BFS广度优先搜索，DFS深度优先搜索，单源最短路径（Dijkstra）算法。
3. DFS运行速度一般比BFS运行速度快一点，DFS比较适合使用递归方式书写，BFS适合使用队列进行书写。

4. 上述代码中也给出了DFS的非递归实现，非递归实现主要使用栈模拟递归程序，记录一些信息。

5. 代码中考虑到图的联通性问题，两个点之间存在多条路径问题。

6. 单源最短路径算法只能用于边权值非负的情况。

7. 注意Dijkstra是使用的用来输出最短路劲信息的方法，使用一个vecPrevVertex记录信息，使用递归方法打印最短路径。

8. Dijkstra算法流程如下：转载http://blog.csdn.net/v_JULY_v/article/details/6096981。算法是BFS的一个应用，在BFS的过程中记录及更新节点信息。

9. 这三个算法都相当重要，要熟练掌握。