Java实现深度优先搜索DFS和广度优先搜索BFS
一、二叉树
概念定义：
深度优先遍历：深度优先遍历是图论中的经典算法。其利用了深度优先搜索算法可以产生目标图的相应拓扑排序表，采用拓扑排序表可以解决很多相关的图论问题，如最大路径问题等等。
根据深度优先遍历的特点我们利用Java集合类的栈Stack先进后出的特点来实现。我用二叉树来进行深度优先搜索。
深度优先搜索的步骤为：
（1）、首先节点 1 进栈，节点1在栈顶；
（2）、然后节点1出栈，访问节点1，节点1的孩子节点3进栈，节点2进栈；
（3）、节点2在栈顶，然后节点2出栈，访问节点2
（4）、节点2的孩子节点5进栈，节点4进栈
（5）、节点4在栈顶，节点4出栈，访问节点4，
（6）、节点4左右孩子为空，然后节点5在栈顶，节点5出栈，访问节点5；
（7）、节点5左右孩子为空，然后节点3在站顶，节点3出栈，访问节点3；
（8）、节点3的孩子节点7进栈，节点6进栈
（9）、节点6在栈顶，节点6出栈，访问节点6；
（10）、节点6的孩子为空，这个时候节点7在栈顶，节点7出栈，访问节点7
（11）、节点7的左右孩子为空，此时栈为空，遍历结束。
广度优先遍历：广度优先遍历是连通图的一种遍历策略，因为它的思想是从一个顶点V0开始，辐射状地优先遍历其周围较广的区域故得名。
根据广度优先遍历的特点我们利用Java数据结构队列Queue来实现。
广度优先搜索的步骤为：
（1）、节点1进队，节点1出队，访问节点1
（2）、节点1的孩子节点2进队，节点3进队。
（3）、节点2出队，访问节点2，节点2的孩子节点4进队，节点5进队；
（4）、节点3出队，访问节点3，节点3的孩子节点6进队，节点7进队；
（5）、节点4出队，访问节点4，节点4没有孩子节点。
（6）、节点5出队，访问节点5，节点5没有孩子节点。
（7）、节点6出队，访问节点6，节点6没有孩子节点。
（8）、节点7出队，访问节点7，节点7没有孩子节点，结束。
代码：
import java.util.*;
/**
* <h3>java</h3>
* <p>树的广度优先搜索和深度优先搜索</p>
*
* @author : sugar without coffee
* @date : 2020-03-29 12:17
**/
public class Main1 {
public static class TreeNode {
String val;
TreeNode left;
TreeNode right;
TreeNode(String x) {
val = x;
}
}
/**
* 根据List创建二叉树
* 根据二叉树的性质:
* 将一个完全二叉树按照从上到下，从左到右进行编号，对树的编号为1~n,其编号为i的节点:
* 如果满足2*i<=n,则说明编号为i的节点有左孩子，否则没有;
* 如果满足2*i+1<=n,则说明编号为i的节点有右孩子，否则没有;
* 上述理论对于数组编号1~n来说同样成立:
* 2*i<=n; 2*i+1<=n;
* 同理：如果数组的下标是从0到n-1，则将对应下标减1(下面函数实现从0开始)
*/
public static TreeNode createTree(List<String> lists){
List<TreeNode> nodeList = new ArrayList<>();
if(lists.size()==1){
return new TreeNode(lists.get(0));
}
for(int i=0;i<lists.size();i++){
nodeList.add(new TreeNode(lists.get(i)));
}
for(int i=1;i<=lists.size()/2;i++) {
if(2*i-1<=lists.size()-1){
nodeList.get(i-1).left = nodeList.get(2*i-1);
}
if(2*i<=lists.size()-1){
nodeList.get(i-1).right = nodeList.get(2*i);
}
}
return nodeList.get(0);
}
/**
* 广度优先遍历是使用队列实现的
* */
public static void BroadFirstSearch(TreeNode nodeHead) {
if(nodeHead==null) {
return;
}
Queue<TreeNode> myQueue=new LinkedList<>();
myQueue.add(nodeHead);
while(!myQueue.isEmpty()) {
TreeNode node=myQueue.poll();
System.out.print(node.val+" ");
if(null!=node.left) {
//深度优先遍历，我们在这里采用每一行从左到右遍历
myQueue.add(node.left);
}
if(null!=node.right) {
myQueue.add(node.right);
}
}
}
/**
* 深度优先遍历
* */
public static void depthFirstSearch(TreeNode nodeHead) {
if(nodeHead==null) {
return;
}
Stack<TreeNode> myStack=new Stack<>();
myStack.add(nodeHead);
while(!myStack.isEmpty()) {
//弹出栈顶元素
TreeNode node=myStack.pop();
System.out.print(node.val+" ");
if(node.right!=null) {
//深度优先遍历，先遍历左边，后遍历右边,栈先进后出
myStack.push(node.right);
}
if(node.left!=null) {
myStack.push(node.left);
}
}
}
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("1");
list.add("2");
list.add("3");
list.add("4");
list.add("5");
list.add("6");
list.add("7");
TreeNode treeNode = createTree(list);
// 广度优先搜索
BroadFirstSearch(treeNode);
System.out.println();
// 深度优先搜索
depthFirstSearch(treeNode);
}
}二、图
1、使用队列Queue实现图的BFS遍历
2、递归实现图的DFS遍历
3、使用栈Stack迭代实现图的DFS遍历
一、BFS（广度优先搜索算法）
BFS算法之所以叫做广度优先搜索，是因为它始终将已发现的顶点和未发现的之间的边界，沿其广度方向向外扩展。亦即，算法首先会发现和s距离为k的所有顶点，然后才会发现和s距离为k+1的其他顶点。
同深度优先搜索相反，BFS宽度优先搜索每次选择深度最浅的节点优先扩展。并且当问题有解时，宽度优先算法一定能够找到解，并且在单位耗散时间的情况下，可以保证找到最优解。
二、DFS（深度优先搜索算法）
DFS算法利用递归方式实现，和BFS不同的是BFS搜索产生的始终是一棵树，而DFS产生的可能会使一个森林。
对于深度优先搜索算法的思想。在一般情况下，当问题有解时，深度优先搜索不但不能够保证找到最优解，也不能保证找到解。如果问题状态空间有限，则可以保证找到解；但是当问题的状态空间无限时，则可能陷入“深渊”而找不到解。为此我们可以利用回溯算法中的思想，可以加上对搜索的深度限制。从而实现对于搜索深度的限制。当然深度限制设置必须合理，深度过深则影响搜索的效率，深度过浅时，则可能影响找到问题的解。
使用栈实现DFS思路关键点：
1、首先明确整个DFS主要便是对于栈进行操作，就是在顶点压栈和弹栈过程中我们需要进行的操作；
2、利用DFS的思想，深度遍历节点。直到栈内元素为空位置；
3、何时进行压栈：对于栈顶顶点，看其邻接顶点中是够存在未被遍历过得白色顶点，若有则对将其压栈，然后再对栈顶元素进行操作；
4、如果栈顶顶点的所有邻接顶点都是被遍历过的灰色顶点，则将栈顶元素弹栈，然后再对现在的栈顶元素进行操作；
5、算法结束时，所有元素均被遍历过即为灰色，并且栈已经为空。
代码：https://gitee.com/hbuzzs/JavaAlgorithm/tree/master/src/GraphDFSBFS
