广度优先搜索让你能够找出两样东西之间的最短距离，不过最短距离的含义有很多！使用广 度优先搜索可以：
（1）编写国际跳棋AI，计算最少走多少步就可获胜；
（2）编写拼写检查器，计算最少编辑多少个地方就可将错拼的单词改成正确的单词，如将READED改为READER需要编辑一个地方；
（3）根据你的人际关系网络找到关系最近的医生（几度好友问题）
（4）走迷宫问题(最短距离问题)
(5) 二叉树层次遍历
广度优先搜索，找出的是段数最少的路径(段数最少)
public class Node {
public String value;
public List<Node> nodes = new ArrayList<>();
}
public static void main(String[] args) {
Node nodeA = new Node();
Node nodeB = new Node();
Node nodeC = new Node();
Node nodeD = new Node();
Node nodeE = new Node();
nodeA.value = "A";
nodeA.nodes.add(nodeB);
nodeB.value = "B";
nodeB.nodes.add(nodeC);
nodeB.nodes.add(nodeD);
nodeC.value = "C";
nodeC.nodes.add(nodeB);
nodeC.nodes.add(nodeD);
nodeD.value = "D";
nodeD.nodes.add(nodeB);
nodeD.nodes.add(nodeC);
nodeD.nodes.add(nodeE);
nodeE.value = "E";
nodeE.nodes.add(nodeD);
int step = breadthFirstSearch(nodeA, "A");
System.out.println("-- step: " + step);
}
public static int breadthFirstSearch(Node startNode, String endValue) {
int step = 0;
HashSet<Node> set = new HashSet<>(); // 避免重复 环图
Queue<Node> queue = new LinkedList();
queue.add(startNode);
while (!queue.isEmpty()) {
int queueSize = queue.size();
for (int i = 0; i < queueSize; i++) {
startNode = queue.poll();
if (endValue.equals(startNode.value)) {
return step;
}
if (!set.contains(startNode)) {
set.add(startNode);
if (!startNode.nodes.isEmpty()) {
queue.addAll(startNode.nodes);
}
}
}
step++;
}
return step;
}
二叉树层次遍历
// 树得广度优先搜索 应用-广度优先搜索
public void levelOrder(TreeNode root) {
Queue<TreeNode> queue = new LinkedList<>();
queue.add(root);
List<List<Integer>> resultList = new ArrayList<>();
while (!queue.isEmpty()) {
List<Integer> list = new ArrayList<>();
int queueSize = queue.size();
for (int i = 0; i < queueSize; i++) {
TreeNode node = queue.poll();
list.add(node.val);
if (node != null) {
if (node.left != null)
queue.add(node.left);
if (node.right != null)
queue.add(node.right);
}
}
resultList.add(list);
}
for (int i = 0; i < resultList.size(); i++) {
System.out.println(resultList.get(i).toString());
}
}
待完善问题
如果你要找出最快的路径,可使用——狄克斯特拉算法（迷宫问题） 不能含有负权边
是否需要将 图转换成二维数组 进行处理。。
—贝尔曼-福德算法 处理负权边
