无向图的邻接矩阵和邻接表实现各种操作 -- C++语言描述

一：实现代码

#ifndef _GRAPH_H
#define _GRAPH_H

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

///////////////////////////////////////////////////////////////////////////////////////////
//通用图结构
template <typename T>
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&) = 0;    //插入边

virtual bool remove_vertex(const T&) = 0;            //删除定点
virtual bool remove_edge(const T&, const T&) = 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;     //得到顶点序号
protected:
static const int VERTICES_DEFAULT_SIZE = 10;         //默认图顶点数
int max_vertices;
int num_vertices;
int num_edges;
};

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

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

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

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

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

#define VERTICES_DEFAULT_SIZE graph<T>::VERTICES_DEFAULT_SIZE //派生类继承父类，若父类为模板，派生类不可直接调用父类保护成员
#define num_vertices          graph<T>::num_vertices            //以宏来代替每个位置写作用域的做法
#define num_edges             graph<T>::num_edges
#define max_vertices          graph<T>::max_vertices //另一种方法派生类内定义自己成员函数，可用using graph<T>::num_edges，在类外则不可

///////////////////////////////////////////////////////////////////////////////////////////
//图的邻接矩阵表示法
template <typename T>
class graph_mtx : public graph<T>{
public:
graph_mtx(int);
graph_mtx(int (*)[4], const int);         //矩阵构造

~graph_mtx();
public:
bool insert_vertex(const T&);
bool insert_edge(const T&, const T&);

bool remove_vertex(const T&);
bool remove_edge(const T&, const T&);

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

int get_vertex_index(const T&)const;
void print_graph()const;
private:
T* vertices_list;                        //顶点线性表
int **edge;                              //内部矩阵
};

template <typename T>
graph_mtx<T>::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];
memset(edge[i], 0, sizeof(int)*max_vertices); //清空图
}

num_vertices = 0;
num_edges = 0;
}

template <typename T>
graph_mtx<T>::graph_mtx(int (*mt)[4], const int arr_size)
{
int edge_count = 0;
max_vertices = arr_size > VERTICES_DEFAULT_SIZE ? arr_size
: 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];
memset(edge[i], 0, sizeof(int)*max_vertices);
}

for(int i=0; i<arr_size; ++i)
for(int j=0; j<arr_size; ++j){
edge[i][j] = mt[i][j];
if(mt[i][j] != 0)
++edge_count;
}

num_vertices = arr_size;
num_edges = edge_count / 2;
}

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

delete edge;
delete []vertices_list;
}

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

template <typename T>
bool graph_mtx<T>::insert_edge(const T& vert1, const T& vert2)
{
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] = 1;    //无向图
++num_edges;

return true;
}

template <typename T>
bool graph_mtx<T>::remove_vertex(const T& vert)          //用最后一个节点直接覆盖删除的节点，转化为删除最后一个节点
{
int edge_count = 0;
int index = get_vertex_index(vert);

if(index == -1)
return false;

for(int i=0; i<num_vertices; ++i){
if(edge[index][i] != 0)
++edge_count;
}

if(index != num_vertices-1){
vertices_list[index] = vertices_list[num_vertices-1];

for(int i=0; i<num_vertices; ++i){                     //此处两个循环不可合并，因为要分别执行，否则右下角数据出错
edge[index][i] = edge[num_vertices-1][i];
}
for(int i=0; i<num_vertices; ++i){
edge[i][index] = edge[i][num_vertices-1];
}
}

for(int i=0; i<num_vertices; ++i){
edge[num_vertices-1][i] = 0;
edge[i][num_vertices-1] = 0;
}

--num_vertices;
num_edges -= edge_count;

return true;
}

template <typename T>
bool graph_mtx<T>::remove_edge(const T& vert1, const T& vert2)
{
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] = 0;
--num_edges;

return true;
}

template <typename T>
int graph_mtx<T>::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)
return i;
}
}
return -1;
}

template <typename T>
int graph_mtx<T>::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)
return i;
}
}
return -1;
}

template <typename T>
int graph_mtx<T>::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>
void graph_mtx<T>::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)
cout << edge[i][j] << "  ";
cout << vertices_list[i] << endl;
}
}

///////////////////////////////////////////////////////////////////////////////////////////
//图的邻接表表示法
template <typename T>
struct node{                                              //节点用来存储与它相连接的顶点
int dest;
struct node* link;
node(int d) : dest(d), link(nullptr) {}
};

template <typename T>
struct vertex{                                            //顶点结构体
T vert;                                               //顶点
struct node<T>* adj;                                  //指向描述其他节点的链表
vertex() : vert(T()), adj(nullptr) {}
};

template <typename T>
class graph_lnk : public graph<T>{
public:
graph_lnk(int);
~graph_lnk();
public:
bool insert_vertex(const T& vert);
bool insert_edge(const T& vert1, const T& vert2);

bool remove_vertex(const T& vert);
bool remove_edge(const T& vert1, const T& vert2);

int get_firstneighbor(const T& vert)const;
int get_nextneighbor(const T& vert1, const T& vert2)const;

void print_graph()const;
int get_vertex_index(const T& vert)const;
protected:
void remove_point_self(const int, const int);
void modify_point_self(const int, const int, const int);
private:
vertex<T>* vertices_table;
};

template <typename T>
graph_lnk<T>::graph_lnk(int sz = VERTICES_DEFAULT_SIZE)
{
max_vertices = sz > max_vertices ? sz : VERTICES_DEFAULT_SIZE;
vertices_table = new vertex<T>[max_vertices];                 //不用再清空，结构体构造函数已清空

num_vertices = 0;
num_edges = 0;
}

