广度优先搜索(Breadth First Search)

广度优先搜索使用队列模型

一、把根节点放到队列的末尾。
二、每次从队列的头部取出一个元素，查看这个元素全部的下一级元素,把它们放到队列的末尾。
并把这个元素记为它下一级元素的前驱。
三、找到所要找的元素时结束程序。
四、若是遍历整个树尚未找到，结束程序。

广度优先搜索使用栈模型

一、把根节点压入栈中。
二、每次从栈中弹出一个元素，搜索全部在它下一级的元素，把这些元素压入栈中。
并把这个元素记为它下一级元素的前驱。
三、找到所要找的元素时结束程序。
四、若是遍历整个树尚未找到，结束程序。

使用栈模型更容易理解,广度优先搜索,不妨思考一下,栈的运行模式.

代码模型

迷宫模型,寻找到达迷宫的最少步数;此代码使用队列模型

广度优先搜索

public class Test {

    public static void main(String[] args) {
        Test t = new Test();

        t.bfs();
    }

    private class Node {

        int x;
        int y;
        int step;

        public Node(int x, int y, int step) {
            this.x = x;
            this.y = y;
            this.step = step;
        }
        @Override
        public String toString() {
            return "Node [x=" + x + ", y=" + y + ", step=" + step + "]";
        }
    }

    int startX = 0;
    int startY = 0;
    int[][] plat = new int[][] { { 0, 0, 1, 0, 0 }, { 0, 0, 1, 0, 1 },
               { 0, 0, 1, 0, 0 }, { 0, 0, 0, 0, 1 } };
    int p = 2;
    int q = 3;
    int[][] next = { { 0, 1 }, { 1, 0 }, { 0, -1 }, { -1, 0 } };
    int[][] book = new int[4][5];
    Queue<Node> queue = new LinkedList<Node>();

    public int bfs() {

        queue.add(new Node(0, 0, 0));


        while (!queue.isEmpty()) {

            Node newNode = queue.poll();
            book[newNode.x][newNode.y] = 1;
            System.out.println(newNode);
            out(book);
            for (int k = 0; k < 4; k++) {
                int x = newNode.x + next[k][0];
                int y = newNode.y + next[k][1];

                if (x == p && y == q) {
                    System.out.println("至少须要" + (newNode.step + 1));
                    return newNode.step + 1;
                }

                if (x >= 0 && x <= plat.length - 1 && y >= 0 && y <= plat[0].length - 1 && plat[x][y] == 0
                        && book[x][y] == 0) {
                    queue.add(new Node(x, y, newNode.step + 1));
                }

            }

        }
        return -1;
    }

    public void out(int[][] a) {

        for (int[] is : a) {
            for (int i : is) {
                System.out.print(i + " ");
            }
            System.out.println();
        }
        System.out.println();
    }
}

快速理解

队列出队进队.进入[x=0, y=1] step=1,这是从0,0到达0,1的最小步数
一样到达 [x=1, y=1], step=2
达到目标点[x=2, y=3], step=7

代码输出图

Node [x=0, y=0, step=0]
1 0 0 0 0 
0 0 0 0 0 
0 0 0 0 0 
0 0 0 0 0 

Node [x=0, y=1, step=1]
1 1 0 0 0 
0 0 0 0 0 
0 0 0 0 0 
0 0 0 0 0 

Node [x=1, y=0, step=1]
1 1 0 0 0 
1 0 0 0 0 
0 0 0 0 0 
0 0 0 0 0 

Node [x=1, y=1, step=2]
1 1 0 0 0 
1 1 0 0 0 
0 0 0 0 0 
0 0 0 0 0 

Node [x=1, y=1, step=2]
1 1 0 0 0 
1 1 0 0 0 
0 0 0 0 0 
0 0 0 0 0 

Node [x=2, y=1, step=3]
1 1 0 0 0 
1 1 0 0 0 
0 1 0 0 0 
0 0 0 0 0 

Node [x=2, y=1, step=3]
1 1 0 0 0 
1 1 0 0 0 
0 1 0 0 0 
0 0 0 0 0 

Node [x=3, y=1, step=4]
1 1 0 0 0 
1 1 0 0 0 
0 1 0 0 0 
0 1 0 0 0 

Node [x=3, y=1, step=4]
1 1 0 0 0 
1 1 0 0 0 
0 1 0 0 0 
0 1 0 0 0 

Node [x=3, y=2, step=5]
1 1 0 0 0 
1 1 0 0 0 
0 1 0 0 0 
0 1 1 0 0 

Node [x=3, y=0, step=5]
1 1 0 0 0 
1 1 0 0 0 
0 1 0 0 0 
1 1 1 0 0 

Node [x=3, y=2, step=5]
1 1 0 0 0 
1 1 0 0 0 
0 1 0 0 0 
1 1 1 0 0 

Node [x=3, y=0, step=5]
1 1 0 0 0 
1 1 0 0 0 
0 1 0 0 0 
1 1 1 0 0 

Node [x=3, y=3, step=6]
1 1 0 0 0 
1 1 0 0 0 
0 1 0 0 0 
1 1 1 1 0 

至少须要7