【数据结构-C++语言】图篇

【数据结构-c++语言】图篇。以下顶点也成节点。

图的基本概念

如果给图的每条边规定一个方向，那么得到的图称为有向图。在有向图中，与一个节点相关联的边有出边和入边之分。相反，边没有方向的图称为无向图。

一个图有顶点和弧（边）组成，其中一个弧有弧头和弧尾（如上图所示）。有的弧还带有权值。顶点的度是指和该顶点相连的边的条数。特别是对于有向图来说，顶点的出边条数称为该顶点的出度，顶点的入边条数称为该项点的入度。

顶点 v1 和顶点 v3 之间存在一条边，我们称顶点 v1 和 v3 互为邻接点。

在一个无向图g 中，两个顶点之间有路径相连，则称他们是连通的。如果 g 是有向图，那么连接两个顶点的路径中所有的边都必须同向。如果图中任意两点都是连通的，那么图被称作连通图。如果此图是有向图，则称为强连通图（注意：需要双向都有路径）。

完全图是一个简单的无向图，其中每对不同的顶点之间都恰连有一条边相连。

子图是图论的基本概念之一，指节点集和边集分别是某一图的节点集的子集和边集的子集的图。如果连通图的一个子图是一棵包含的所有顶点的树，则该子图称为g的生成树。

---

图的存储方式

邻接矩阵—数组存储

邻接矩阵**是表示顶点之间相邻关系的矩阵。顶点的表示一般由顶点索引和顶点数据组成。下面分别是有向图和无向图邻接矩阵。

对于邻接矩阵，我们可以用int型的二维数组进行如下表示。

对于邻接矩阵的顶点和图，我们可以使用如下的方式进行表示。

---

邻接表—链式存储

邻接表是图的一种最主要存储结构，用来描述图上的每一个点。对图的每个顶点建立一个容器（n个顶点建立n个容器），第 i 个容器中的结点包含顶点 vi 的所有邻接顶点。

邻接表的顶点由顶点索引、顶点数据、出弧链表表头指针组成。弧由弧头顶点索引、弧数据和下一条弧指针。其中出弧链表表头指针指向弧链表。

---

十字链表—链式存储

---

邻接多重表—链式存储（无向图）

---

图的遍历

深度优先搜索：

假设给定图g的初态是所有顶点均未曾访问过。在g中任选一顶点v为初始出发点(源点)，则深度优先遍历可定义如下：首先访问出发点v，并将其标记为已访问过；然后依次从v出发搜索v的每个邻接点w。若w未曾访问过，则以w为新的出发点继续进行深度优先遍历，直至图中所有和源点v有路径相通的顶点(亦称为从源点可达的顶点)均已被访问为止。若此时图中仍有未访问的顶点，则另选一个尚未访问的顶点作为新的源点重复上述过程，直至图中所有顶点均已被访问为止。

广度优先搜索：

1、从图中某个顶点v0出发，并访问此顶点； 2、从v0出发，访问v0的各个未曾访问的邻接点w1，w2，…,wk;然后,依次从w1,w2,…,wk出发访问各自未被访问的邻接点； 3、重复步骤2，直到全部顶点都被访问为止。

最小生成树

普利姆算法

克鲁斯卡尔算法

图的编码

深度优先遍历和广度优先遍历

首先来定义节点类，新建node.h，node.cpp。

#node.h
class node
{
public:
    node(char data = 0);
    char m_cdata;
    bool m_bisvisited;  //当前节点是否被访问的标志。true表示访问过
};

#node.cpp
#include "stdafx.h"
#include "node.h"

node::node(char data)
{
    m_cdata = data;
    m_bisvisited = false;
}

节点类有两个成员变量，一个是节点数据m_cdata（默认值为0），一个是访问标志m_bisvisited（true表示访问过，初始化为false）。

接着设计图类cmap，新建cmap.h和cmap.cpp。

#cmap.h
#include "node.h"
#include "vector"
using namespace std;

class cmap
{
public:
    cmap(int capacity);
    ~cmap();
    bool addnode(node *pnode);      //向途中加入节点
    void resetnode();               //重置节点
    bool setvaluetomatrixfordirectedgraph(int row, int col, int val=1);      //为有向图设置邻接矩阵
    bool setvaluetomatrixforundirectedgraph(int row, int col, int val = 1);  //为无向图设置邻接矩阵
    void printmatrix();     //打印邻接矩阵
    void depthfitsttraverse(int nodeindex);     //深度优先遍历
    void breadthfitsttraverse(int nodeindex);   //广度优先遍历

private:
    bool getvaluefrommatrix(int row, int col, int &val);   //从矩阵中获取权值
    void breadthfitsttraverseimpl(vector prevec);     //从广度优先遍历实现函数

private:
    int m_icapacity;            //途中最多可以容纳的定点数
    int m_inodecount;           //已经添加节点个数
    node *m_pnodearray;         //用来存放节点数组
    int *m_pmatrix;             //用来存放邻接矩阵
};

