【数据结构】：图

图

• 1、定义是一种非线性结构，由顶点的集合和顶点间的关系的集合组成的一种数据结构。
  Graph = (V,E);
  V = {x|x是顶点的集合}；
  E = {<x,y> |(x,y属于V)}；
• 2、图的分类有向图：顶点之间单向指引就是有向图无向图：顶点之间可以互相指引就是无向图
  
• 3、一些基本概念
  1）完全图：在由n个顶点组成的无向图中，若有n(n-1)/2条边，则就是完全无向图
  2）权重：在一些图中，边具有与之相关的数值，称为权重。
  3）邻接顶点：如果（u,v）是图中的一条边，那么u,v互为邻接点。
  4）度：与顶点相关联的边的数目
  5）路径：一个顶点到另一个顶点所经过的痕迹
  6）连通图：在无向图中，任意两个顶点之间都是连通的。
  7）强连通图：在有向图中，若每一对顶点之间都存在路径，就称此图为强连通图。
  8）生成树：若一个图有n个顶点，则有n-1条边的就是生成树
  一个无向连通图的生成树是它的极小连通子图。
  -4、图的存储方法
  1）邻接矩阵
  A：如何存储：
  
  B：代码如何实现：

template<class V,class W>
class GraphMatrix
{
public:
    //构造函数
    GraphMatrix(V* v,size_t n,bool isDirected = false,const W& invalue = W())
        :_v(v,v+n)
        ,_isDirected(isDirected)
    {
        _matrix = new W*[_v.size()];
        for(size_t i = 0; i<n; i++)
        {
            _matrix[i] = new W[_v.size()];
            for(size_t j = 0; j<n; j++)
            {
                _matrix[i][j] = invalue;
            }
        }
    }

    //给定一个顶点，如何得到这个顶点的下标
    size_t GetIndex(const V& v)
    {
        for(size_t i = 0; i<_v.size(); i++)
        {
            if(_v[i] == v)
            {
                return i;
            }
        }
        assert(false);
        return 0;
    }
    //如何加一条边
    void AddEge(const V& v1, const V& v2, const W& w)
    {
        size_t src = GetIndex(v1);
        size_t dest = GetIndex(v2);

        _matrix[src][dest] = w;
        if(_isDirected = false) //说明是无向图
        {
            _matrix[dest][src] = w;
        }
    }

    //析构函数
    ~GraphMatrix()
    {
        //先释放数据
        for(size_t i = 0; i<_v.size(); i++)
        {
            delete[] _matrix[i];
        }
        //后释放指针数组
        delete[] _matrix;
    }
private:
    vector<V> _v;     //顶点的集合
    W** _matrix;       //边上权重的集合
    bool _isDirected;  //是否是与有向图
};

2）邻接表
A：如何存储：

节点的设置：

template<class W>
struct GraphLinkNode
{
    W _weight;       //权重
    GraphLinkNode<W*> _next;  //下一个节点
    size_t _src;      
    size_t _dest;
    GraphLinkNode(size_t src,size_t dest,const W& weight = W())
        :_weight(weight)
        ,_next(NULL)
        ,_src(src)
        ,_dest(dest)
    {}
};

B：代码如何实现

template<class V, class W>
class GraphLink
{
    typedef LinKEdge<W> Edge;
public:

    GraphLink(V* vertexs, size_t n, const W& invalid = W(), bool isDirected = false)
        :_isDirected(isDirected)
    {
        _vertexs.resize(n);
        _vertexs.assign(vertexs, vertexs+n);

        _linkTables.resize(n, NULL);
    }
    size_t GetVertexIndex(const V& v)
    {
        for (size_t i = 0; i < _vertexs.size(); ++i)
        {
            if (_vertexs[i] == v)
            {
                return i;
            }
        }

        assert(false);
        return 0;
    }

    void _AddEdge(size_t src, size_t dst, const W& w)
    {
        // 头插
        LinKEdge<W>* edge = new Edge(src, dst, w);
        edge->_next = _linkTables[src];
        _linkTables[src] = edge;
    }

    void AddEdge(const V& v1, const V& v2, const W& w)
    {
        size_t src = GetVertexIndex(v1);
        size_t dst = GetVertexIndex(v2);

        _AddEdge(src, dst, w);
        if (_isDirected == false)
        {
            _AddEdge(dst, src, w);
        }
    }

protected:
    vector<V> _vertexs;  // 顶点集合
    vector<Edge*> _linkTables; // 邻接表
    bool _isDirected;
};

邻接矩阵和邻接表的比较及各自的用途：
说明：
A：就定义来说：
邻接矩阵更适合直接定位
邻接表适合搜寻相邻节点
B：存储
邻接矩阵：在无向图的存储中，邻接矩阵的存储方式是一种对称矩阵，这样的存储方式可以节省很大的内存空间
邻接表：在无向图的存储中，是要将重复的元素再次进行存储的，因此会有空间上的开销
C：找寻元素的相邻边
邻接矩阵：要按行，列，依次进行查找，时间复杂度很高
邻接表：直接就遍历依次指向此节点的链表即可
- 5、图的遍历
1）分类：
深度优先遍历
广度优先遍历

2）代码如何实现
A：深度优先遍历

void DFS(const V& src)
    {
        size_t index = GetVertexIndex(src);
        vector<bool> visited(_vertexs.size(),false);
        visited[index] = true;
        cout<<_vertexs[index]<<"->";
        _DFS(index,visited);

    }
    void _DFS(size_t src,vector<bool>& visited)
    {
        Edge* cur = _linkTables[src];
        while(cur)
        {
            size_t dst = cur->_dst;
            if(visited[dst] == false)
            {
                cout<<_vertexs[dst]<<"->"<<" ";
                visited[dst] = true;
                _DFS(dst,visited);
            }
            cur = cur->_next;
        }
    }

B：广度优先遍历

void BFS(const V& src)
    {
        size_t index = GetVertexIndex(src);
        vector<bool> visited(_vertexs.size(),false);
        queue<int> q;
        q.push(index);
        while(!q.empty())
        {
            size_t front = q.front();
            if(visited[front] == false)
            {
                cout<<_vertexs[front]<<"->";
                visited[front] = true;
                Edge* cur = _linkTables[front];
                while(cur)
                {
                    size_t dst = cur->_dst;
                    if(visited[dst] == false)
                    {
                        q.push(dst);
                        visited[dst] = true;
                        cout<<_vertexs[dst]<<"->";
                    }
                    cur = cur->_next;
                }
            }
            q.pop();
        }
    }