BFS&&DFS

代码来源于https://www.jianshu.com/p/2d6812a7b868

广度优先搜索：队列的过程

深度优先搜索：栈的过程

广度搜索

这个图 遍历为 ABCDEF  （E和D的位置不能颠倒，因为要先把B相邻的所有节点都遍历完才能去遍历与c相邻的所有节点）

核心思想：BFS一层一层的来  先放一个节点，然后放他的临近节点，再拿出队列里第一个节点，再拿出第一个节点的同时，把这个节点的临近节点同时放进去，，依次进行

步骤

首先需要一个字典来把图存起来：存的方式是key为节点，value为邻接节点；

主函数BFS要带两个参数，第一个是图，第二个是要把哪个节点作为起始节点（start）；

要有一个队列，用LinkedList来实现，因为他具有双向链表的功能。存放现在看到的所有顺序 queue，添加为append 弹出为pop

queue先把初始节点添加上，queue.append（start）

然后 当前节点为vertex   nodes为当前节点所对应的所有邻接节点

遍历所有nodes，把尚未添加进队列的节点放入queue

那么 如何保证这个nodes尚未进去呢？这里用hash表来查找会比较快也就是set()

最后 打印出当前节点就可以啦 也就是vertex

import java.util.HashMap;
import java.util.LinkedList;
import java.util.Queue;


class Main {
    public static void main(String[] args) {
        //构造各顶点
        LinkedList<Character> list_s = new LinkedList<>(); //
        list_s.add('w');
        list_s.add('r');
        LinkedList<Character> list_w = new LinkedList<Character>();
        list_w.add('s');
        list_w.add('i');
        list_w.add('x');
        LinkedList<Character> list_r = new LinkedList<Character>();
        list_r.add('s');
        list_r.add('v');
        LinkedList<Character> list_x = new LinkedList<Character>();
        list_x.add('w');
        list_x.add('i');
        list_x.add('u');
        list_x.add('y');
        LinkedList<Character> list_v = new LinkedList<Character>();
        list_v.add('r');
        LinkedList<Character> list_i = new LinkedList<Character>();
        list_i.add('u');
        list_i.add('x');
        list_i.add('w');
        LinkedList<Character> list_u = new LinkedList<Character>();
        list_u.add('i');
        list_u.add('x');
        list_u.add('y');
        LinkedList<Character> list_y = new LinkedList<Character>();
        list_y.add('u');
        list_y.add('x');

        //构造图
        HashMap<Character, LinkedList<Character>> graph = new HashMap<Character, LinkedList<Character>>();
        graph.put('s', list_s);
        graph.put('w', list_w);
        graph.put('r', list_r);
        graph.put('x', list_x);
        graph.put('v', list_v);
        graph.put('i', list_i);
        graph.put('y', list_y);
        graph.put('u', list_u);

        //记录每个点到起始点的距离，即最短距离
        HashMap<Character, Integer> dist = new HashMap<Character, Integer>();
        //遍历的起始点
        char start = 's';
        //调用广度优先方法
        bfs(graph, dist, start);//传入图，最短距离，还有首节点

    }
    private static void bfs(HashMap<Character, LinkedList<Character>> graph,HashMap<Character, Integer> dist,char start){
        Queue<Character> q = new LinkedList<>(); //队列
        q.add(start);// 将s作为起始顶点加入队列
        dist.put(start,0); //map.put方法 意思是添加一个键值对 第一个参数是key，第二个参数是value
        int i=0;
        while(!q.isEmpty()){
            char top = q.poll();   //map .pop方法相当于get的操作，就是只是查看。 .poll相当于先get然后再remove掉，就是查看的同时，也将这个元素从容器中删除掉。
                                    // 这里是直接取出队首元素
            i++;
            System.out.println("The "+ i +"th element :"+top+"distance from s is "+dist.get(top));
            int d = dist.get(top) + 1;// 得出其周边还未被访问的节点的距离
            for (Character c : graph.get(top)) {
                if (!dist.containsKey(c))// 如果dist中还没有该元素说明还没有被访问
                {
                    dist.put(c, d);
                    q.add(c);
                }
            }

        }

    }

}

深度搜索

核心思想：把上面的队列变成栈就可以啦

嗯，，代码待续。。。。