#cmap.cpp
#include "stdafx.h"
#include "vector"
#include "iostream"
#include "cmap.h"
using namespace std;


cmap::cmap(int capacity)
{
    m_icapacity = capacity;
    m_inodecount = 0;
    m_pnodearray = new node[m_icapacity];
    m_pmatrix = new int[m_icapacity * m_icapacity];
    //memset(m_pmatrix, 0, m_icapacity * m_icapacity * sizeof(int));
    //void *memset(void *s, int ch, size_t n);
    //函数解释：将s中当前位置后面的n个字节 （typedef unsigned int size_t ）用 ch 替换并返回 s 。
    for (int i = 0; i < m_icapacity * m_icapacity; i++)
    {
        m_pmatrix[i] = 0;
    }
}

cmap::~cmap()
{
    delete[]m_pnodearray;
    delete[]m_pmatrix;
}

bool cmap::addnode(node *pnode)
{
    if (pnode == null)
    {
        return false;
    }
    m_pnodearray[m_inodecount].m_cdata = pnode->m_cdata;
    m_inodecount++;
    return true;
}

void cmap::resetnode()
{
    for (int i = 0; i < m_inodecount; i++)
    {
        m_pnodearray[i].m_bisvisited = false;
    }
}

bool cmap::setvaluetomatrixfordirectedgraph(int row, int col, int val)
{
    if (row < 0 || row >= m_icapacity)
    {
        return false;
    }
    if (col < 0 || col >= m_icapacity)
    {
        return false;
    }
    m_pmatrix[row * m_icapacity + col] = val;
    return true;
}

bool cmap::setvaluetomatrixforundirectedgraph(int row, int col, int val)
{
    if (row < 0 || row >= m_icapacity)
    {
        return false;
    }
    if (col < 0 || col >= m_icapacity)
    {
        return false;
    }
    m_pmatrix[row * m_icapacity + col] = val;
    m_pmatrix[col * m_icapacity + row] = val;
    return true;
}

void cmap::printmatrix()
{
    for (int i = 0; i < m_icapacity; i++)
    {
        for (int k = 0; k < m_icapacity; k++)
        {
            cout << m_pmatrix[i * m_icapacity + k] << " ";
        }
        cout << endl;
    }
}

bool cmap::getvaluefrommatrix(int row, int col, int &val)
{
    if (row < 0 || row >= m_icapacity)
    {
        return false;
    }
    if (col < 0 || col >= m_icapacity)
    {
        return false;
    }
    val = m_pmatrix[row * m_icapacity + col];
    return true;
}

//深度优先遍历
void cmap::depthfitsttraverse(int nodeindex)
{
    int value = 0;

    cout << m_pnodearray[nodeindex].m_cdata << " ";
    m_pnodearray[nodeindex].m_bisvisited = true;

    //通过邻接矩阵判断是否与其他顶点有连接
    for (int i = 0; i < m_icapacity; i++)
    {
        getvaluefrommatrix(nodeindex, i, value);
        if (value != 0) //判断有弧连接其他顶点
        {
            //再判断该点是否被访问过
            if (m_pnodearray[i].m_bisvisited)
            {
                continue;
            }
            else 
            {
                depthfitsttraverse(i);
            }
        }
        else
        {
            //如果没有去向索引为 i 的顶点的弧，则循环继续
            continue;
        }
    }
}

//广度优先遍历
void cmap::breadthfitsttraverse(int nodeindex)
{
    cout << m_pnodearray[nodeindex].m_cdata << " ";
    m_pnodearray[nodeindex].m_bisvisited = true;

    vector curvec;           //当前数组
    curvec.push_back(nodeindex);  //压入数组

    breadthfitsttraverseimpl(curvec);
}
//广度优先遍历 进一步
void cmap::breadthfitsttraverseimpl(vector prevec)
{
    int value = 0;
    vector curvec;     //保存当前这一层所有节点

    for (int j = 0; j < (int)prevec.size(); j++)    //prevec.size():上一层节点数
    {
        for (int i = 0; i < m_icapacity; i++)       //判断上一层节点与其他点是否有连接
        {
            getvaluefrommatrix(prevec[j], i, value);
            if (value != 0)
            {
                if (m_pnodearray[i].m_bisvisited)
                {
                    continue;
                }
                else    //如果有连接，置为已访问、输出并保存到当前这一层的curvec
                {
                    cout << m_pnodearray[i].m_cdata << " ";
                    m_pnodearray[i].m_bisvisited = true;

                    curvec.push_back(i);
                }
            }
        }
    }

    if (curvec.empty())     //判断本层是否存在被访问过的点
    {
        return;
    }
    else    //本层访问过的点的个数不为0，下一层可能还有节点与本层的节点相连接
    {
        breadthfitsttraverseimpl(curvec);
    }
}

