深度优先与广度优先算法

一、算法核心

深度优先搜索和广度优先搜索，都是图形搜索算法，它两相似，又却不同，在应用上也被用到不同的地方。

1）深度优先搜索

深度优先搜索属于图算法的一种，是一个针对图和树的遍历算法，英文缩写为DFS即Depth First Search。一般用堆数据结构来辅助实现DFS算法。其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次。

2）广度优先搜索

广度优先搜索（也称宽度优先搜索，缩写BFS，以下采用广度来描述）是连通图的一种遍历算法。它的思想是从一个顶点V0开始，辐射状地优先遍历其周围较广的区域。根据广度优先遍历的特点我们利用Java数据结构队列Queue来实现。

3）以二叉树遍历对比

深度优先搜索的步骤为：

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的左右孩子为空，此时栈为空，遍历结束。

广度优先搜索的步骤为：

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没有孩子节点，结束。

二、代码

1）创建二叉树结构

/**
 * 二叉树数据结构
 */
public class TreeNode {
    int data;
    TreeNode leftNode;
    TreeNode rightNode;
    public TreeNode() {
    }
    public TreeNode(int d) {
        data=d;
    }
    public TreeNode(TreeNode left,TreeNode right,int d) {
        leftNode=left;
        rightNode=right;
        data=d;
    }
}

2）深度优先遍历

    //深度优先遍历使用栈实现
    public 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.data+" ");
            if(node.rightNode!=null) {
                myStack.push(node.rightNode);    //深度优先遍历，先遍历左边，后遍历右边,栈先进后出
            }
            if(node.leftNode!=null) {
                myStack.push(node.leftNode);
            }
        }
    }

3）广度优先遍历

  //广度优先遍历是使用队列实现的
    public 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.data+" ");
            if(null!=node.leftNode) {
                myQueue.add(node.leftNode);    //这里采用每一行从左到右遍历
            }
            if(null!=node.rightNode) {
                myQueue.add(node.rightNode);
            }

        }
    }