图--02---图的搜索路径查找
Posted 高高for 循环
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了图--02---图的搜索路径查找相关的知识，希望对你有一定的参考价值。
文章目录
图的搜索
在很多情况下，我们需要遍历图，得到图的一些性质，例如，找出图中与指定的顶点相连的所有顶点，或者判定某个顶点与指定顶点是否相通，是非常常见的需求。
有关图的搜索，最经典的算法有深度优先搜索和广度优先搜索，接下来我们分别讲解这两种搜索算法。
- 深度优先搜索
- 广度优先搜索
深度优先搜索
先找子结点，然后找兄弟结点
- 所谓的深度优先搜索，指的是在搜索时，如果遇到一个结点既有子结点，又有兄弟结点，那么先找子结点，然后找兄弟结点。
很明显，在由于边是没有方向的，所以，如果4和5顶点相连，那么4会出现在5的相邻链表中，5也会出现在4的相邻链表中，那么为了不对顶点进行重复搜索，应该要有相应的标记来表示当前顶点有没有搜索过，可以使用一个布尔类型的数组 boolean[V] marked,索引代表顶点，值代表当前顶点是否已经搜索，如果已经搜索，标记为true，如果没有搜索，标记为false；
API设计：
代码：
图----Graph
package graph;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedDeque;
public class Graph {
//顶点数目
private final int V;
//边的数目
private int E;
//邻接表
private Queue<Integer>[] adj;
public Graph(int V){
//初始化顶点数量
this.V = V;
//初始化边的数量
this.E = 0;
//初始化邻接表
this.adj = new Queue[V];
for (int i = 0; i < adj.length; i++) {
adj[i] = new ConcurrentLinkedDeque<>();
}
}
//获取顶点数目
public int V(){
return V;
}
//获取边的数目
public int E(){
return E;
}
//向图中添加一条边 v-w
public void addEdge(int v, int w) {
//在无向图中，边是没有方向的，所以该边既可以说是从v到w的边，又可以说是从w到v的边，因此，需要让w出现在v的邻接表中，并且还要让v出现在w的邻接表中
adj[v].offer(w);
adj[w].offer(v);
//边的数量+1
E++;
}
//获取和顶点v相邻的所有顶点
public Queue<Integer> adj(int v){
return adj[v];
}
}
深度优先搜索----DepthFirstSearch
package graph;
public class DepthFirstSearch {
//索引代表顶点，值表示当前顶点是否已经被搜索
private boolean[] marked;
//记录有多少个顶点与s顶点相通
private int count;
//构造深度优先搜索对象，使用深度优先搜索找出G图中s顶点的所有相邻顶点
public DepthFirstSearch(Graph G,int s){
//初始化marked数组
this.marked = new boolean[G.V()];
//初始化跟顶点s相通的顶点的数量
this.count=0;
dfs(G,s);
}
//使用深度优先搜索找出G图中v顶点的所有相通顶点
private void dfs(Graph G, int v){
//把v顶点标识为已搜索
marked[v] = true;
for (Integer w : G.adj(v)) {
//判断当前w顶点有没有被搜索过，如果没有被搜索过，则递归调用dfs方法进行深度搜索
if (!marked[w]){
dfs(G,w);
}
}
//相通顶点数量+1
count++;
}
//判断w顶点与s顶点是否相通
public boolean marked(int w){
return marked[w];
}
//获取与顶点s相通的所有顶点的总数
public int count(){
return count;
}
}
测试
public class DepthFirstSearchTest {
public static void main(String[] args) {
//准备Graph对象
Graph G = new Graph(13);
G.addEdge(0,5);
G.addEdge(0,1);
G.addEdge(0,2);
G.addEdge(0,6);
G.addEdge(5,3);
G.addEdge(5,4);
G.addEdge(3,4);
G.addEdge(4,6);
G.addEdge(7,8);
G.addEdge(9,11);
G.addEdge(9,10);
G.addEdge(9,12);
G.addEdge(11,12);
//准备深度优先搜索对象
DepthFirstSearch search = new DepthFirstSearch(G, 0);
//测试与某个顶点相通的顶点数量
int count = search.count();
System.out.println("与起点0相通的顶点的数量为:"+count);
//测试某个顶点与起点是否相同
boolean marked1 = search.marked(5);
System.out.println("顶点5和顶点0是否相通："+marked1);
boolean marked2 = search.marked(7);
System.out.println("顶点7和顶点0是否相通："+marked2);
}
}
广度优先搜索
先找兄弟结点，然后找子结点
- 所谓的深度优先搜索，指的是在搜索时，如果遇到一个结点既有子结点，又有兄弟结点，那么先找兄弟结点，然后找子结点。
API设计：
思路分析：
和 二叉树的层序遍历----广度优先思路一样
树–05—二叉树–02—二叉搜索树(BST)遍历
实现步骤：
- 创建队列，存储每一层的结点；
- 使用循环从队列中弹出一个结点：
- 获取当前结点的key；
- 如果当前结点的左子结点不为空，则把左子结点放入到队列中
- 如果当前结点的右子结点不为空，则把右子结点放入到队列中
创建辅助队列做排序
代码：
package graph;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedDeque;
public class BreadthFirstSearch {
//索引代表顶点，值表示当前顶点是否已经被搜索
private boolean[] marked;
//记录有多少个顶点与s顶点相通
private int count;
//用来存储待搜索邻接表的点
private Queue<Integer> waitSearch;
//构造广度优先搜索对象，使用广度优先搜索找出G图中s顶点的所有相邻顶点
public BreadthFirstSearch(Graph G, int s) {
this.marked = new boolean[G.V()];
this.count=0;
this.waitSearch = new ConcurrentLinkedDeque<Integer>();
bfs(G,s);
}
//使用广度优先搜索找出G图中v顶点的所有相邻顶点
private void bfs(Graph graph, int v){
//把当前顶点v标识为已搜索
marked[v] = true;
//让顶点v进入队列，待搜索
waitSearch.offer(v);
System.out.print("节点"+v+"广度遍历顺序为："+v);
//通过循环，如果队列不为空，则从队列中弹出一个待搜索的顶点进行搜索
while (!waitSearch.isEmpty()){
//弹出一个待搜索的顶点
Integer wait = waitSearch.poll();
//遍历wait顶点的邻接表
for(Integer w: graph.adj(wait)){
// 该顶点还没被搜索过 对其进行搜索
if(!marked(w)){
marked[w] = true;
// 将节点放入堆栈中，用于后续的获取该节点的子节点
waitSearch.offer(w);
//让相通的顶点+1；
count++;
System.out.print( +w);
}
}
}
System.out.println();
}
//判断w顶点与s顶点是否相通
public boolean marked(int w) {
return marked[w];
}
//获取与顶点s相通的所有顶点的总数
public int count() {
return count;
}
}
测试:
package graph;
public class BreadthFirstSearchTest {
public static void main(String[] args) {
//准备Graph对象
Graph G = new Graph(13);
G.addEdge(0,5);
G.addEdge(0,1);
G.addEdge(0,2);
G.addEdge(0,6);
G.addEdge(5,3);
G.addEdge(5,4);
G.addEdge(3,4);
G.addEdge(4,6);
G.addEdge(7,8);
G.addEdge(9,11);
G.addEdge(9,10);
G.addEdge(9,12);
G.addEdge(11,12);
//准备广度优先搜索对象
BreadthFirstSearch search = new BreadthFirstSearch(G, 0);
//测试与某个顶点相通的顶点数量
int count = search.count();
System.out.println("与起点0相通的顶点的数量为:"+count);
//测试某个顶点与起点是否相同
boolean marked1 = search.marked(5);
System.out.println("顶点5和顶点0是否相通："+marked1);
boolean marked2 = search.marked(7);
System.out.println("顶点7和顶点0是否相通："+marked2);
}
}
案例-畅通工程续1
- 某省调查城镇交通状况，得到现有城镇道路统计表，表中列出了每条道路直接连通的城镇。省政府“畅通工程”的目标是使全省任何两个城镇间都可以实现交通（但不一定有直接的道路相连，只要互相间接通过道路可达即可）。目前的道路状况，9号城市和10号城市是否相通？9号城市和8号城市是否相通？
- 在我们的测试数据文件夹中有一个trffic_project.txt文件，它就是诚征道路统计表，下面是对数据的解释：
需求：
- 总共有20个城市，目前已经修改好了7条道路，问9号城市和10号城市是否相通？9号城市和8号城市是否相通？
解题思路：
- 创建一个图Graph对象，表示城市；
- 分别调用addEdge(0,1),addEdge(6,9),addEdge(3,8),addEdge(5,11),addEdge(2,12),addEdge(6,10),addEdge(4,8)，表示已经修建好的道路把对应的城市连接起来；
- 通过Graph对象和顶点9，构建DepthFirstSearch对象或BreadthFirstSearch对象；
- 调用搜索对象的marked(10)方法和marked(8)方法，即可得到9和城市与10号城市以及9号城市与8号城市是否相通。
代码:
package graph;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Traffic_Project_Test2 {
public static void main(String[] args) throws Exception{
//构建一个缓冲读取流BufferedReader
BufferedReader br = new BufferedReader(new InputStreamReader(Traffic_Project_Test2.class.getClassLoader().getResourceAsStream("traffic_project.txt")));
//读取第一行数据20
int totalNumber = Integer.parseInt(br.readLine());
//构建一个Graph对象
Graph G = new Graph(totalNumber);
//读取第二行数据7
int roadNumber = Integer.parseInt(br.readLine());
//循环读取有限次(7)，读取已经修建好的道路
for (int i = 1;i<=roadNumber;i++){
String road = br.readLine();//"0 1"
String[] str = road.split(" ");
int v = Integer.parseInt(str[0]);
int w = Integer.parseInt(str[1]);
//调用图的addEdge方法，把边添加到图中，表示已经修建好的道路
G.addEdge(v,w);
}
//构建一个深度优先搜索对象，起点设置为顶点9
DepthFirstSearch search = new DepthFirstSearch(G, 9);
//调用marked方法，判断8顶点和10顶点是否与起点9相通
System.out.println("顶点8和顶点9是否相通："+search.marked(8));
System.out.println("顶点10和顶点9是否相通："+search.marked(10));
}
}
路径查找
在实际生活中，地图是我们经常使用的一种工具，通常我们会用它进行导航，输入一个出发城市，输入一个目的地城市，就可以把路线规划好，而在规划好的这个路线上，会路过很多中间的城市。这类问题翻译成专业问题就是：
需求:
从s顶点到v顶点是否存在一条路径？如果存在，请找出这条路径。
- 例如在上图上查找顶点0到顶点4的路径用红色标识出来,那么我们可以把该路径表示为 0-2-3-4。
查找API设计
思路分析:
- 我们实现路径查找，最基本的操作还是得遍历并搜索图，所以，我们的实现暂且基于深度优先搜索来完成。其搜索的过程是比较简单的。我们添加了edgeTo[]整型数组，这个整型数组会记录从每个顶点回到起点s的路径。
如果我们把顶点设定为0，那么它的搜索可以表示为下图：
根据最终edgeTo的结果，我们很容易能够找到从起点0到任意顶点的路径；
代码：
DepthFirstPaths
import java.util.Stack;
public class DepthFirstPaths {
//索引代表顶点，值表示当前顶点是否已经被搜索
private boolean[] marked;
//起点
private int s;
//索引代表顶点，值代表从起点s到当前顶点路径上的最后一个顶点
private int[] edgeTo;
//构造深度优先搜索对象，使用深度优先搜索找出G图中起点为s的所有路径
public DepthFirstPaths(Graph G, int s){<以上是关于图--02---图的搜索路径查找的主要内容，如果未能解决你的问题，请参考以下文章
Python 图_系列之纵横对比 Bellman-Ford 和 Dijkstra 最短路径算法