图类一共有四个成员变量，int型的m_icapacity表示图中最多可以容纳的顶点数，int型的m_pmatrix表示已经添加顶点个数，顶点类指针m_pnodearray用来指向顶点数组，int型指针m_pmatrix指向邻接矩阵。

构造函数传入一个参数，图的容量（可以容纳顶点的个数）。m_inodecount置为0表示当前已经加入的顶点个数。创建的顶点类m_pnodearray用来存放顶点。创建的int一维数组m_pmatrix用来表示邻接矩阵（大小为m_icapacity * m_icapacity）。除此之外，我们还要将邻接矩阵内的元素置为0。

析构函数用来释放存放顶点的顶点类和邻接矩阵数组。

bool cmap::addnode(node *pnode)添加顶点函数传入的参数为要插入的顶点类指针pnode。首先判断pnode指向是否为null，然后将顶点数组的当前位置m_inodecount的顶点的数据赋值为pnode->m_cdata，最后不要忘记m_inodecount++。

接着来将重置顶点函数void cmap::resetnode()，这个函数主要用来将图内所有顶点的访问状态置为为访问过，也就是将m_pnodearray所有的元素的m_bisvisited赋值为false。

bool cmap::setvaluetomatrixfordirectedgraph(int row, int col, int val)为有向图设置邻接矩阵函数传入三个参数，分别是矩阵的行和列，以及矩阵元素的初值（默认值为1，表示两个顶点之间有连接即边）。首先判断传入的行和列是否合法，接着将邻接矩阵m_pmatrix对应位置的元素置为1。

因为这里是用一维矩阵表示的（demo里面展示出来是个二维矩阵），行数从上而下为0-7（以demo中例子为依据），列数从左至右为0-7。邻接矩阵存储是按照行从左至右、从上至下初始化的。但实质上是一维数组，故而索引（下标）为row*capacity+col。比如demo中的3行3列，实际上在数组中其存储在下标为3*8+3的位置。

bool cmap::setvaluetomatrixforundirectedgraph(int row, int col, int val)为无向图设置邻接矩阵函数也传入三个参数分别是矩阵的行和列，以及矩阵元素的初值（默认值为1）。首先也要判断传入参数的合法性。因为是无向图，其邻接矩阵对称，所以我们要进行两次邻接矩阵元素的赋值。

void cmap::printmatrix()打印邻接矩阵函数直接使用两个for循环打印矩阵的每个元素（打印完每一行之后控制换行）。

bool cmap::getvaluefrommatrix(int row, int col, int &val)取邻接矩阵中指定位置的权值函数，传入的参数有三，行、列、以及存放权值的变量 val 。首先判断传入参数的合法性，最后将指定位置的值赋值给val。

void cmap::depthfitsttraverse(int nodeindex)深度优先遍历函数传入的参数为开始遍历顶点的索引。首先创建一个初值为0的int变量value用来存放邻接矩阵的元素的值，接着打印当前位置（索引为nodeindex）的数据，并置为已访问状态。然后通过遍历邻接矩阵判断是否与其他顶点有连接，在每一次循环中，先取出当前位置为起点，其他位置为终点的元素值存放到value中，并判断value是否为0，即是否存在与当前位置的顶点相连接的其他点。如果有则继续判断该点是否被访问过，访问过则跳过本次循环；没有访问过则迭代，继续调用本函数，传入的参数为本次循环的顶点 i 。如果value为0，即没有去向索引为 i 的顶点的弧，则循环继续。

void cmap::breadthfitsttraverse(int nodeindex)广度优先遍历函数传入的参数也为开始遍历顶点的索引。首先也是打印当前位置（索引为nodeindex）的数据并置为已访问状态。然后创建一个能够存放任意类型的动态数组（这里我们定义为int容器）curvec来表示当前这一层的数组，然后将当前位置的顶点存入数组中。接着调用进一步的广度优先遍历函数breadthfitsttraverseimpl(curvec)。这个函数的解释如下。

