//图的存储结构:
const int MAXSIZE = 10;
//邻接矩阵
template<class T>
class MGraph {
public:
MGraph(T a[], int n, int e);
void DFS(int v);
void BFS(int v);
private: //edge为边用来表示无向图,arc为弧用来表示有向图,vertex为顶点
T vertex[MAXSIZE];
int arc[MAXSIZE][MAXSIZE];
int edge[MAXSIZE][MAXSIZE];
int vNum, arcNum,eNum;
bool* visited; //DFS使用
};
template<class T>
MGraph<T>::MGraph(T a[], int v, int e) { //n为顶点个数,e为边的个数,a[]为各顶点值
vNum = v; //将顶点个数,边个数,顶点值放入类中属性
arcNum = e;
visited = new bool[v];
memset(visited, false, sizeof(bool) * v);
for (int k = 0; k < v; k++) {
vertex[k] = a[k];
}
for (int k = 0; k < v; k++) { //先将邻接矩阵初始化
for (int j = 0; j < v; j++) {
arc[k][j] = 0;
}
}
for (int k = 0,i=0,j=0; k < e; k++) { //这里是无向图的邻接矩阵,输入相连的两个顶点
cin >> i >> j;
arc[j-1][i-1] = arc[i-1][j-1] = 1;
}
}
//邻接表,同样以无向图为例,边用arc表示
struct ArcNode { //边的数据结构,存储边信息和下一条边
int adjvex; //相邻的顶点
ArcNode* nextarc;
};
struct VertexNode { //顶点的数据结构,存储顶点信息和下一条边
int vertex;
ArcNode* firstarc;
};
template<class T>
class ALGraph {
public:
ALGraph(T a[], int n, int e);
//~ALGraph();
void DFS(int v);
void BFS(int v);
private:
VertexNode adjlist[MAXSIZE];
int vNum, arcNum;
bool* visited;
};
template<class T>
ALGraph<T>::ALGraph(T a[], int v, int e) {
vNum = v;
arcNum = e;
visited = new bool[v];
memset(visited, false, sizeof(bool) * v);
for (int i = 0; i < v; i++) { //对顶点表进行初始化
adjlist[i].vertex = a[i];
adjlist[i].firstarc = NULL;
}
for (int k = 0,i=0,j=0; k < e; k++) { //这里是无向图,如果有向图的话,则为顶点i指向j
cin >> i >> j; //注意这里的e是每个顶点连接的边的总和,将无向看成有双箭头的有向(实际不适合表示无向图)
ArcNode* s = new ArcNode;
s->adjvex = j; //这里使用的是头插入法
s->nextarc = adjlist[i-1].firstarc;
adjlist[i-1].firstarc = s;
}
}
//补充:邻接表适合表示有向图,还有一种逆邻接表表示法,与邻接表的出为指向方向相反,逆邻接表类似于入边表
//十字链表,只提供节点的存储结构
struct VertexNodeC {
int Vertex;
ArcNode* firstin;
ArcNode* firstout;
};
struct ArcNodeC {
int headvex,tailvex;
ArcNode* hlink;
};
//边集数组,比较常用,使用两个一维数组存储,一个数组存储顶点,一个数组存储起点,终点,权值
struct ArcNodeE {
int headvex;
int tailvex;
int weight;
};
//图的遍历:DFS与BFS
//DFS深度优先搜索,类似于二叉树的前序遍历,先从一条支路到结尾,然后一步步回溯寻找还未访问过的节点
//邻接矩阵和邻接表两种存储结构的dfs
//两种存储结构的dfs比较
//邻接矩阵的时间复杂度 n
//邻接表的时间复杂度 n+e 栈深度 n 空间复杂度 n
template<class T>
void MGraph<T>::DFS(int v) {
cout << vertex[v];
visited[v] = true; //将访问过的顶点标记为访问过
for (int j = 0; j < vNum; j++) { //按照邻接矩阵的特性,根据标记来深入搜索
if (arc[v][j] == 1 && visited[j] == false) {
DFS(j);
}
}
}
template<class T>
void ALGraph<T>::DFS(int v) { //根据邻接表的连接,从顶点第一个边节点转为顶点节点,并标记是否访问,然后一步步回溯看是否有未访问的相邻节点
cout << adjlist[v].vertex;
visited[v] = true;
ArcNode* p = adjlist[v].firstarc;
while (p) {
if (visited[p->adjvex] == false) {
DFS(p->adjvex);
}
p = p->nextarc;
}
}
//BFS广度优先搜索,类似于树的层序遍历,使用队列逻辑结构
//分别用邻接矩阵和邻接表描述
//邻接矩阵时间复杂度 n
//邻接表时间复杂度 n+e 空间复杂度 n
template<class T>
void MGraph<T>::BFS(int v) {
int queue[MAXSIZE];
int f = 0, r = 0;
cout << vertex[v];
visited[v] = true;
queue[++r] = v;
while (f != r) { //当头尾相等时队列为空,表示队列为空
v = queue[++f];
for (int j = 0; j < vNum; j++) {
if (arc[v][j] == 1 && visited[j] == false) {
cout << vertex[j];
visited[j] = true;
queue[++r] = j;
}
}
}
}
template<class T>
void ALGraph<T>::BFS(int v) {
int queue[MAXSIZE];
int f = 0, r = 0;
cout << adjlist[v].vertex;
visited[v] = true;
queue[++r] = v;
while (r!=f) {
v = queue[++f];
ArcNode *p = adjlist[v].firstarc;
while (p) {
int j = p->adjvex;
if (visited[j] == false) {
cout << adjlist[j].vertex;
visited[j] = true;
queue[++r] = j;
}
p = p->nextarc;
}
}
}
关于图的4中基本算法放在单独一篇,Prim,Kruskal,Floyd,Dijkstra
图的数据结构的实现与遍历(DFS,BFS)
猜你喜欢
转载自www.cnblogs.com/cimuhuashuimu/p/12134076.html
今日推荐
周排行