图的深度优先搜索和广度优先搜索算法、最小生成树两种算法 --C++实现

一：通用图结构

#ifndef _GRAPH_H
#define _GRAPH_H

#include <iostream>
#include <string.h>
#include <assert.h>
#include <queue>
using namespace::std;

#define MAX_COST 0x7FFFFFFF   //花费无限大设为整型最大值

///////////////////////////////////////////////////////////////////////////////////////////
//通用图结构
template <typename T, typename E>
class graph{
public:
bool is_empty()const;
bool is_full()const;

int get_numvertices()const;    //当前顶点数
int get_numedges()const;       //当前边数
public:
virtual bool insert_vertex(const T&) = 0;            //插入顶点
virtual bool insert_edge(const T&, const T&, E) = 0;    //插入边

virtual int get_firstneighbor(const T&)const = 0;    //得到第一个邻接顶点
virtual int get_nextneighbor(const T&, const T&)const = 0;    //某邻接顶点的下一个邻接顶点

virtual void print_graph()const = 0;
virtual int get_vertex_index(const T&)const = 0;     //得到顶点序号

virtual void depth_first(const T&) = 0;
virtual void broad_first(const T&) = 0;

virtual void min_spantree_kruskal() = 0;
virtual void min_spantree_prim(const T&) = 0;
protected:
static const int VERTICES_DEFAULT_SIZE = 10;         //默认图顶点数
int max_vertices;
int num_vertices;
int num_edges;
};

template <typename T, typename E>
bool graph<T, E>::is_empty()const
{
return num_edges == 0;
}

template <typename T, typename E>
bool graph<T, E>::is_full()const
{
return num_vertices >= max_vertices
|| num_edges >= max_vertices*(max_vertices-1)/2;    //判满，分为顶点满和边满
}

template <typename T, typename E>
int graph<T, E>::get_numvertices()const
{
return num_vertices;
}

template <typename T, typename E>
int graph<T, E>::get_numedges()const
{
return num_edges;
}

///////////////////////////////////////////////////////////////////////////////////////////

#define VERTICES_DEFAULT_SIZE graph<T, E>::VERTICES_DEFAULT_SIZE
#define num_vertices          graph<T, E>::num_vertices
#define num_edges             graph<T, E>::num_edges
#define max_vertices          graph<T, E>::max_vertices

///////////////////////////////////////////////////////////////////////////////////////////

#endif /*graph.h*/

二：邻接矩阵图结构

#pragma once

#include "graph.h"

//图的邻接矩阵表示法
template <typename T, typename E>
class graph_mtx : public graph<T, E>{
public:
graph_mtx(int);
~graph_mtx();
public:
bool insert_vertex(const T&);
bool insert_edge(const T&, const T&, E);

int get_firstneighbor(const T&)const;
int get_nextneighbor(const T&, const T&)const;

int get_vertex_index(const T&)const;
T& get_vertex_symbol(const int)const;
void print_graph()const;

void depth_first(const T&);
void broad_first(const T&);

void min_spantree_kruskal();
void min_spantree_prim(const T&);
protected:
void depth_first(const T&, bool *);
private:
T* vertices_list;                        //顶点线性表
E **edge;                              //内部矩阵
};

template <typename T, typename E>
graph_mtx<T, E>::graph_mtx(int sz = VERTICES_DEFAULT_SIZE)
{
max_vertices = sz > VERTICES_DEFAULT_SIZE ? sz
: VERTICES_DEFAULT_SIZE;
vertices_list = new T[max_vertices];

edge = new int*[max_vertices];                    //动态申请二维数组
for(int i=0; i<max_vertices; ++i){
edge[i] = new int[max_vertices];
}

for(int i=0; i<max_vertices; ++i)
for(int j=0; j<max_vertices; ++j){
if(i != j)
edge[i][j] = MAX_COST;
else
edge[i][j] = 0;
}

num_vertices = 0;
num_edges = 0;
}

template <typename T, typename E>
graph_mtx<T, E>::~graph_mtx()
{
for(int i=0; i<max_vertices; ++i)
delete []edge[i];                     //分别析构，再总析构

delete edge;
delete []vertices_list;
}

template <typename T, typename E>
bool graph_mtx<T, E>::insert_vertex(const T& vert)
{
if(this->is_full())                       //派生类函数调用父类函数，用this或加作用域
return false;
vertices_list[num_vertices++] = vert;
return true;
}

template <typename T, typename E>
bool graph_mtx<T, E>::insert_edge(const T& vert1, const T& vert2, E cost = MAX_COST)//由于权值存在默认值，get_neighbor的操作需判断是否等于MAX_COST，否则不能正常取得邻接顶点
{
if(this->is_full())                       //判满
return false;

int index_v1 = get_vertex_index(vert1);   //得到顶点序号
int index_v2 = get_vertex_index(vert2);

if(index_v1 == -1 || index_v2 == -1 )
return false;

edge[index_v1][index_v2] = edge[index_v2][index_v1] = cost;    //无向图
++num_edges;

return true;
}