void cmap::breadthfitsttraverseimpl(vector prevec)传入的参数为上一个函数创建的动态数组prevec（即curvec，这里表示为上一层数组）。首先创建一个初值为0的int变量value用来存放邻接矩阵的元素的值。接着定义新的int动态数组curvec来存放当前这一层所有顶点。然后遍历上一层所有顶点，在上一层每个顶点的循环中，遍历所有顶点，判断上一层节点与其他点是否有连接。将取出来的value进行判断是否为0，如果不为0，则继续判断是否被访问，访问了continue，没访问则表示上一层和当前这一层的 i 顶点有连接，将 i 顶点置为已访问、输出并保存到当前这一层的curvec。遍历完上一层的顶点数组prevec之后，判断本层数组curvec是否为空，如果为空跳出，否则表示本层访问过的点的个数不为0，下一层可能还有节点与本层的节点相连接，继续迭代本函数，传入参数为本层数组curvec。

新建测试demo.cpp

#demo.cpp
#include "stdafx.h"
#include "iostream"
#include "cmap.h"
using namespace std;

/*
        a
      /    \
    b        d 
   / \      /   \
 c   f   g - h
  \ /
   e
*/

/*
  a b c d e f g h
a 0 1 0 1 0 0 0 0
b 1 0 1 0 0 1 0 0
c 0 1 0 0 1 0 0 0
d 1 0 0 0 0 0 1 1
e 0 0 1 0 0 1 0 0
f 0 1 0 0 1 0 0 0
g 0 0 0 1 0 0 0 1
h 0 0 0 1 0 0 1 0
*/

int main()
{
    cmap *pmap = new cmap(8);

    node *pnodea = new node('a');
    node *pnodeb = new node('b');
    node *pnodec = new node('c');
    node *pnoded = new node('d');
    node *pnodee = new node('e');
    node *pnodef = new node('f');
    node *pnodeg = new node('g');
    node *pnodeh = new node('h');

    pmap->addnode(pnodea);
    pmap->addnode(pnodeb);
    pmap->addnode(pnodec);
    pmap->addnode(pnoded);
    pmap->addnode(pnodee);
    pmap->addnode(pnodef);
    pmap->addnode(pnodeg);
    pmap->addnode(pnodeh);

    pmap->setvaluetomatrixforundirectedgraph(0, 1);
    pmap->setvaluetomatrixforundirectedgraph(0, 3);
    pmap->setvaluetomatrixforundirectedgraph(1, 2);
    pmap->setvaluetomatrixforundirectedgraph(1, 5);
    pmap->setvaluetomatrixforundirectedgraph(3, 6);
    pmap->setvaluetomatrixforundirectedgraph(3, 7);
    pmap->setvaluetomatrixforundirectedgraph(6, 7);
    pmap->setvaluetomatrixforundirectedgraph(2, 4);
    pmap->setvaluetomatrixforundirectedgraph(4, 5);

    pmap->printmatrix();
    cout << endl;

    pmap->resetnode();
    pmap->depthfitsttraverse(1);
    cout << endl;

    pmap->resetnode();
    pmap->breadthfitsttraverse(1);
    cout << endl;

    system("pause");
    return 0;
}

运行结果为：

---

最小生成树

【普利姆算法】：从单一顶点开始，普里姆算法按照以下步骤逐步扩大树中所含顶点的数目，直到遍及连通图的所有顶点。
+ 1、输入：一个加权连通图，其中顶点集合为v，边集合为e；
+ 2、初始化：vnew = {x}，其中x为集合v中的任一节点（起始点），enew = {}；
+ 3、重复下列操作，直到vnew = v：
+ （1）在集合e中选取权值最小的边（u, v），其中u为集合vnew中的元素，而v则是v中没有加入vnew的顶点（如果存在有多条满足前述条件即具有相同权值的边，则可任意选取其中之一）；
+ （2）将v加入集合vnew中，将（u, v）加入集合enew中；
+ 4、输出：使用集合vnew和enew来描述所得到的最小生成树。

【克鲁斯卡尔算法】：先构造一个只含 n 个顶点、而边集为空的子图，把子图中各个顶点看成各棵树上的根结点，之后，从网的边集 e 中选取一条权值最小的边，若该条边的两个顶点分属不同的树，则将其加入子图，即把两棵树合成一棵树，反之，若该条边的两个顶点已落在同一棵树上，则不可取，而应该取下一条权值最小的边再试之。依次类推，直到森林中只有一棵树，也即子图中含有 n-1 条边为止。

