图的深度优先和广度优先遍历及两点间最优路径实现

通用遍历

参考：https://segmentfault.com/a/1190000002685939

遍历
图的遍历，所谓遍历，即是对结点的访问。一个图有那么多个结点，如何遍历这些结点，需要特定策略，一般有两种访问策略：

深度优先遍历
广度优先遍历
深度优先
深度优先遍历，从初始访问结点出发，我们知道初始访问结点可能有多个邻接结点，深度优先遍历的策略就是首先访问第一个邻接结点，然后再以这个被访问的邻接结点作为初始结点，访问它的第一个邻接结点。总结起来可以这样说：每次都在访问完当前结点后首先访问当前结点的第一个邻接结点。


我们从这里可以看到，这样的访问策略是优先往纵向挖掘深入，而不是对一个结点的所有邻接结点进行横向访问。


具体算法表述如下：


访问初始结点v，并标记结点v为已访问。
查找结点v的第一个邻接结点w。
若w存在，则继续执行4，否则算法结束。
若w未被访问，对w进行深度优先遍历递归（即把w当做另一个v，然后进行步骤123）。
查找结点v的w邻接结点的下一个邻接结点，转到步骤3。
例如下图，其深度优先遍历顺序为 1->2->4->8->5->3->6->7

广度优先
类似于一个分层搜索的过程，广度优先遍历需要使用一个队列以保持访问过的结点的顺序，以便按这个顺序来访问这些结点的邻接结点。


具体算法表述如下：


访问初始结点v并标记结点v为已访问。
结点v入队列
当队列非空时，继续执行，否则算法结束。
出队列，取得队头结点u。
查找结点u的第一个邻接结点w。
若结点u的邻接结点w不存在，则转到步骤3；否则循环执行以下三个步骤：
1). 若结点w尚未被访问，则访问结点w并标记为已访问。
2). 结点w入队列
3). 查找结点u的继w邻接结点后的下一个邻接结点w，转到步骤6。
如上图，其广度优先算法的遍历顺序为：1->2->3->4->5->6->7->8

Java实现 GraphSearchImpl.java类

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;


public class GraphSearchImpl
{
private List<Integer> nodeList;// 存储点的链表
private boolean[] visited; // 是否遍历标识
private int[][] edges;// 邻接矩阵，用来存储边
private int edgeNum;// 边的数目
private int nodeNum;


public GraphSearchImpl(int n)
{
// 初始化矩阵，一维数组，和边的数目
edges = new int[n][n];
nodeList = new ArrayList<Integer>(n);
visited = new boolean[n];
edgeNum = 0;
nodeNum = n;
initVisited();
}

// 返回v1,v2的权值
public int getWeight(int v1, int v2)
{
return edges[v1][v2];
}

// 插入结点
public void insertNodeData(Integer nodeId)
{
nodeList.add(nodeList.size(), nodeId);
}


// 插入结点
public void insertEdge(int v1, int v2, int weight)
{
edges[v1][v2] = weight;
edgeNum++;
}

// 删除结点
public void deleteEdge(int v1, int v2)
{
edges[v1][v2] = 0;
edgeNum--;
}


// 对外公开函数，深度优先遍历，与其同名私有函数属于方法重载
public void depthFirstSearch()
{
for (int i = 0; i < nodeNum; i++)
{
// 因为对于非连通图来说，并不是通过一个结点就一定可以遍历所有结点的。
if (!visited[i])
{
depthFirstSearch(visited, i);
}
}
}

// 对外公开函数，广度优先遍历
public void broadFirstSearch()
{
for (int i = 0; i < nodeNum; i++)
{
if (!visited[i])
{
broadFirstSearch(visited, i);
}
}
}


public void initVisited()
{
int len = visited.length;
for (int i = 0; i < len; i++)
{
visited[i] = false;
}
}

// 私有函数，深度优先遍历
private void depthFirstSearch(boolean[] isVisited, int i)
{
// 首先访问该结点，在控制台打印出来
System.out.print(getNodeId(i) + "  ");
// 置该结点为已访问
isVisited[i] = true;


int w = getFirstNeighbor(i);
while (w != -1)
{
if (!isVisited[w])
{
depthFirstSearch(isVisited, w);
}
w = getNextNeighbor(i, w);
}
}


// 私有函数，广度优先遍历
private void broadFirstSearch(boolean[] isVisited, int i)
{
int u, w;
LinkedList<Integer> queue = new LinkedList<Integer>();


// 访问结点i
System.out.print(getNodeId(i) + "  ");
isVisited[i] = true;
// 结点入队列
queue.addLast(i);
while (!queue.isEmpty())
{
u = ((Integer) queue.removeFirst()).intValue();
w = getFirstNeighbor(u);
while (w != -1)
{
if (!isVisited[w])
{
// 访问该结点
System.out.print(getNodeId(w) + "  ");
// 标记已被访问
isVisited[w] = true;
// 入队列
queue.addLast(w);
}
<