template <typename T, typename E>
int graph_mtx<T, E>::get_firstneighbor(const T& vert)const
{
int index = get_vertex_index(vert);

if(index != -1){
for(int i=0; i<num_vertices; ++i){
if(edge[index][i] != 0 && edge[index][i] != MAX_COST)  //加上判断MAX_COST
return i;
}
}
return -1;
}

template <typename T, typename E>
int graph_mtx<T, E>::get_nextneighbor(const T& vert1, const T& vert2)const
{
int index_v1 = get_vertex_index(vert1);
int index_v2 = get_vertex_index(vert2);

if(index_v1 != -1 && index_v2 != -1){
for(int i=index_v2+1; i<num_vertices; ++i){
if(edge[index_v1][i] != 0 && edge[index_v1][i] != MAX_COST)
return i;
}
}
return -1;
}

template <typename T, typename E>
int graph_mtx<T, E>::get_vertex_index(const T& vert)const
{
for(int i=0; i<num_vertices; ++i){
if(vertices_list[i] == vert)
return i;
}
return -1;
}

template <typename T, typename E>
T& graph_mtx<T, E>::get_vertex_symbol(const int index)const
{
assert(index >= 0 && index < this->get_numvertices());
//assert(index >= 0 && index < num_vertices); //error，由于num_vertices本身是我们用宏替换父类该元素，在这里使用会出现双重宏
return vertices_list[index];
}

template <typename T, typename E>
void graph_mtx<T, E>::print_graph()const
{
if(this->is_empty()){
cout << "nil graph" << endl;                      //空图输出nil
return;
}

for(int i=0; i<num_vertices; ++i){
cout << vertices_list[i] << "  ";
}
cout << endl;

for(int i=0; i<num_vertices; ++i){
for(int j=0; j<num_vertices; ++j){
if(edge[i][j] != MAX_COST)
cout << edge[i][j] << "  ";
else
cout << '@' << "  ";        //若权值无限大，以@代替
}
cout << vertices_list[i] << endl;
}
}

template <typename T, typename E>
void graph_mtx<T, E>::depth_first(const T& vert)   //深度优先，认准一条路往死走，无路可走再回退
{
int num = this->get_numvertices();
bool *visited = new bool[num];

memset(visited, 0, sizeof(bool)*num);          //首先全部赋值为假，遍历过后为真，防止图死循环
depth_first(vert, visited);
cout << "end.";

delete []visited;
}

template <typename T, typename E>
void graph_mtx<T, E>::depth_first(const T& vert, bool *visited)
{
cout << vert << "-->";

int index = get_vertex_index(vert);
visited[index] = true;

int neighbor_index = get_firstneighbor(vert);
while(neighbor_index != -1){
if(!visited[neighbor_index])
depth_first(get_vertex_symbol(neighbor_index), visited);   //递归

neighbor_index = get_nextneighbor(vert,
get_vertex_symbol(neighbor_index));
}
}

template <typename T, typename E>
void graph_mtx<T, E>::broad_first(const T& vert)
{
int num = this->get_numvertices();
bool *visited = new bool[num];
int index = get_vertex_index(vert);
assert(index != -1);

memset(visited, 0, sizeof(bool)*num);

queue<int> que;                    //通过队列，将元素以次入队
que.push(index);

cout << vert << "-->";
visited[index] = true;

while(!que.empty()){
int index_tmp = que.front();
que.pop();

int neighbor_index = get_firstneighbor(get_vertex_symbol(index_tmp));
while(neighbor_index != -1){
if(!visited[neighbor_index]){
cout << get_vertex_symbol(neighbor_index) << "-->";
visited[neighbor_index] = true;                  //遍历过后为真，防止图死循环
que.push(neighbor_index);
}
neighbor_index = get_nextneighbor(get_vertex_symbol(index_tmp),
get_vertex_symbol(neighbor_index));
}
}
cout << "end.";

delete []visited;
}

//////////////////////////////////////////////////////////////////
//min_spactree_kruskal
template <typename T, typename E>
struct _mst_edge{                  //最小生成树边的结构体,<begin, end>为一组边，cost为花费
int begin;
int end;
E cost;
};

template <typename T, typename E>
int compare(const void* vp1, const void* vp2)
{
return (*(_mst_edge<T, E> *)vp1).cost - (*(_mst_edge<T, E> *)vp2).cost;
}