首先我们需要一个存放边的类，新建edge.h和edge.cpp

#edge.h
class edge
{
public:
    edge(int m_inodeindexa = 0, int m_inodeindexb = 0, int m_iweightvalue = 0);
    int m_inodeindexa;
    int m_inodeindexb;
    int m_iweightvalue;
    bool m_bselected;
};

#edge.cpp
#include "stdafx.h"
#include "edge.h"

edge::edge(int nodeindexa, int nodeindexb, int weightvalue)
{
    m_inodeindexa = nodeindexa;
    m_inodeindexb = nodeindexb;
    m_iweightvalue = weightvalue;
    m_bselected = false;
}

边类有四个成员变量，分别是int的m_inodeindexa（边的a顶点，默认值为0）、m_inodeindexb（边的b顶点，默认值为0）、m_iweightvalue（边的权值，默认值为0）以及bool的m_bselected（访问标志，默认值为false）。

接着新建cmap_tree.h和cmap.cpp。

#cmap_tree.h
#include "node.h"
#include "edge.h"
#include "vector"
using namespace std;

class cmap_tree
{
public:
    cmap_tree(int capacity);
    ~cmap_tree();
    bool addnode(node *pnode);      //向途中加入节点
    void resetnode();               //重置节点
    bool setvaluetomatrixfordirectedgraph(int row, int col, int val = 1);      //为有向图设置邻接矩阵
    bool setvaluetomatrixforundirectedgraph(int row, int col, int val = 1);  //为无向图设置邻接矩阵
    void printmatrix();     //打印邻接矩阵
    void depthfitsttraverse(int nodeindex);     //深度优先遍历
    void breadthfitsttraverse(int nodeindex);   //广度优先遍历

    void primtree(int nodeindex);       //普利姆生成树
    void kruskaltree();                 //克鲁斯卡尔算法生成树

private:
    bool getvaluefrommatrix(int row, int col, int &val);   //从矩阵中获取权值
    void breadthfitsttraverseimpl(vector prevec);     //从广度优先遍历实现函数
    int getminedge(vector edgevec);                  //获取最小边

    bool isinset(vector nodeset, int target);         //判断顶点是否在点集合中
    void mergenodeset(vector &nodeseta, vector nodesetb);  //合并两个顶点集合

private:
    int m_icapacity;            //途中最多可以容纳的定点数
    int m_inodecount;           //已经添加节点个数
    node *m_pnodearray;         //用来存放节点数组
    int *m_pmatrix;             //用来存放邻接矩阵

    edge *m_pedge;              //用来存放最小生成树的边
};

#cmap.cpp
#include "stdafx.h"
#include "vector"
#include "iostream"
#include "cmap_tree.h"
using namespace std;


cmap_tree::cmap_tree(int capacity)
{
    m_icapacity = capacity;
    m_inodecount = 0;
    m_pnodearray = new node[m_icapacity];
    m_pmatrix = new int[m_icapacity * m_icapacity];
    //memset(m_pmatrix, 0, m_icapacity * m_icapacity * sizeof(int));
    //void *memset(void *s, int ch, size_t n);
    //函数解释：将s中当前位置后面的n个字节 （typedef unsigned int size_t ）用 ch 替换并返回 s 。
    for (int i = 0; i < m_icapacity * m_icapacity; i++)
    {
        m_pmatrix[i] = 0;
    }

    m_pedge = new edge[m_icapacity - 1];    //边是顶点个数-1
}

cmap_tree::~cmap_tree()
{
    delete[]m_pnodearray;
    delete[]m_pmatrix;
    delete[]m_pedge;
}

bool cmap_tree::addnode(node *pnode)
{
    if (pnode == null)
    {
        return false;
    }
    m_pnodearray[m_inodecount].m_cdata = pnode->m_cdata;
    m_inodecount++;
    return true;
}

void cmap_tree::resetnode()
{
    for (int i = 0; i < m_inodecount; i++)
    {
        m_pnodearray[i].m_bisvisited = false;
    }
}

bool cmap_tree::setvaluetomatrixfordirectedgraph(int row, int col, int val)
{
    if (row < 0 || row >= m_icapacity)
    {
        return false;
    }
    if (col < 0 || col >= m_icapacity)
    {
        return false;
    }
    m_pmatrix[row * m_icapacity + col] = val;
    return true;
}

