广度优先算法

广度优先算法核心思想

需求： 以上是一张图，求1号节点到5号节点最少需要经过几个节点。

节点之间有边则可以走，如果没有则不能，例如：从1号节点可以到2号节点。从1号节点不能直接到4号节点

分析：
首先我们从1号顶点开始出发，访问其可以到达的顶点2，将其入队，接着访问其可以到达的顶点3，将其入队。此时1号顶点已经没有可以到达的未访问过的节点，接着我们就从2号顶点开始访问其未访问过的顶点，以此类推，直到队列中出现最后的顶点（4号顶点），此时遍历结束。

总结： 广度优先算法的核心思想就是：从一个未被访问过的顶点开始，访问该顶点所有相邻的顶点，然后对每个相邻的顶点再访问他们相邻的未被访问的顶点，直到所有的顶点都被访问过，遍历结束。

代码实现：

---

int[][] arrs = new int[5][5];
int end = 4; //设置最终要到达的元素
int head = 0;
int tail = 1;
int[] que = new int[25];
int[] book = new int[5];
boolean flag = false;

private void initArrs() {
    for (int i = 0; i <= 4; i++) {
        for (int j = 0; j <= 4; j++) {
            arrs[i][j] = 0;
        }
    }

    arrs[0][1] = 1;
    arrs[0][2] = 1;

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

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

    arrs[3][1] = 1;
    arrs[3][2] = 1;
    arrs[3][4] = 1;

    arrs[4][2] = 1;
    arrs[4][3] = 1;
}

private void wfs() {
    while (head < tail && tail <= end) {
        for (int i = 0; i <= 4; i++) {
            if (arrs[head][i] == 1 && book[i] == 0) {
                que[tail++] = i;
                book[i] = 1;
            }

            if (tail > end) {
                flag = true;
                break;
            }
        }

        if (flag) {
            break;
        }

        head++;
    }
}

@Test
public void testWidthSearch() {
    initArrs();

    for (int i = 0; i <= 4; i++) {
        for (int j = 0; j <= 4; j++) {
            System.out.print(arrs[i][j] + "    ");
        }
        System.out.println();
    }

    book[0] = 1;
    que[0] = 0;
    wfs();

    for (int i = 0; i <= 4; i++) {
        System.out.println(que[i]);
    }

    System.out.println(head);
}