图的实现（带有深度/广度优先遍历/最小生成树算法）

连通图

  在图中，任意俩个节点都有一条路径，我们把这种图称为连通图。

生成树

  连通图可能有多个边其中可能有环，但是生成树是由N个节点，N-1条边构成的连通图。它是一个特殊的连通图，其中没有环路。

最小生成树

  因为N个节点,N-1条边构成生成树。那么就存在多个生成树，那么这么生成树中权值最小的生成树叫做最小生成树。
  kruskal是构成最小生成树的一种算法，这个算法就是在图中不断地选出权值最小的边，一直选出N-1条即可。如果选的过程中遇见有构成环路的边，就选下一条权值次小的边即可。

广度优先/深度优先

  这是俩种不同遍历图的方式，深度优先强调一直遍历，直到遍历到无法遍历的位置，再回退到上一节点，遍历与上一节点相邻的另一个节点。一般用递归实现。
  广度优先，强调先把当前节点相邻的节点都访问了，然后在遍历相邻节点的相邻节点，一般用队列实现。因为队列是头删尾进，先进先出的原则，所以更好符合条件。

代码实现

#pragma once
#include<string>
#include<iostream>
#include<vector>
#include<unordered_map>
#include<queue>
#include"Union.h"
using namespace std;
struct Edge
{
    Edge( size_t src, size_t dst,int weight)
    :_weight(weight), _src(src), _dst(dst)
    {}
    int _weight;
    size_t _src;
    size_t _dst;
    Edge * next;
};
template<class V, bool digraph>
class graph
{
public:
    graph()
    {}
    graph(vector<V>&vertrix)
    {
        _vertrix.reserve(vertrix.size());
        int index = 0;
        for (auto&i : vertrix)
        {
            _vertrix.push_back(i);
            _hash[i] = index++;
        }
        linktable.resize(_vertrix.size());
    }
    graph(const graph<V, digraph>&object)
        :_vertrix(object._vertrix), linktable(object.linktable), _hash(object._hash)
    {}
    graph<V, digraph>&operator=(const graph<V, digraph>object)
    {
        _vertrix.swap(object._vertrix);
        _hash.swap(object._hash);
        // this->linktable.swap(object.linktable);
    }
    void Addedge(const V&v1, const V&v2, int weight)
    {
        int src = _hash[v1];
        int dst = _hash[v2];
        _Addedge(src, dst, weight);
        if (digraph == false)
            _Addedge(dst, src, weight);
    }
    void BFS()
    {
        queue<int> qcon;
        qcon.push(0);
        vector<bool> visited(_vertrix.size(), false);
        Edge * pCur = NULL;
        int src = 0;
        while (!qcon.empty())
        {
            src = qcon.front();
            qcon.pop();
            cout << _vertrix[src] << "->";
            visited[src] = true;
            pCur = linktable[src];
            while (pCur)
            {
                if (visited[pCur->_dst] == false)
                {
                    qcon.push(pCur->_dst);
                    visited[pCur->_dst] = true;//防止有的节点被多次push
                }
                pCur = pCur->next;
            }
        }
    }
    void DFS()
    {
        vector<bool> visited(_vertrix.size(), false);
        _DFS(0, visited);
    }
    bool kruskal(graph<V, digraph>&mintree)
    {
        mintree._vertrix = _vertrix;
        mintree._hash = mintree._hash;
        mintree.linktable.resize(linktable.size());
        Uoion uoiobject(_vertrix.size());
        struct compareGreater
        {
            bool operator()(Edge*parent, Edge*child)
            {
                return parent->_weight > child->_weight;
            }
        };
        priority_queue<Edge*, vector<Edge*>, compareGreater> MinHeap;
        Edge * pCur = NULL;
        for (auto&i : linktable)
        {
            pCur = i;
            while (pCur)
            {
                if (pCur->_src < pCur->_dst)
                    MinHeap.push(pCur);
                pCur = pCur->next;
            }
        }
        int N = _vertrix.size() - 1;
        if (MinHeap.size()<N)
        {
            cerr << "不是连通图,请先构造出来连通图" << endl;
            return false;
        }
        int src = 0;
        int dst = 0;
        while (N)
        {
            if (MinHeap.size() != 0)
                pCur = MinHeap.top();
            else
            {
                cerr << "给的图无法构成最小生成树，可能环路过多，边数过少" << endl;
                return false;
            }
            MinHeap.pop();
            src = pCur->_src;
            dst = pCur->_dst;
            if (uoiobject.GetRoot(src) != uoiobject.GetRoot(dst))
            {
                mintree._Addedge(src, dst, pCur->_weight);
                uoiobject.uni(src, dst);
                --N;
            }
        }
        return true;
    }
    ~graph()
    {
        Edge * pCur = NULL;
        Edge * pNext = NULL;
        for (auto&i : linktable)
        {
            pCur = i;
            while (pCur)
            {
                pNext = pCur->next;
                delete pCur;
                pCur = pNext;
            }
        }
    }
protected:
    void _DFS(size_t src, vector<bool>&visited)
    {
        cout << _vertrix[src] << "->";
        visited[src] = true;
        Edge* pCur = linktable[src];
        while (pCur)
        {
            if (visited[pCur->_dst] == false)
                _DFS(pCur->_dst, visited);
            pCur = pCur->next;
        }
    }
    void _Addedge(int src, int dst, int weight)
    {
        Edge * pCur = new Edge(src, dst, weight);
        pCur->next = linktable[src];
        linktable[src] = pCur;
    }
    private:
        vector<V> _vertrix;//vector析构函数会类型萃取，如果所ADT类型一个一个调用
        vector<Edge*> linktable;//析构函数，如果是内置类型什么都不做。
        unordered_map<V, int> _hash;//所以linktable我们得自己释放 
};

#include<vector>
using namespace std;
class Uoion
{
public:
    Uoion(int n = 0)
        :_uoion(n + 1, -1)
    {}
    int GetRoot(int x)
    {
        while (_uoion[x] >= 0)
        {
            x = _uoion[x];
        }
        return x;
    }
    int uni(int x, int y)
    {
        int Root = x;
        int Root2 = y;
        while (_uoion[Root] >= 0 || _uoion[Root2] >= 0)
        {
            if (_uoion[Root] >= 0)
                Root = _uoion[Root];
            if (_uoion[Root2] >= 0)
                Root2 = _uoion[Root2];
        }
        if (Root != Root2)
        {
            _uoion[Root] += _uoion[Root2];
            _uoion[Root2] = Root;
        }
        return Root;
    }
    int  Size()
    {
        int ret = 0;
        size_t size = _uoion.size();
        for (size_t i = 0; i<size; ++i)
        {
            if (_uoion[i]<0)
                ++ret;
        }
        return ret;
    }
private:
    vector<int> _uoion;
};
#include"graph.h"

int main()
{
    vector<string> str = { "西安", "上海", "广州", "深圳", "北京" };
    graph<std::string, false> graphobject(str);
    graphobject.Addedge("西安", "上海", 100);
    graphobject.Addedge("西安", "北京", 200);
    graphobject.Addedge("北京", "上海", 300);
    graphobject.Addedge("上海", "深圳", 400);
    graphobject.Addedge("深圳", "广州", 500);
    graphobject.Addedge("北京", "广州", 600);
    graphobject.DFS();
    cout << endl;
    graphobject.BFS();
    graph<std::string, false> mintree;
    graphobject.kruskal(mintree);
    mintree.DFS();
    return 0;
}