bool cmap_tree::setvaluetomatrixforundirectedgraph(int row, int col, int val)
{
    if (row < 0 || row >= m_icapacity)
    {
        return false;
    }
    if (col < 0 || col >= m_icapacity)
    {
        return false;
    }
    m_pmatrix[row * m_icapacity + col] = val;
    m_pmatrix[col * m_icapacity + row] = val;
    return true;
}

void cmap_tree::printmatrix()
{
    for (int i = 0; i < m_icapacity; i++)
    {
        for (int k = 0; k < m_icapacity; k++)
        {
            cout << m_pmatrix[i * m_icapacity + k] << " ";
        }
        cout << endl;
    }
}

bool cmap_tree::getvaluefrommatrix(int row, int col, int &val)
{
    if (row < 0 || row >= m_icapacity)
    {
        return false;
    }
    if (col < 0 || col >= m_icapacity)
    {
        return false;
    }
    val = m_pmatrix[row * m_icapacity + col];
    return true;
}

//深度优先遍历
void cmap_tree::depthfitsttraverse(int nodeindex)
{
    int value = 0;

    cout << m_pnodearray[nodeindex].m_cdata << " ";
    m_pnodearray[nodeindex].m_bisvisited = true;

    //通过邻接矩阵判断是否与其他顶点有连接
    for (int i = 0; i < m_icapacity; i++)
    {
        getvaluefrommatrix(nodeindex, i, value);
        if (value != 0) //判断有弧连接其他顶点
        {
            //再判断该点是否被访问过
            if (m_pnodearray[i].m_bisvisited)
            {
                continue;
            }
            else
            {
                depthfitsttraverse(i);
            }
        }
        else
        {
            //如果没有去向索引为 i 的顶点的弧，则循环继续
            continue;
        }
    }
}

//广度优先遍历
void cmap_tree::breadthfitsttraverse(int nodeindex)
{
    cout << m_pnodearray[nodeindex].m_cdata << " ";
    m_pnodearray[nodeindex].m_bisvisited = true;

    vector curvec;           //当前数组
    curvec.push_back(nodeindex);  //压入数组

    breadthfitsttraverseimpl(curvec);
}
//广度优先遍历 进一步
void cmap_tree::breadthfitsttraverseimpl(vector prevec)
{
    int value = 0;
    vector curvec;     //保存当前这一层所有节点

    for (int j = 0; j < (int)prevec.size(); j++)    //prevec.size():上一层节点数
    {
        for (int i = 0; i < m_icapacity; i++)       //判断上一层节点与其他点是否有连接
        {
            getvaluefrommatrix(prevec[j], i, value);
            if (value != 0)
            {
                if (m_pnodearray[i].m_bisvisited)
                {
                    continue;
                }
                else    //如果有连接，置为已访问、输出并保存到当前这一层的curvec
                {
                    cout << m_pnodearray[i].m_cdata << " ";
                    m_pnodearray[i].m_bisvisited = true;

                    curvec.push_back(i);
                }
            }
        }
    }

    if (curvec.empty())     //判断本层是否存在被访问过的点
    {
        return;
    }
    else    //本层访问过的点的个数不为0，下一层可能还有节点与本层的节点相连接
    {
        breadthfitsttraverseimpl(curvec);
    }
}

//普利姆生成树
void cmap_tree::primtree(int nodeindex)
{
    int value = 0;        //保存边的权值
    int edgecount = 0;    //保存边的个数
    vector nodevec;  //存放点的集合(索引)
    vector edgevec; //存放备选边的集合

    cout << m_pnodearray[nodeindex].m_cdata << endl;

    nodevec.push_back(nodeindex);
    m_pnodearray[nodeindex].m_bisvisited = true;

    while (edgecount < m_icapacity - 1)         //算法结束条件
    {
        int temp = nodevec.back();              //保存nodevec最尾部的变量，不能直接把nodeindex赋值，不然这个循环temp一直不变，都是nodeindex
        for (int i = 0; i < m_icapacity; i++)   //寻找与temp节点连接的所有边
        {
            getvaluefrommatrix(temp, i, value);
            if (value != 0)  //判断是否有连接的边
            {
                if (m_pnodearray[i].m_bisvisited)  //判断当前的点是否被访问
                {
                    continue;
                }
                else
                {
                    edge edge(temp, i, value);     //通过相连接的两个点和权值创建一个边的对象
                    edgevec.push_back(edge);       //将边放入备选边集合中（不放重复的边）
                }
            }
        }
        //所有与temp相连接的边都被放入备选边集合中了

        //从备选边集合中找出最小的边的
        int edgeindex = getminedge(edgevec);
        edgevec[edgeindex].m_bselected = true;

        //打印边和权值
        cout << edgevec[edgeindex].m_inodeindexa << "---" << edgevec[edgeindex].m_inodeindexb << " ";
        cout << edgevec[edgeindex].m_iweightvalue << endl;

        m_pedge[edgecount] = edgevec[edgeindex];    //将最小的边保存到最小生成树的边集合中
        edgecount++;

        int nextnodeindex = edgevec[edgeindex].m_inodeindexb;    //找到与当前最小边所连接的下一个点
        nodevec.push_back(nextnodeindex);                        //保证下一次循环时temp为下一个点
        m_pnodearray[nextnodeindex].m_bisvisited = true;
        cout << m_pnodearray[nextnodeindex].m_cdata << endl;
    }
}