bool _is_same(int *father, int begin, int end)            //判断是否在同一张子图中
{
while(father[begin] != begin)
begin = father[begin];
while(father[end] != end)
end = father[end];

return begin == end;                       //以最后一个元素是否存在父子关系判断
}

void mark_same(int *father, int begin, int end)
{
while(father[begin] != begin)
begin = father[begin];
while(father[end] != end)
end = father[end];

father[end] = begin;                    //让最后一个元素连接起来，使它们成为同一子图的元素
}

template <typename T, typename E>
void graph_mtx<T, E>::min_spantree_kruskal()
{
int num = this->get_numvertices();
_mst_edge<T, E> *mst_edge = new _mst_edge<T, E>[num*(num-1)/2];

int k = 0;
for(int i=0; i<num; ++i)
for(int j=i+1; j<num; ++j){       //建立有效边结构体数组，从i+1开始，直接统计矩阵1/2边数，不会产生重复
if(edge[i][j] != MAX_COST){
mst_edge[k].begin = i;
mst_edge[k].end = j;
mst_edge[k].cost = edge[i][j];
++k;
}
}

qsort(mst_edge, k, sizeof(_mst_edge<T, E>), compare<T, E>);   //调用快速排序函数

int *father = new int[num];          //初始化使所有元素的父指向自己
for(int i=0; i<num; ++i)
father[i] = i;

for(int i=0; i<num; ++i)
if(!_is_same(father, mst_edge[i].begin, mst_edge[i].end)){  //判断是否在同一张子图中
cout << get_vertex_symbol(mst_edge[i].begin) << "-->"
<< get_vertex_symbol(mst_edge[i].end)
<< ":"  << mst_edge[i].cost << endl;
mark_same(father, mst_edge[i].begin, mst_edge[i].end);   //加入后做标记
}

delete []father;
delete []mst_edge;
}

//////////////////////////////////////////////////////////////////
//min_spantree_prim

template <typename T, typename E>
void graph_mtx<T, E>::min_spantree_prim(const T& vert)
{
int num = this->get_numvertices();
int *lowcost = new int[num];   //最小花费数组
int *mst = new int[num];       //起始位置数组 <mst[i], i> 为一组边，起始为mst[i]

int index = get_vertex_index(vert);
assert(index != -1);

for(int i=0; i<num; ++i){      //初始化使每个元素默认花费是以起始边为vert作为基准，所以mst[i]对应下标即为vert的下标index
if(edge[index][i] != 0){
lowcost[i] = edge[index][i];
mst[i] = index;
}
else
lowcost[i] = 0;
}

for(int i=0; i<num-1; ++i){     //循化，num个元素共有num-1条边
int min = MAX_COST;
int min_index = -1;

for(int j=0; j<num; ++j){
if(lowcost[j] != 0 && lowcost[j] < min){    //找出最小花费
min = lowcost[j];
min_index = j;
}
}

cout << get_vertex_symbol(mst[min_index]) << "-->"
<< get_vertex_symbol(min_index) << ":" << min << endl;

lowcost[min_index] = 0;    //花费为0，相当于加入已生成树中

for(int j=0; j<num; ++j){   //循环，如果某元素到新元素的花费比默认花费小，那么就更新它，
int cost = edge[min_index][j];//下次再循环到上面找最小花费时，就可能找到更新的这个最小花费，这就相当于每次加入新元素后
if(cost < lowcost[j]){          //其他顶点挑出与已生成树所有顶点的花费最小值，并更新
lowcost[j] = cost;
mst[j] = min_index;
}
}
}

delete []lowcost;
delete []mst;
}

三：测试部分

#include "graph.h"
#include "graph_mtx.h"

#define VERTEX_SIZE 4

int main()
{
graph_mtx<char, int> gm;

gm.insert_vertex('A');
gm.insert_vertex('B');
gm.insert_vertex('C');
gm.insert_vertex('D');
gm.insert_vertex('E');
gm.insert_vertex('F');

gm.insert_edge('A', 'B', 6);
gm.insert_edge('A', 'C', 1);
gm.insert_edge('A', 'D', 5);
gm.insert_edge('B', 'C', 5);
gm.insert_edge('B', 'E', 3);
gm.insert_edge('C', 'D', 5);
gm.insert_edge('C', 'F', 4);
gm.insert_edge('D', 'F', 2);
gm.insert_edge('E', 'F', 6);
gm.insert_edge('C', 'E', 6);
gm.print_graph();

cout << "depth_first traverse:" << endl;
gm.depth_first('A');
cout << endl;

cout << "broad_first traverse:" << endl;
gm.broad_first('A');
cout << endl;

cout << "min_spantree_kruskal :" << endl;
gm.min_spantree_kruskal();
cout << "min_spantree_prim :" << endl;
gm.min_spantree_prim('A');

return 0;
}