图的数据结构-CSDN博客

1.简介

图包括很多种类型，该文章仅介绍无向图与有向图

首先，我们必须有一个Bag数组来装下图

2.Bag的实现

由于仅展示

#include<vector>
class Bag
{
private:
    class Node
    {
    public:
        int val;
        Node* next;
        Node(int v, Node* x) :
            val(v), next(x) {}
    };
    Node* head;
public:
    Bag():head(nullptr){}
    ~Bag()
    {
        while (head)
        {
            Node*temp = head;
            head = head->next;
            delete temp;
        }
    }
    void put(int val)
    {
        Node*temp = new Node(val, head);
        head = temp;
    }
    std::vector<int> Travel()
    {
        Node*temp = head;
        std::vector<int>result;
        while (temp)
        {
            result.push_back(temp->val);
            temp = temp->next;
        }
        return result;
    }
};

最简单的链表形式，不提供删除等操作

3.无向图

3.1 Graph类

无向图，顾名思义，没有方向，一条路径是双向的

class Graph
{
protected:  //成员设为保护成员方便继承使用
    int V;//顶点个数
    int E;//边的数目  
    Bag *adj;
public:
    Graph(int v);
    virtual ~Graph();
    int GetV() { return V; }
    int GetE() { return E; }
    virtual void AddEdge(int w, int v);
    std::vector<int> GetBagValve(int w);
};

3.2 其他方法的实现

Graph::Graph(int v)
{
    V = v;
    adj = new Bag[V]();
}
void Graph::AddEdge(int w, int v)
{
    adj[w].put(v);
    adj[v].put(w);
    ++E;
}
Graph::~Graph()
{
    delete[] adj;
}
std::vector<int> Graph::GetBagValve(int w)
{
    return adj[w].Travel();

因为比较简单，此处不进行解释

4.有向图

4.1 DirectGraph类的实现

class DirectGraph :public Graph
{
public:
    DirectGraph(int v) :
        Graph(v) {}
    void AddEdge(int w, int v) override;
    DirectGraph reverse();
};

DirGraph类直接继承于Graph类，有效防止了重复代码的书写

4.2 方法的实现

void DirectGraph::AddEdge(int w, int v)
{
    adj[w].put(v);
    ++E;
}
DirectGraph DirectGraph::reverse()  //提供了反转方法，这在后续的拓扑排序中有用
{
    DirectGraph R(V);
    for (int v = 0; v < V; v++)
    {
        std::vector<int>temp = GetBagValve(v);
        for (int i = 0; i < temp.size(); ++i)
            R.AddEdge(temp[i], v);
    }
    return R;
}

5. BFS与DFS类的base类实现

5.1类的实现

class base
{
protected:
    bool*marked;  // 标记数组
    int*EdgeTo; //从哪条边访问的？
    int s; //起点
public:
    base() = default;
    base(int s, Graph &G);
    virtual ~base() //析构函数
    {
        delete[] marked;
        delete[] EdgeTo;
    }
    bool HasPathTo(int v);  是否有起点s到v的路径？
    std::stack<int>PathTo(int v);  取路径
};

5.2 类方法的实现

bool base::HasPathTo(int v)
{
    return marked[v];
}
std::stack<int> base::PathTo(int v)
{
    if (HasPathTo(v))
        return std::stack<int>();
    std::stack<int>temp;
    while (v != s)
    {
        temp.push(v);
        v = EdgeTo[v];
    }
    temp.push(s);
    return temp;
}
base::base(int s, Graph & G)   //构造函数
{
    marked = new bool[G.GetV()]{ 0 };
    EdgeTo = new int[G.GetV()];
    this->s = s;
}
void BFS::bfs(Graph&G,int s)
{
    std::queue<int>q;
    q.push(s);
    cout << s << endl;
    marked[s] = true;
    while (!q.empty())
    {
        s = q.front();
        q.pop();
        std::vector<int>temp = G.GetBagValve(s);
        for (auto it = temp.begin(); it != temp.end(); ++it)
            if (!marked[*it])
            {
                cout << *it << endl;
                EdgeTo[*it] = s;
                marked[*it] = true;
                q.push(*it);
            }
    }
}

6.深度优先搜索DFS类的实现

6.1 class的实现

class DFS:public base
{
public:
    DFS(int s, Graph &G)   //构造函数，开始搜索
        :base(s, G) {dfs(G, s);}  
    void dfs(Graph&G, int w);
};

6.2 类方法的实现

void DFS::dfs(Graph & G, int w)
{
    cout << w << endl;
    marked[w] = true;
    std::vector<int> temp = G.GetBagValve(w);
    for (int i = 0; i < temp.size(); ++i)
        if (!marked[temp[i]])
        {
            EdgeTo[temp[i]] = w;
            dfs(G, temp[i]);
        }
}

7 广度优先搜索bfs类的实现

7.1 类的实现

class BFS:public base
{
public:
    BFS(int x,Graph&G):
        base(x, G) {bfs(G, x);}
    void bfs(Graph&G,int x);
};

与BFS类大同小异

7.2 bfs方法的实现

void BFS::bfs(Graph&G,int s)
{
    std::queue<int>q;
    q.push(s);
    cout << s << endl;
    marked[s] = true;
    while (!q.empty())
    {
        s = q.front();
        q.pop();
        std::vector<int>temp = G.GetBagValve(s);
        for (auto it = temp.begin(); it != temp.end(); ++it)
            if (!marked[*it])
            {
                cout << *it << endl;
                EdgeTo[*it] = s;
                marked[*it] = true;
                q.push(*it);
            }
    }
}

有没有很熟悉，没错，二叉树的层序遍历便是dfs

转载于:https://www.cnblogs.com/vhyz/p/7583695.html