int cmap_tree::getminedge(vector edgevec)
{
    int minweight = 0;
    int edgeindex = 0;
    int i = 0;
    for ( ; i < (int)edgevec.size(); i++)     //找出第一条没有被访问的边
    {
        if (!edgevec[i].m_bselected)
        {
            minweight = edgevec[i].m_iweightvalue;
            edgeindex = i;
            break;
        }
    }

    if (minweight == 0)     //如果所有边都被访问过
    {
        return -1;
    }

    for ( ; i < (int)edgevec.size(); i++)
    {
        if (edgevec[i].m_bselected)
        {
            continue;
        }
        else
        {
            if (minweight > edgevec[i].m_iweightvalue)
            {
                minweight = edgevec[i].m_iweightvalue;
                edgeindex = i;
            }
        }
    }

    return edgeindex;
}

//克鲁斯卡尔算法生成树
void cmap_tree::kruskaltree()
{
    int value = 0;
    int edgecount = 0;

    //定义存放节点集合的数组
    vector> nodesets;

    //第一步：取出所有边
    vector edgevec;
    for (int i = 0; i < m_icapacity; i++)
    {
        for (int k = i + 1; k < m_icapacity; k++)  //矩阵上三角
        {
            getvaluefrommatrix(i, k, value);
            if (value != 0)
            {
                edge edge(i, k, value);
                edgevec.push_back(edge);
            }
        }
    }

    //第二步：从所有边中取出组成最小生成树的边
    //1.找到算法结束条件
    while (edgecount < m_icapacity -1)
    {

        //2.从边集合中找到最小边
        int minedgeindex = getminedge(edgevec);
        edgevec[minedgeindex].m_bselected = true;

        //3.找出最小边连接的点
        int nodeaindex = edgevec[minedgeindex].m_inodeindexa;
        int nodebindex = edgevec[minedgeindex].m_inodeindexb;

        bool nodeaisinset = false;
        bool nodebisinset = false;

        int nodeainsetlable = -1;
        int nodebinsetlable = -1;

        //4.找出点所在的点集合
        for (int i = 0; i < (int)nodesets.size(); i++) //在存放节点集合的数组寻找a点在哪一个集合
        {
            nodeaisinset = isinset(nodesets[i], nodeaindex);  //在存放节点集合的数组nodesets的第i个数组中寻找a点
            if (nodeaisinset)
            {
                nodeainsetlable = i;  //找出a点所在集合的索引
            }
        }

        for (int i = 0; i < (int)nodesets.size(); i++) //在存放节点集合的数组寻找b点在哪一个集合
        {
            nodebisinset = isinset(nodesets[i], nodebindex);  //在存放节点集合的数组nodesets的第i个数组中寻找b点
            if (nodebisinset)
            {
                nodebinsetlable = i;  //找出b点所在集合的索引
            }
        }

        //5.根据点所在集合的不同做出不同处理
        if (nodeainsetlable == -1 && nodebinsetlable == -1)  //a点和b点都不在已有的节点集合中，所以ab两个点要放在一个全新的集合中
        {
            vector vec;
            vec.push_back(nodeaindex);
            vec.push_back(nodebindex);
            nodesets.push_back(vec);
        }

        else if (nodeainsetlable == -1 && nodebinsetlable != -1)  //a点不在已有的节点集合中，b点归属某一集合，所以将a点放在b点的集合里边
        {
            nodesets[nodebinsetlable].push_back(nodeaindex);
        }

        else if (nodeainsetlable != -1 && nodebinsetlable == -1)  //b点不在已有的节点集合中，a点归属某一集合，所以将b点放在a点的集合里边
        {
            nodesets[nodeainsetlable].push_back(nodebindex);
        }

        else if (nodeainsetlable != -1 && nodebinsetlable != -1 && nodeainsetlable != nodebinsetlable)  //a点和b点都在已有的节点集合中（两个不同的集合），所以要合并两个集合
        {
            mergenodeset(nodesets[nodeainsetlable], nodesets[nodebinsetlable]);  //合并到第一个参数的集合中，即a的集合
            for (int k = nodebinsetlable; k < (int)nodesets.size() - 1; k++)  //删除b的集合
            {
                nodesets[k] = nodesets[k + 1];
            }
        }

        else if (nodeainsetlable != -1 && nodebinsetlable != -1 && nodeainsetlable == nodebinsetlable)  //a点和b点都在已有的节点集合中（同一个集合），所以直接跳过本次循环
        {
            continue;
        }

        m_pedge[edgecount] = edgevec[minedgeindex];  //将寻找到的最小边放到最小生成树的边集合中
        edgecount++;

        cout << edgevec[minedgeindex].m_inodeindexa << "--" << edgevec[minedgeindex].m_inodeindexb << " ";
        cout << edgevec[minedgeindex].m_iweightvalue << endl;
    }
}

