图（Graph）：图是一系列顶点（元素）的集合，这些顶点通过一系列边连接起来组成图这种数据结构。顶点用圆圈表示，边就是这些圆圈之间的连线。顶点之间通过边连接。
图分为有向图和无向图：
●有向图：边不仅连接两个顶点，并且具有方向；
●无向图：边仅仅连接两个顶点，没有其他含义；
地图中的城市我们看做是顶点，高铁线路看做是边；很显然，我们的地图是一种无向图，以长沙到上海为例，经过的城市有长沙、南昌、杭州、上海等地；那么从上海也可以按照原有的路线进行返回；
图的相关术语
相邻顶点
当两个顶点通过一条边相连时，我们称这两个顶点是相邻的，并且称这条边依附于这两个顶点。
度：
某个顶点的度就是依附于该顶点的边的个数
子图：
是一副图的所有边的子集（包含这些边依附的顶点）组成的图；
路径：
是由边顺序连接的一系列顶点组成
环：
是一条至少含有一条边且终点和起点相同的路径
连通图：
如果图中任意一个顶点都存在一条路径到达另外一个顶点，那么这幅图就称之为连通图
连通子图：
一个非连通图由若干连通的组成部分，每一个连通的部分都可以称为该图的连通子图
图的存储结构
要表示一幅图，只需要表示清楚以下两部分内容即可：
-
图中所有的顶点；
-
所有连接顶点的边；
常见的图的存储结构有两种：邻接矩阵和邻接表
邻接矩阵
-
使用一个V*V的二维数组int[V][V] adj,把索引的值看做是顶点；
-
如果顶点v和顶点w相连，我们只需要将adj[v][w]和adj[w][v]的值设置为1,否则设置为0即可。
很明显，邻接矩阵这种存储方式的空间复杂度是V^2的，如果我们处理的问题规模比较大的话，内存空间极有可能不够用。
邻接表
1.使用一个大小为V的数组 Queue[V] adj，把索引看做是顶点；
2.每个索引处adj[v]存储了一个队列，该队列中存储的是所有与该顶点相邻的其他顶点
很明显，邻接表的空间并不是是线性级别的，所以后面我们一直采用邻接表这种存储形式来表示图。
图的实现
public class Graph {
//顶点数目
private 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 Queue<>();
}
}
//获取顶点数目
public int getV() {
return V;
}
//获取边的数目
public int getE() {
return E;
}
//向图中加一条边
public void addEdge(int v,int w){
//就把w添加到v对应的链表中，这样就相当于顶点v就多了一个相邻点w
adj[v].inQueue(w);
//把v添加到w的链表中，这样w就多了一个相邻点v
adj[w].inQueue(v);
//边的数目自增1
E++;
}
//获取和顶点v相邻的所有节点
public Queue<Integer> adj(int v){
return adj[v];
}
}
实现了图这种数据结构之后我们可以在此数据结构上做一些复杂的算法计算，如广度优先搜索算法、深度优先搜索算法等；
深度优先算法（DFS）
- 深度搜索：搜索到一个顶点时，先将此顶点某个子顶点搜索到底部（子顶点的子顶点的子顶点...），然后回到上一级，继续搜索第二个子顶点一直搜索到底部；
很明显，在由于边是没有方向的，所以，如果4和5顶点相连，那么4会出现在5的相邻链表中，5也会出现在4的相 邻链表中，那么为了不对顶点进行重复搜索，应该要有相应的标记来表示当前顶点有没有搜索过，可以使用一个布 尔类型的数组 boolean[V] marked,索引代表顶点，值代表当前顶点是否已经搜索，如果已经搜索，标记为true， 如果没有搜索，标记为false；
public class DepthFirstSearch {
//索引代表顶点，值表示当前顶点是否已经被搜索
private boolean[] marked;
//记录有多少个顶点与s顶点想通
private int count;
//构造深度优先搜索对象，使用深度优先搜索找出G图中s顶点的所有相邻顶点
public DepthFirstSearch(Graph G,int s){
//创建一个和图顶点数量一样大小的布尔数组
marked=new boolean[G.getV()];
//搜索图中的与顶点s相同的所有顶点
dfs(G,s);
}
//深度优先搜索找出图G中v的顶点的所有相邻顶点
private void dfs(Graph G,int v){
//把当前顶点标记为已搜索
marked[v]=true;
//遍历v顶点的邻接表，得到每一个顶点w
for (Integer w : G.adj(v)) {
//如果当前顶点的w没有被搜索过,则递归搜索与w顶点相通的其他顶点
if (!marked[w]){
dfs(G,w);
}
}
//想通的顶点数量+1
count++;
}
//判断w顶点与s顶点是否相通
public boolean marked(int w){
return marked[w];
}
//获取与顶点s相同的所有顶点总数
public int getCount(){
return count;
}
}
广度优先算法（BFS）
- 广度搜索：搜索到一个顶点时，先将此顶点的所有子顶点全部搜索完毕，再进行下一个子顶点的子顶点搜索；
代码实现：
public class BreadthFirstSearch {
//索引代表顶点，值表示当前顶点是否已经被搜索
private boolean[] marked;
//记录有多少个顶点与s顶点相遇
private int count;
//用来存储待搜索邻接表的点
private Queue<Integer> waitSearch;
//构造广度优先搜索对象,使用广度优先搜索找出图G中S顶点的所有相邻顶点
public BreadthFirstSearch(Graph g,int s){
//创建一个和图顶点个数一样大小的布尔数组
marked=new boolean[g.getV()];
//初始化待抖索顶点的队列
waitSearch=new Queue<>();
//搜索G图中与顶点s相同的所有顶点
dfs(g,s);
}
//使用广度优先搜索找出G图中V顶点的所有相邻顶点
private void dfs(Graph g,int v){
for (Integer w : g.adj(v)) {//取得当前顶点的所有子节点
if (!marked[w]){//如果还没被搜索
marked[w]=true; //标记为已经搜索
waitSearch.inQueue(w); //将该顶点的所有子节点进入到待搜索队列中
System.out.println("搜索子节点："+w);
}
}
while (!waitSearch.isEmpty()){
dfs(g,waitSearch.outQueue()); //开始搜索子节点
}
count++; //想通的顶点加一
}
//判断w顶点与s顶点是否相通
public boolean marked(int w){
return marked[w];
}
//获取与顶点s相同的所有顶点总数
public int getCount(){
return count;
}
}
测试类;
public class BreadthTest {
public static void main(String[] args) {
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( 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.getCount();
System.out.println("与起点相通的顶点的数量为：" + count);
boolean marked1 = search.marked( 5);
System.out.println("顶点5和顶点0是否相通：" + marked1);
boolean marked2 = search.marked( 7);
System.out.println("顶点7和顶点0是否相通：" + marked2);
BreadthFirstSearch search2 = new BreadthFirstSearch(G, 9);
BreadthFirstSearch search7 = new BreadthFirstSearch(G, 5);
}
}
路径查找问题
在实际生活中，地图是我们经常使用的一种工具，通常我们会用它进行导航，输入一个出发城市，输入一个目的地 城市，就可以把路线规划好，而在规划好的这个路线上，会路过很多中间的城市。这类问题翻译成专业问题就是： 从s顶点到v顶点是否存在一条路径？如果存在，请找出这条路径。
我们实现路径查找，最基本的操作还是得遍历并搜索图，所以，我们的实现暂且基于深度优先搜索来完成。其搜索 的过程是比较简单的。我们添加了edgeTo[]整型数组，这个整型数组会记录从每个顶点回到起点s的路径。
代码实现
public class RoadSearch {
private boolean[] marked; //索引代表顶点，值表示当前顶点是否已经被搜索
private int start; //起点
private int [] edgeTo;//索引代表顶点，值代表从起点s到当前顶点路径的上一个顶点（也就是最后一个顶点）
public RoadSearch(Graph graph,int s){
marked=new boolean[graph.getV()];//创建一个和顶点数量一样大的布尔数组
this.start=s;
edgeTo=new int[graph.getV()];//创建一个和顶点数量一样多的整形数组
dfs(graph,s);
}
private void dfs(Graph graph,int v){
//标记为已搜索
marked[v]=true;
for (Integer w : graph.adj(v)) { //遍历v的临建表 得到v的所有子节点w
if (!marked[w]){
edgeTo[w]=v; //如果当前w顶点没被搜索过 将该索引位置处edgeTo[w]设置为v 表示w的上一个顶点为v 并递归搜索与w想通的顶点
dfs(graph,w);
}
}
}
public boolean hashPathTo(int v){ //判断v顶点与s是否存在路径
return marked[v];
}
//找出顶点s到顶点v的路径
public Stack pathTo(int v){//找出从起点s到顶点v的路径（就是该路径经过的顶点)
if (!hashPathTo(v)){ //顶点s与顶点v不想通 直接返回false
return null;
}
Stack<Integer> integers = new Stack<>();//创建存储路径的容器
for (int x=v;x!=start;x=edgeTo[x]){
//第一次把当前顶点存进去， 然后下次循环 x就等于当前顶点的上一个顶点 下次循环就会从 上一个顶点开始 以此类推 直到x=start也就是等于起点为止 相当于逆推法
//因为edgeTo[]数组中 每一个索引表示顶点 索引的值表示该顶点的上一个顶点 所以就相当于倒着着
//把当前顶点放入容器
integers.push(x);
}
//最后把起点放入容器
integers.push(start);
return integers;
}
}
代码解析：
路径查找最核心的就是创建一个edgeTo的整型数组，数组的索引值同样表示顶点，关键是值表示的该顶点的上一个顶点，然后通过一个栈来存放顶点s到目标顶点的所有路径顶点。