邻接表在c++中的实现

我正在寻找c++中图形的简洁精确的邻接表表示。我的节点就是节点id。我是这样做的。只是想知道专家们是怎么想的。有没有更好的办法?

这是类的实现(没什么特别的，现在不关心公共/私有方法)

#include <iostream>
#include <vector>
#include <fstream>
#include <sstream>
using namespace std;
class adjList {
public:
    int head;
    vector<int> listOfNodes;
    void print();
};
void adjList :: print() {
    for (int i=0; i<listOfNodes.size(); ++i) {
        cout << head << "-->" << listOfNodes.at(i) << endl;
    }
}
class graph {
public:
    vector<adjList> list;
    void print();
};
void graph :: print() {
    for (int i=0; i<list.size(); ++i) {
        list.at(i).print();
        cout << endl;
    }
}

main函数逐行解析输入文件。其中每行解释如下:

<source_node> <node1_connected_to_source_node> <node2_connected_to_source_node <node3_connected_to_source_node> <...>

正文:

int main()
    {
        fstream file("graph.txt", ios::in);
        string line;
        graph g;
        while (getline(file, line)) {
            int source;
            stringstream str(line);
            str >> source;
            int node2;
            adjList l;
            l.head = source;
            while (str >> node2) {
                l.listOfNodes.push_back(node2);
            }
            g.list.push_back(l);
        }
        file.close();
        g.print();
        getchar();
        return 0;
    }

我知道我应该在adjList类中添加adddge()函数，而不是直接从main()中修改它的变量，但是，现在我只是想知道最好的结构。

我的方法有一个缺点。对于具有大量节点的复杂图，node将确实是一个结构/类，在这种情况下，我将通过存储整个对象来复制值。在这种情况下，我想我应该使用指针。例如，对于无向图，我将在adjList中存储节点对象的副本(节点1和2之间的连接意味着1的邻接表将有2，反之亦然)。我可以通过在adjList中存储节点对象的指针而不是整个对象来避免这个问题。检查从这种方法中获益的dfs实现。我需要确保每个节点只被访问一次。拥有同一节点的多个副本将使我的生活变得更加困难。没有?

在这种情况下，我的类定义将改变如下:

#include <iostream>
#include <vector>
#include <fstream>
#include <sstream>
#include <map>
using namespace std;
class node {
public:
    node() {}
    node(int id, bool _dirty): node_id(id), dirty(_dirty) {}
    int node_id;
    bool dirty;
};
class adjList {
public:
    node *head;
    vector<node*> listOfNodes;
    void print();
    ~adjList() { delete head;}
};
void adjList :: print() {
    for (int i=0; i<listOfNodes.size(); ++i) {
        cout << head->node_id << "-->" << listOfNodes.at(i)->node_id << endl;
    }
}
class graph {
public:
    vector<adjList> list;
    void print();
    void dfs(node *startNode);
};
void graph::dfs(node *startNode) {
    startNode->dirty = true;
    for(int i=0; i<list.size(); ++i) {
        node *stNode = list.at(i).head;
        if (stNode->node_id != startNode->node_id) { continue;}
        for (int j=0; j<list.at(i).listOfNodes.size(); ++j) {
            if (!list.at(i).listOfNodes.at(j)->dirty) {
                dfs(list.at(i).listOfNodes.at(j));
            }
        }
    }
    cout << "Node: "<<startNode->node_id << endl;
}
void graph :: print() {
    for (int i=0; i<list.size(); ++i) {
        list.at(i).print();
        cout << endl;
    }
}

这就是我如何实现main()函数。我使用地图来避免重复的对象。只在之前没有定义的情况下创建一个新对象。根据对象的id检查对象是否存在。

int main()
{
    fstream file("graph.txt", ios::in);
    string line;
    graph g;
    node *startNode;
    map<int, node*> nodeMap;
    while (getline(file, line)) {
        int source;
        stringstream str(line);
        str >> source;
        int node2;
        node *sourceNode;
        // Create new node only if a node does not already exist
        if (nodeMap.find(source) == nodeMap.end()) {
                sourceNode = new node(source, false);
                nodeMap[source] = sourceNode;
        } else {
                sourceNode = nodeMap[source];
        }
        adjList l;
        l.head = sourceNode;
        nodeMap[source] = sourceNode;
        while (str >> node2) {
            // Create new node only if a node does not already exist
            node *secNode;
            if (nodeMap.find(node2) == nodeMap.end()) {
                secNode = new node(node2, false);
                nodeMap[node2] = secNode;
            } else {
                secNode = nodeMap[node2];
            }
            l.listOfNodes.push_back(secNode);
        }
        g.list.push_back(l);
        startNode = sourceNode;
    }
    file.close();
    g.print();
    g.dfs(startNode);
    getchar();
    return 0;
}

第二个编辑在Ulrich Eckhardt建议将邻接表放在节点类之后，我认为这是一个更好的数据结构来存储图并执行dfs()， dijkstra()之类的操作。请注意邻接表是在节点类中合并的。

#include <iostream>
#include <vector>
#include <fstream>
#include <sstream>
#include <map>
using namespace std;
class node {
public:
    node() {
    }
    node(int id, bool _dirty): node_id(id), dirty(_dirty) {
        //cout << "In overloaded constn";
    }
    int node_id;
    bool dirty;
    vector<node*> listOfNodes;
};
class graph {
public:
    vector<node*> myGraph;
    void dfs(node* startNode);
};
void graph::dfs(node* startNode) {
    startNode->dirty = true;
    for (int j=0; j<startNode->listOfNodes.size(); ++j) {
            if (!startNode->listOfNodes.at(j)->dirty) {
                dfs(startNode->listOfNodes.at(j));
            }
        }
    cout << "Node: "<<startNode->node_id << endl;
}

我们能做得更好吗?