[Java]Java实现二叉树和图的DFS、BFS

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