图的广度优先搜索遍历这里只列了迭代的算法，递归比较困难

搜索遍历需要借助一个队列。
每次将当前节点出队列，以及让该节点的所有未被访问的邻接节点入队列，重复直至队列为空。
节点的出队列的顺序构成了广度优先搜索的遍历序列。

采用邻接表时，复杂度为O(V+E)。采用邻接矩阵时，复杂度为O(V^2)。V为顶点数、E为边数。
两者的空间复杂度相同。

C++代码如下：
这里有2个函数，分别是：
邻接表 BFS
邻接矩阵 BFS

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

typedef int DATA_TYPE;  // 权值为int型
const DATA_TYPE NO_EDGE = 10000000;  // 表示没有该边

// 邻接矩阵
struct AdjMatrixGraph
{
    vector<vector<DATA_TYPE> > weights;
};

// 邻接表
struct AdjTableGraph
{
    vector<vector<int> > adjTable;
    vector<vector<DATA_TYPE> > adjWeights;  // 暂时用不到 维数与adjTable一致
};

// 邻接表广度优先搜索算法
vector<int> AdjTableBFS(AdjTableGraph graph, int startNode)
{
    int vertexNum = graph.adjTable.size();
    vector<int> visited(vertexNum, 0);
    vector<int> visitOrder;
    queue<int> trace;
    trace.push(startNode);
    visited[startNode] = 1;

    while (!trace.empty())
    {
        int currentNode = trace.front();
        trace.pop();
        visitOrder.push_back(currentNode);

        if (graph.adjTable[currentNode].size() > 0)
        {
            for (size_t i = 0; i < graph.adjTable[currentNode].size(); ++i)
            {
                if (visited[graph.adjTable[currentNode][i]] == 0)
                {
                    trace.push(graph.adjTable[currentNode][i]);
                    visited[graph.adjTable[currentNode][i]] = 1;
                }
            }
        }
    }

    return visitOrder;
}


// 邻接矩阵深度优先搜索算法
vector<int> AdjMatrixBFS(AdjMatrixGraph graph, int startNode)
{
    int vertexNum = graph.weights.size();
    vector<int> visited(vertexNum, 0);
    vector<int> visitOrder;
    queue<int> trace;
    trace.push(startNode);
    visited[startNode] = 1;

    while (!trace.empty())
    {
        int currentNode = trace.front();
        trace.pop();
        visitOrder.push_back(currentNode);

        for (size_t i = 0; i < vertexNum; ++i)
        {
            if (visited[i] == 0 && graph.weights[currentNode][i] < NO_EDGE)
            {
                trace.push(i);
                visited[i] = 1;
            }
        }
    }

    return visitOrder;
}


int main(int argc, char *argv[])
{

    // 图的初始化
    // 顶点编号必须为从0开始的连续的整数(若不是，先转换)
    // 图为有向图

    // ================邻接表方式===============
    AdjTableGraph graph;
    graph.adjTable.push_back(vector<int>{1, 3});
    graph.adjTable.push_back(vector<int>{2});
    graph.adjTable.push_back(vector<int>{4});
    graph.adjTable.push_back(vector<int>{2});
    graph.adjTable.push_back(vector<int>{});

    // 邻接表
    vector<int> visitOrder = AdjTableBFS(graph, 0);
    cout << "邻接表 BFS： ";
    for (size_t i = 0; i < visitOrder.size(); ++i)
    {
        cout << visitOrder[i] << " ";
    }
    cout << endl;


    // ===============邻接矩阵方式===============
    AdjMatrixGraph graph2;
    graph2.weights.push_back(vector<DATA_TYPE>{0, 8, NO_EDGE, 5, NO_EDGE});
    graph2.weights.push_back(vector<DATA_TYPE>{NO_EDGE, 0, 3, NO_EDGE, NO_EDGE});
    graph2.weights.push_back(vector<DATA_TYPE>{NO_EDGE, NO_EDGE, 0, NO_EDGE, 6});
    graph2.weights.push_back(vector<DATA_TYPE>{NO_EDGE, NO_EDGE, 9, 0, NO_EDGE});
    graph2.weights.push_back(vector<DATA_TYPE>{NO_EDGE, NO_EDGE, NO_EDGE, NO_EDGE, 0});

    // 邻接矩阵
    vector<int> visitOrder2 = AdjMatrixBFS(graph2, 0);
    cout << "邻接矩阵 BFS： ";
    for (size_t i = 0; i < visitOrder2.size(); ++i)
    {
        cout << visitOrder2[i] << " ";
    }
    cout << endl;

    return 0;
}

测试用例图如下：

编译环境(CLion 2016 with MinGW G++, GDB 7.11)

输出结果：
邻接表 BFS： 0 1 3 2 4
邻接矩阵 BFS： 0 1 3 2 4