DFS & BFS

一.简介

DFS(Depth First Search)：

深度优先搜索算法核心思想是递归处理每一个可能的分支路径深入到不能再深入为止

BFS(Breadth First Search)：

宽度优先搜索算法采用队列记录当前节点下可能的节点，不断循环从队列取出节点再入队取出节点下可能的节点

二.实现

package com.vincent;


import java.util.Deque;
import java.util.LinkedList;

public class Main {
    public static void main(String[] args) throws Exception {
        int[][] data = new int[5][5];
        data[0][1] = 1;
        data[0][2] = 1;
        data[0][3] = 1;

        data[1][0] = 1;

        data[2][0] = 1;
        data[2][3] = 1;
        data[2][4] = 1;

        data[3][0] = 1;
        data[3][2] = 1;

        data[4][2] = 1;

        //记录访问过的节点索引
        int[] book = new int[5];

        dfs(data,book,4,2);
        System.out.println();

        for(int j=0;j<book.length;j++){
            book[j] = 0;
        }

        bfs(data,book,4,2);
    }

    /**
     * 深度优先搜索
     * @param data
     * @param book
     * @param row       开始搜索行索引
     * @param col       开始搜索列索引
     */
    public static void dfs(int[][] data,int[] book,int row,int col){
        book[row] = 1;
        System.out.printf("%d\t",row);
        for(int i=0;i<data[row].length;i++){
            if(data[row][i] == 1 && book[i] == 0){
                dfs(data,book,i,0);
            }
        }
    }

    public static void bfs(int[][] data,int[] book,int row,int col){
        Deque<Integer> queue = new LinkedList<>();
        queue.addLast(row);

        while(queue.size() > 0){
            Integer item = queue.removeFirst();
            if(book[item] == 1){
                continue;
            }
            for(int i=0;i<data[item].length;i++){
                if(data[item][i] == 1 && book[i] == 0){
                    queue.addLast(i);
                }
            }
            book[item] = 1;
            System.out.printf("%d\t",item);
        }
        System.out.println();
    }
}

效果：

三.总结

1.DFS依赖递归，递归深度受内存栈大小制约

2.BFS依赖队列存放当前节点下可能的节点