template <typename T>
graph_lnk<T>::~graph_lnk()
{
for(int i=0; i<max_vertices; ++i){
auto tmp = vertices_table[i].adj;
auto next_tmp = tmp;

while(tmp != nullptr){           //删除节点
next_tmp = tmp->link;
delete tmp;
tmp = next_tmp;
}
}
delete []vertices_table;            //删除表
}

template <typename T>
bool graph_lnk<T>::insert_vertex(const T& vert)
{
if(this->is_full())
return false;

vertices_table[num_vertices++].vert = vert;

return true;
}

template <typename T>
bool graph_lnk<T>::insert_edge(const T& vert1, const T& vert2)
{
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;

auto tmp = vertices_table[index_v1].adj;
while(tmp != nullptr){
if(tmp->dest == index_v2)
return false;
tmp = tmp->link;
}

tmp = new node<T>(index_v2);                    //采用前插法，比尾插法效率高，省事
tmp->link = vertices_table[index_v1].adj;
vertices_table[index_v1].adj = tmp;

tmp = new node<T>(index_v1);
tmp->link = vertices_table[index_v2].adj;
vertices_table[index_v2].adj = tmp;

++num_edges;

return true;
}

template <typename T>
bool graph_lnk<T>::remove_vertex(const T& vert)
{
int index = get_vertex_index(vert);
int edge_count = 0;

if(index == -1)
return false;

auto tmp = vertices_table[index].adj;
auto next_tmp = tmp;

while(tmp != nullptr){
remove_point_self(index, tmp->dest);       //删除目标顶点指向自己的节点
++edge_count;                              //记录边数
next_tmp = tmp->link;
delete tmp;
tmp = next_tmp;
}

if(index != num_vertices-1){
vertices_table[index].adj = vertices_table[num_vertices-1].adj;     //用最后一个顶点覆盖要删除的顶点
vertices_table[index].vert = vertices_table[num_vertices-1].vert;
}

tmp = vertices_table[index].adj;
while(tmp != nullptr){
modify_point_self(tmp->dest, num_vertices-1, index);                //调整原指向最后一个顶点的节点，使其指向新的位置
tmp = tmp->link;
}

--num_vertices;
num_edges -= edge_count;

return true;
}

template <typename T>
bool graph_lnk<T>::remove_edge(const T& vert1, const T& vert2)
{
int index_v1 = get_vertex_index(vert1);
int index_v2 = get_vertex_index(vert2);

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

remove_point_self(index_v1, index_v2);                //相互删除指向自己的节点，相当于删除边
remove_point_self(index_v2, index_v1);

return true;
}

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

if(index != -1 && vertices_table[index].adj != nullptr){    //第一个结点即为所求
return vertices_table[index].adj->dest;
}
return -1;
}

template <typename T>
int graph_lnk<T>::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){
auto tmp = vertices_table[index_v1].adj;

while(tmp != nullptr && tmp->dest != index_v2)
tmp = tmp->link;

if(tmp->dest == index_v2 && tmp->link != nullptr)
return tmp->link->dest;
}
return -1;
}

template <typename T>
void graph_lnk<T>::remove_point_self(const int self_index, const int other_index)       //删除指向自己的结点
{
auto tmp = vertices_table[other_index].adj;
auto pre_tmp = tmp;

while(tmp->dest != self_index){
pre_tmp = tmp;
tmp = tmp->link;
}

if(pre_tmp == tmp)
vertices_table[other_index].adj = tmp->link;
else
pre_tmp->link = tmp->link;

delete tmp;
}

template <typename T>
void graph_lnk<T>::modify_point_self(const int other_index,
const int old_index, const int new_index)         //调整原指向最后一个顶点的节点，使其指向新的位置
{
auto tmp = vertices_table[other_index].adj;

while(tmp->dest != old_index){
tmp = tmp->link;
}
tmp->dest = new_index;
}

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

template <typename T>
void graph_lnk<T>::print_graph()const
{
if(this->is_empty()){
cout << "nil graph" << endl;
return ;
}

for(int i=0; i<num_vertices; ++i){
cout << vertices_table[i].vert << " : ";

auto tmp = vertices_table[i].adj;
while(tmp != nullptr){
cout << tmp->dest << "-->";
tmp = tmp->link;
}
cout << "nil" << endl;
}
}

#endif

二：相关测试代码

#include "graph.h"

#define VERTEX_SIZE 4

int main()
{
int mtx[][VERTEX_SIZE] = {{0,1,0,1},
{1,0,1,0},
{0,1,0,1},
{1,0,1,0}};
//graph_mtx<int> gm(mtx, VERTEX_SIZE);

graph_mtx<char> gm;
gm.insert_vertex('A');
gm.insert_vertex('B');
gm.insert_vertex('C');
gm.insert_vertex('D');

gm.insert_edge('A', 'B');
gm.insert_edge('A', 'D');
gm.insert_edge('B', 'C');
gm.insert_edge('C', 'D');

//cout << gm.get_firstneighbor('A') << endl;
//cout << gm.get_nextneighbor('A', 'B') << endl;

//gm.remove_vertex('B');
gm.remove_edge('A', 'B');

gm.print_graph();

return 0;
}*/

#include "graph.h"

#define VERTEX_SIZE 4

int main()
{
graph_lnk<char> gl;

gl.insert_vertex('A');
gl.insert_vertex('B');
gl.insert_vertex('C');
gl.insert_vertex('D');

gl.insert_edge('A','B');
gl.insert_edge('A','C');
gl.insert_edge('B','D');
gl.print_graph();

cout << "-------------after remove-------------" << endl;
gl.remove_vertex('A');
gl.print_graph();

//gl.remove_edge('A', 'B');
//gl.print_graph();

cout << gl.get_firstneighbor('A') << endl;
cout << gl.get_nextneighbor('A', 'C') << endl;

return 0;
}