//判断顶点是否在点集合中
bool cmap_tree::isinset(vector nodeset, int target)//判断顶点是否在点集合中
{
    for (int i = 0; i < (int)nodeset.size(); i++)
    {
        if (nodeset[i] == target)
        {
            return true;
        }
    }
    return false;
}

//合并两个顶点集合
void cmap_tree::mergenodeset(vector &nodeseta, vector nodesetb)
{
    for (int i = 0; i < (int)nodesetb.size(); i++)
    {
        nodeseta.push_back(nodesetb[i]);
    }
}

和cmap.h相比，cmap_tree.h多了下面这几个成员函数和成员变量：

public:void primtree(int nodeindex)普利姆算法生成树 public:void kruskaltree()克鲁斯卡尔算法生成树 private:int getminedge(vector edgevec)获取最小边 private:bool isinset(vector nodeset, int target)判断顶点是否在点集合中 private:void mergenodeset(vector &nodeseta, vector nodesetb)合并两个顶点集合 private:edge *m_pedge用来存放最小生成树的边

首先，我们来说说cmap_tree相比cmap，新增加的成员变量边类m_pedge是用来存放最小生成树的边的。

接着来说说void primtree(int nodeindex)普利姆算法生成树函数传入的参数为最小生成树的起点的索引首先创建一个初值为0的int的value来保存边的权值，初值为0的int的edgecount来保存边的个数，int动态数组nodevec存放点的集合（索引），edge动态数组edgevec存放备选边的集合。接着打印一下当前顶点，然后将当前顶点（起点）存入nodevec，并将其访问标志置为true。再接着我们while循环的结束条件为edgecount

#demo_tree.cpp
#include "stdafx.h"
#include "iostream"
#include "cmap_tree.h"
using namespace std;

/*
            a
         /      \
       b- -f--d
        \  / \  / 
         c- -d

 a b c d e f
 0 1 2 3 4 5

 a-b 6    a-e 5    a-f 1
 b-c 3    b-f 2      
 c-f 8    c-d 7
 d-f 4    d-e 2
 e-f 9
*/


int main()
{
    cmap_tree *pmap = new cmap_tree(6);

    node *pnodea = new node('a');
    node *pnodeb = new node('b');
    node *pnodec = new node('c');
    node *pnoded = new node('d');
    node *pnodee = new node('e');
    node *pnodef = new node('f');

    pmap->addnode(pnodea);
    pmap->addnode(pnodeb);
    pmap->addnode(pnodec);
    pmap->addnode(pnoded);
    pmap->addnode(pnodee);
    pmap->addnode(pnodef);

    pmap->setvaluetomatrixforundirectedgraph(0, 1, 6);
    pmap->setvaluetomatrixforundirectedgraph(0, 4, 5);
    pmap->setvaluetomatrixforundirectedgraph(0, 5, 1);
    pmap->setvaluetomatrixforundirectedgraph(1, 2, 3);
    pmap->setvaluetomatrixforundirectedgraph(1, 5, 2);
    pmap->setvaluetomatrixforundirectedgraph(2, 5, 8);
    pmap->setvaluetomatrixforundirectedgraph(2, 3, 7);
    pmap->setvaluetomatrixforundirectedgraph(3, 5, 4);
    pmap->setvaluetomatrixforundirectedgraph(3, 4, 2);
    pmap->setvaluetomatrixforundirectedgraph(4, 5, 9);

    //pmap->primtree(0);
    pmap->kruskaltree();

    system("pause");
    return 0;
}

运行结果如下：

---

基本结束啦，所有的代码都上传到 github 了。