无向图
术语表
图：由一组顶点个一组能够将两个顶点相连的边组成。
自环：一条连接一个顶点和其自身的边。
平行边：连接同一对顶点的两条边称为平行边。
多重图：含有平行边。
简单图：没有平行边和自环。
相邻：两个顶点通过一条边相连，并称这条边依附这两个顶点。
顶点的度数：依附于他的边的数量。
子图：一幅图的所有边的一个子集（以及所依附的所有顶点）组成的图。
路径：由边顺序连接的一系列顶点。
简单路径：一条没有重复顶点的路径。
环：一条至少含有一条边且起点和终点相同的路径。
简单环：除起点外不含重复顶点和边的环。
路径或环的长度：包含的边数。
文中环和路径指简单环和简单路径，一般环和路径指有可重复的顶点。
连通图：如果任意一个顶点都存在一条路径到达另一个任意顶点，我们称这幅图是连通图。
极大连通子图：一幅非连通的图由若干连通部分组成，他们都是极大连通子图。
无环图：一种没有环的图。
树：一幅无环连通子图。
森林：换不相连的树。
连通图的生成树：他的一幅子图，含有图中所有的顶点且是一棵树。
图的生成树森林：他的所有连通子图的生成树的集合。
当一幅含有V个结点的图G满足下列5个条件之一时，他就是一棵树：
1）G有V-1条边且不含有环；
2）G有V-1条边且是连通的：
3）G是连通的，但删除任意一条边都会使他不在连通；
4）G是无环图，但添加任意一条边都会产生一条环；
5）G中的任意一对顶点之间仅存在一条简单路径。
图的密度：已经链接的顶点对占所有可能被连接的顶点对的比例，稀疏图中，被链接的顶点对很少；而稠密图中很多。如果一幅图中不同的边的数量在顶点总数v的一个小的常数倍以内为稀疏图，否则为稠密图。
二分图：一种能够将所有结点分为两部分的图，每条边所连接的两个顶点都分别属于不同的部分。
图的表示方式：
要求：
1）它必须为可能在应用中碰到的各种类型的图预留出足够的空间。
2）图的实例方法一定要快——他们是开发处理图的各种用例的基础。
1.邻接矩阵：V*V的布尔矩阵，满足不了空间。
2.边的数组：满足不了第二个条件。
3.邻接表数组：一个以顶点为索引的列表数组，其中的每个元素都是和该顶点相邻的列表数组。（类似于拉链式的散列表）
本章解决的无向图问题：
| 问题 | 解决方法 |
| 无向图的创建 | Graph |
| 单点连通性 | DepthFirstSearch |
| 单点路径 | DepthFirstPaths |
| 单点最短路径 | BreadthFirstPaths |
| 连通性 | CC |
| 检测环 | Cycle |
| 双色问题（二分） | TwoColor |
实现：
1.无向图的创建
具体方法是构建一个邻接表存储所有结点，每个结点指向一条链表存储结点相连的所有边。
代码：
#ifndef GRAPH_H
#define GRAPH_H
#include<iostream>
#include<vector>
#include"Bag.h"
using std::cout;
using std::endl;
using std::cin;
using std::vector;
class Graph
{
private:
int V = 0;//顶点数
int E = 0;//边数
vector<Bag<int>> adj;//邻接表
public:
Graph(int V):V(V),E(0),adj(V){}//构造结点
Graph(int V, int E) :V(V), adj(V)//构造整个图
{
int v, w;
for (int i = 0; i < E; i++)
{
cout << "输入第" << i << "边的两个结点：" << endl;
cin >> v >> w;
addEdge(v, w);//添加边
}
}
int getV(){ return V; }
int getE(){ return E; }
void addEdge(int v, int w)//连接v,w
{
adj[v].add(w);//将连接的结点倒入自己的链表
adj[w].add(v);
E++;
}
Bag<int> getadj(int v) { return adj[v]; }
};
#endif
#include<string>
#include<iostream>
#include<vector>
#include"Graph.h"
#include"Bag.h"
using namespace std;
int main()
{
cout << "输入顶点数和边数：" << endl;
int n,m;
cin >> n>>m;
Graph G(n,m);
for (int v = 0; v < G.getV(); v++)
{
cout << v << ": ";
G.getadj(v).trave();
cout << endl;
}
system("pause");
return 0;
}
2.单点连通性（深度优先搜索）
搜索和一个结点连通的所以结点，具体步骤：
1）设置一个bool数组，记录结点是否已经经过，也就是是否连通；
2）遍历结点的链表，被查看的链表元素没有经过则记录元素，然后递归遍历被查看的元素的链表；
3）有记录则查看链表下一个元素。
深度优先搜索的意思是在图中优先搜索一条路径，走到头之后（也就是该结点连接的所以链表元素都被记录），返回上一路口，走另一条路。
代码：
#ifndef DEPTHFIRSTSEARCH_H
#define DEPTHFIRSTSEARCH_H
#include<vector>
#include"Graph.h"
using std::vector;
class DepthFirstSearch//深度优先搜索
{
private:
vector<bool> marked;//记录顶点是否和起点S连通
int count=0;//与起点S连通的顶点总数
public:
DepthFirstSearch(Graph G, int s) :marked(G.getV())
{
dfs(G, s);
}
void dfs(Graph G, int v)
{
marked[v] = true;
count++;
for (const auto & w: G.getadj(v))
if (!marked[w])dfs(G, w);
}
bool getmarked(int w){ return marked[w]; }
int getcount(){ return count; }
};
#endif
#include<string>
#include<iostream>
#include<vector>
#include"Graph.h"
#include"Bag.h"
#include"DepthFirstSearch.h"
using namespace std;
int main()
{
cout << "输入顶点数和边数：" << endl;
int n,m;
cin >> n>>m;
Graph G(n,m);
DepthFirstSearch search(G, 0);
for (int v = 0; v < G.getV(); v++)
if (search.getmarked(v))
cout << v << " ";
cout << endl;
system("pause");
return 0;
}3.寻找路径（基于深度优先搜索）
在深度优先搜索的基础上加一个数组，用来存储每个结点来时的路径（前置结点），然后用栈逆向输出即可。
代码：
#ifndef DEPTHFIRSTPATHS_H
#define DEPTHFIRSTPATHS_H
#include<vector>
#include"Graph.h"
#include"stack.h"
using std::vector;
class DepthFirstPaths
{
private:
vector<bool> marked;//记录结点是否经过
vector<int> edgeTo;//记录结点的上一结点
int s=0;//起点
public:
DepthFirstPaths(Graph G, int s) :
marked(G.getV()), edgeTo(G.getV()), s(s)
{
dfs(G, s);
}
void dfs(Graph G, int v)
{
marked[v] = true;//已经过v
for (int w : G.getadj(v))//遍历v的链表
if (!marked[w])//W没有经过
{
edgeTo[w] = v;//记录此结点的上一路径
dfs(G, w);//查询w的链表元素
}
}
bool hasPathTo(int v){ return marked[v]; }//是否存在s到v的路径
stack<int> pathTo(int v)//输出s到v的路径
{
stack<int> path;
if (!hasPathTo(v))return path;
for (int i = v; i != s; i = edgeTo[i])
path.push(i);
path.push(s);
return path;
}
};
#endif测试用例：
#include<string>
#include<iostream>
#include<vector>
#include"Graph.h"
#include"Bag.h"
#include"DepthFirstPaths.h"
using namespace std;
int main()//DepthFirstPaths.h
{
cout << "输入顶点数和边数：" << endl;
int n, m,s;
cin >> n >> m;
Graph G(n, m);
cout << "输入查询顶点：" << endl;
cin >> s;
DepthFirstPaths Paths(G, s);
for (int v = 0; v < G.getV(); v++)
{
cout << s << " to " << v << ": ";
if (Paths.hasPathTo(v))
for (int x : Paths.pathTo(v))
if (x == s)cout << x;
else cout << "-" << x;
cout << endl;
}
system("pause");
return 0;
}
4.单点最短路径（基于广度优先搜索）
广度优先搜索与深度优先搜索的区别在于，我们先将与结点相连的结点搜索完，之后在查询下一层级，也就是说，我们先搜索结点的链表，结束之后，搜索结点链表首元素的链表，次元素的链表，依次下去直到全部元素所有元素都查完。所以这里我们就需要用一个队列记录搜索过的结点，以便返回使用，具体步骤：
1）设置队列记录首元素；
2）首元素出队，检查元素链表，经过元素全部入队，并记录；
3）对不为空，下一元素出队，继续进行检查，记录；
4）为空，结束。
代码：
#ifndef BREADTHFIRSTPATHS_H
#define BREADTHFIRSTPATHS_H
#include<vector>
#include"Graph.h"
#include"queue.h"
#include"stack.h"
using std::vector;
class BreadthFirstPaths
{
private:
vector<bool> marked;//记录是否已经过
vector<int> edgeTo;//记录上一路径
int s=0;//起点
public:
BreadthFirstPaths(Graph G, int s) :
marked(G.getV()), edgeTo(G.getV()), s(s)
{
bfs(G, s);
}
void bfs(Graph G, int s)
{
queue<int> que;
marked[s] = true;//标记起点
que.enqueue(s);
while (!que.Empty())
{
int v = que.dequeue();//取出下一个结点
for (int w : G.getadj(v))//遍历结点链表
if (!marked[w])//链表元素未被标记
{
edgeTo[w] = v;//记录他上一路径
marked[w] = true;//标记元素
que.enqueue(w);//入队
}
}
}
bool hasPathTo(int v){ return marked[v]; }//是否存在s->v的路径
stack<int> pathTo(int v)//输出s->v的路径
{
stack<int> path;
if (!hasPathTo(v))return path;
for (int i = v; i != s; i = edgeTo[i])
path.push(i);
path.push(s);
return path;
}
};
#endif测试用例：
#include<string>
#include<iostream>
#include<vector>
#include"Graph.h"
#include"Bag.h"
#include"BreadthFirstPaths.h"
using namespace std;
int main()//BreadthFirstPaths
{
cout << "输入顶点数和边数：" << endl;
int n, m, s;
cin >> n >> m;
Graph G(n, m);
cout << "输入查询顶点：" << endl;
cin >> s;
BreadthFirstPaths paths(G, s);
for (int v = 0; v < G.getV(); v++)
{
cout << s << " to " << v << ": ";
if (paths.hasPathTo(v))
for (int x : paths.pathTo(v))
if (x == s)cout << x;
else cout << "-" << x;
cout << endl;
}
system("pause");
return 0;
}
5.连通分量（基于深度优先搜索）
深度优先搜索的下一个直接应用就是找出一幅图的所有连通分量。
连通分量:即图中，一个最大连通子图就是一个连通分量。
查找图的所有连通分量，只需要深度优先搜索所有的结点，用一个数组记录是相同连通分量的结点打上同样的标记即可。
代码：
#ifndef CC_H
#define CC_H
#include<vector>
#include"Graph.h"
#include"Bag.h"
using std::vector;
class CC
{
private:
vector<bool> marked;//结点是否被记录
vector<int> id;//记录结点在那一连通分量
int count;//连通分量的数目
public:
CC(Graph G) :marked(G.getV()), id(G.getV()), count(0)
{
for (int s=0 ; s < G.getV();s++)
if (!marked[s])
{
dfs(G, s);
count++;
}
}
void dfs(Graph G, int v)
{
marked[v] = true;//标记v
id[v] = count;//记录v输入那一连通分量
for (int w : G.getadj(v))
if (!marked[w])
dfs(G, w);
}
bool connected(int v, int w)//判断v，w是否连通
{
return id[v] == id[w];
}
int getid(int v){ return id[v]; }//输入v在那一连通分量
int getcount(){ return count; }//连通分量数目
vector<Bag<int>> componentsTo(Graph G)
{
int m = getcount();
vector<Bag<int>> components(m);
for (int v = 0; v < G.getV(); v++)
components[getid(v)].add(v);
return components;
}
};
#endif测试用例：
#include<string>
#include<iostream>
#include<vector>
#include"Graph.h"
#include"Bag.h"
#include"CC.h"
using namespace std;
int main()//cc
{
cout << "输入顶点数和边数：" << endl;
int n, m, s;
cin >> n >> m;
Graph G(n, m);
CC cc(G);
m=cc.getcount();
vector<Bag<int>> components = cc.componentsTo(G);
for (int i = 0; i < m; i++)
{
cout << i << " : ";
for (auto v : components[i])
cout << v << " ";
cout << endl;
}
system("pause");
return 0;
}
5.无环图（基于深度优先搜索）
检测图是不是无环图。
在深度优先探索中当探索子元素的链表时，发现一个已经标记的结点且不是结点本身时，说明图是有环图。
代码：
#ifndef CYCLE_H
#define CYCLE_H
#include<vector>
using std::vector;
#include"Graph.h"
class Cycle
{
private:
vector<bool> marked;
bool hasCycle;//无环图
public:
Cycle(Graph G) :marked(G.getV())
{
for (int s = 0; s < G.getV(); s++)
if (!marked[s])dfs(G, s, s);
}
void dfs(Graph G, int v, int u)//正在探测的元素u的链表
{
marked[v] = true;
for (int w : G.getadj(v))
if (!marked[w])dfs(G, w, v);
else if (w != u)hasCycle = true;//探索到一个已标记的结点，且不是自己
}
bool hasCycleTo(){ return hasCycle; }
};
#endif测试用例：
#include<string>
#include<iostream>
#include<vector>
#include"Graph.h"
#include"Bag.h"
#include"Cycle.h"
using namespace std;
int main()
{
cout << "输入顶点数和边数：" << endl;
int n, m, s;
cin >> n >> m;
Graph G(n, m);
Cycle cy(G);
if (cy.hasCycleTo())cout << "有环图" << endl;
else cout << "无环图" << endl;
system("pause");
}6.二分图（双色问题）
将一幅图用两种颜色一分为二，也就是每一个条边的两个端点的颜色都不同。
在深度优先探索中，用两种颜色依次标记连通的结点，如果一个结点链表中有一个被标记元素且颜色与自己相同，则不是二分图。
代码：
#ifndef TWOCOLOR_H
#define TWOCOLOR_H
#include<vector>
using std::vector;
#include"Graph.h"
class TwoColor
{
private:
vector<bool> marked;
vector<bool> color;//结点的颜色
bool isTwoColor = true;//双色图（默认是）
public:
TwoColor(Graph G) :marked(G.getV()), color(G.getV())
{
for (int s = 0; s < G.getV(); s++)
if (!marked[s])dfs(G, s);
}
void dfs(Graph G, int v)
{
marked[v] = true;
for (int w : G.getadj(v))
if (!marked[w])
{
color[w] = !color[v];
dfs(G, w);
}
else if (color[w] == color[v])isTwoColor = false;//子链接中一个元素被标记，且颜色与自己相同
}
bool isBipartite()
{
return isTwoColor;
}
};
#endif测试用例：
#include<string>
#include<iostream>
#include<vector>
#include"Graph.h"
#include"Bag.h"
#include"TwoColor.h"
using namespace std;
int main()//TwoColor
{
cout << "输入顶点数和边数：" << endl;
int n, m, s;
cin >> n >> m;
Graph G(n, m);
TwoColor cy(G);
if (cy.isBipartite())cout << "双色图" << endl;
else cout << "不是双色图" << endl;
system("pause");
}符号图
在典型应用中，图都是通过文件或者网页定义的，使用的是字符串而非整数来指代顶点。为了适应应用，我们定义了拥有以下性质的输入格式：
1）顶点名为字符串
2）用指定的分隔符来隔开顶点名
3）每一行都表示一组边的集合，每一条边都连接着这一晃的第一个名称表示的顶点和另一个顶点
4）结点总数V和边总数E，除了输入时都是隐式定义的
很显然符号图需要用到符号表，下面是带模板的符号表：
#ifndef ST_H
#define ST_H
#include<string>
#include<vector>
#include"queue.h"
using std::string;
using std::vector;
template<typename key, typename Item>
class ST
{
class Node
{
friend class ST;
key key;
Item data;
Node* next;
public:
template<typename key, typename Item>
Node(key key, Item item, Node* next) :
key(key), data(item), next(next){}
};
private:
Node* first = NULL;
public:
void put(key key, Item item);//插入
Item get(key key);//顺序查找
void delete_1(key key);//删除
bool Empty(){ return first ? 0 : 1; }
int size();//长度
queue<key> keys();//键的集合
bool contains(key key){ return get(key) != NULL; }//键是否存在
};
template<typename key, typename Item>
void ST<key, Item>::put(key key, Item item)//头插法
{
for (Node* x = first; x; x = x->next)
if (key == x->key)
{
x->data = item;
return;
}
first = new Node(key, item, first);
}
template<typename key, typename Item>
Item ST<key, Item>::get(key key)
{
for (Node* x = first; x; x = x->next)
if (key == x->key)return x->data;
return NULL;
}
template<typename key, typename Item>
void ST<key, Item>::delete_1(key key)
{
if (first->key == key)
{
Node* x = first;
first = x->next;
delete x;
return;
}
for (Node* x = first; x->next; x = x->next)
if (key == x->next->key)
{
Node* t = x->next;
x->next = t->next;
delete(t);
return;
}
}
template<typename key, typename Item>
int ST<key, Item>::size()
{
int n = 0;
for (Node* x = first; x; x = x->next)
n++;
return n;
}
template<typename key, typename Item>
queue<key> ST<key,Item>::keys()
{
queue<key> a;
for (Node* x = first; x; x = x->next)
a.enqueue(x->key);
return a;
}
#endif符号图代码：
#ifndef SYMBOLGRAPH_H
#define SYMBOLGRAPH_H
#include<iostream>
using std::cout;
using std::endl;
using std::cin;
#include<string>
using std::string;
#include<vector>
using std::vector;
#include"Graph.h"
#include"ST.h"
class SymbolGraph
{
private:
ST<string, int> st;//符号名->索引
vector<string> keys;//索引->符号名
Graph G;//图
string sy = "-";//间隔符号
public:
SymbolGraph(int V, int E) :G(V)
{
string sp;//读取字符串
for(int i=0;i<V;i++)//第一遍，构建索引
{
cout << "输入第"<<i<<"个符号名：" << endl;
cin >> sp;
if (!st.contains(sp))//符号名唯一
{
st.put(sp, i);//添加符号名->索引
keys.push_back(sp);//添加索引->符号名
}
else i--;
}
string sp1,sp2;
for (int i = 0; i < E; i++)//第二遍，构造图
{
cout << "输入第" << i << "条边的两个顶点：" << endl;
cin >> sp1 >> sp2;
G.addEdge(st.get(sp1), st.get(sp2));
}
}
bool contains(string s){ return st.contains(s); }//检索符号名是否存在
int index(string s){ return st.get(s); }//检索符号名是第几个结点
string name(int v){ return keys[v]; }//检索第v个索引的名称
Graph getG(){ return G; }//输出图
string Sy(){ return sy; }//输出分隔符
};
#endif测试用例：
#include<string>
#include<iostream>
#include<vector>
#include"Graph.h"
#include"BreadthFirstPaths.h"
#include"SymbolGraph.h"
using namespace std;
int main()//SymbolGraph
{
cout << "输入图的结点数和边数:" << endl;
int V, E;
cin >> V >> E;
SymbolGraph sym(V, E);
Graph G = sym.getG();
cout << "输入要查找的结点的符号名：" << endl;
string source;
cin >> source;
int s = sym.index(source);
BreadthFirstPaths bfs(G,s);
cout << "输入你要到达的结点名：" << endl;
string sink;
cin >> sink;
if (sym.contains(sink))
{
int t = sym.index(sink);
cout << source << "->"<<sink << "的最短路径为：" << endl;
if (bfs.hasPathTo(t))
for (int v : bfs.pathTo(t))
if (v == s)cout << sym.name(v);
else cout << sym.Sy() + sym.name(v);
else cout << "Not connected" << endl;
}
else cout << "Not in datebase" ;
cout << endl;
system("pause");
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
