广度优先搜索算法

vertex.h

#ifndef _VERTEX_H_
#define _VERTEX_H_
#include <ostream>

enum BFS_VERTEX_COLOR {
    WHITE,
    GRAY,
    BLACK,
};

struct Vertex {
    int index;
    BFS_VERTEX_COLOR color = WHITE;
    int d = -1;
    int pre_index = -1;

    bool operator==(const Vertex& v) {
        return index == v.index;
    }

    void set(BFS_VERTEX_COLOR color, int d, int pre_index) {
        this->color = color;
        this->d = d;
        this->pre_index = pre_index;
    }
};

std::ostream & operator<<(std::ostream & os, const Vertex &v);

#endif

vertex.cpp

#include <string>
#include "vertex.h"

using namespace std;

ostream & operator<<(ostream & os, const Vertex &v) {
    os << static_cast<char>(v.index) << "(";
    
    string color_str = "";
    if (v.color == WHITE) {
        color_str = "WHITE";
    } else if (v.color == GRAY) {
        color_str = "GRAY";
    } else if (v.color == BLACK) {
        color_str = "BLACK";
    }
    os << color_str << ",";
    
    if (v.d == -1) {
        os << "INF";
    } else {
        os << v.d;
    }
    os << ",";
    
    if (v.pre_index == -1) {
        os << "NIL";
    } else {
        os << static_cast<char>(v.pre_index);
    }
    os << ")";
    return os;
}

edge.h

#ifndef _EDGE_H_
#define _EDGE_H_

#include <utility>
#include <ostream>
#include "vertex.h"

using Edge = std::pair<Vertex, Vertex>;
std::ostream & operator<<(std::ostream & os, const Edge &e);

#endif

edge.cpp

#include "edge.h"

using namespace std;

ostream & operator<<(ostream & os, const Edge &e) {
    os << e.first << "-" << e.second << endl;
    return os;
}

graph.h

#ifndef _GRAPH_H_
#define _GRAPH_H_
#include <vector>
#include <ostream>
#include "edge.h"

using Graph = std::vector<Edge>;

std::ostream & operator<<(std::ostream & os, const Graph &g);

#endif

graph.cpp

#include "graph.h"
#include <iostream>

using namespace std;

ostream & operator<<(ostream & os, const Graph &g) {
    for (const auto& e: g) {
        os <<e;
    }
    return os;
}

 

adj_list.h

#ifndef _ADJ_LIST_H_
#define _ADJ_LIST_H_

#include <vector>
#include <map>
#include <ostream>
#include "vertex.h"
#include "graph.h"

using Relation = std::vector<int>;

struct AdjList {
    std::vector<Vertex> vertexs;
    std::map<int, Relation> relations;

    AdjList(const Graph& g);
    Vertex *get_vertex(int index);
    Relation *get_relation(int index);
};

std::ostream & operator<<(std::ostream & os, const AdjList &adj_list);

#endif

adj_list.cpp

#include <algorithm>
#include "adj_list.h"
#include "graph.h"

using namespace std;

ostream & operator<<(ostream & os, const Relation &relation) {
    for (const auto& i: relation) {
        os << static_cast<char>(i) << "->";
    }
    return os;
}

ostream & operator<<(ostream & os, const AdjList &adj_list) {
    for (const auto& vertex: adj_list.vertexs) {
        os << vertex << "->";
    }
    os << endl;
    for (auto it = adj_list.relations.begin(); it != adj_list.relations.end(); it++) {
        os << static_cast<char>(it->first) << "->" << it->second << endl;
    }
    return os;
}

static void add_to_vertexs(vector<Vertex> &vertexs, const Vertex& v) {
    if (find(begin(vertexs), end(vertexs), v) == vertexs.end()) {
        vertexs.push_back(v);
    }
}

static void add_to_relation(Relation &relation, int index) {
    if (find(begin(relation), end(relation), index) == relation.end()) {
        relation.push_back(index);
    }
}

static void add_to_relations(std::map<int, Relation> &relations, int index0, int index1) {
    auto search = relations.find(index0);
    if (search != relations.end()) {
        add_to_relation(search->second, index1);
    } else {
        relations[index0] = Relation{index1};
    }
}

AdjList::AdjList(const Graph& g) {
    for (auto& e: g) {
        add_to_vertexs(vertexs, e.first);
        add_to_vertexs(vertexs, e.second);
        add_to_relations(relations, e.first.index, e.second.index);
        add_to_relations(relations, e.second.index, e.first.index);
    }
}

Vertex *AdjList::get_vertex(int index) {
    for (auto &i: vertexs) {
        if (i.index == index) {
            return &i;
        }
    }
    return nullptr;
}

Relation *AdjList::get_relation(int index) {
    auto search = relations.find(index);
    if (search != relations.end()) {
        return &search->second;
    }
    return nullptr;
}

bfs.cpp

#include <iostream>
#include <deque>
#include "adj_list.h"

using namespace std;

void BFS(AdjList &adj_list, int s) {
    Vertex *p_s = adj_list.get_vertex(s);
    p_s->set(GRAY, 0, -1);

    deque<int> q;
    q.push_back(s);
    
    while (q.size() != 0) {
        int u = q[0];
        q.pop_front();
        
        Vertex *p_u = adj_list.get_vertex(u);
        Relation *p_u_relation = adj_list.get_relation(u);

        for (auto v: *p_u_relation) {
            Vertex *p_v = adj_list.get_vertex(v);
            if (p_v->color == WHITE) {
                p_v->set(GRAY, p_u->d + 1, p_u->index);
                q.push_back(v);
            }
        }
        p_u->color = BLACK;
    }
}

int main() {
    Graph g {
        Edge{{'r'}, {'s'}},
        Edge{{'r'}, {'v'}},
        Edge{{'s'}, {'w'}},
        Edge{{'w'}, {'t'}},
        Edge{{'w'}, {'x'}},
        Edge{{'t'}, {'x'}},
        Edge{{'t'}, {'u'}},
        Edge{{'x'}, {'u'}},
        Edge{{'x'}, {'y'}},
        Edge{{'u'}, {'y'}},};
    cout << "Graph:" << endl;
    cout << g;

    AdjList adj_list{g};
    cout << "AdjList:" << endl;
    cout << adj_list;

    BFS(adj_list, 's');
    cout << "After BFS:" << endl;
    cout << adj_list;
}