bfs、dfs（图）

1.bfs：广度优先遍历
：广度优先遍历，要借助数据结构中的队列来实现，与树的层次遍历类似。

package bfs;

import java.util.*;

public class bfs {
    public static Map<String,String[]> graph(){//构建地图
        Map<String,String[]> map = new HashMap<>();
        String[] A ={"B","C"};
        String[] B ={"A","C","D"};
        String[] C ={"A","B","D","E"};
        String[] D ={"B","C","E","F"};
        String[] E ={"C","D"};
        String[] F ={"D"};
        map.put("A",A);
        map.put("B",B);
        map.put("C",C);
        map.put("D",D);
        map.put("E",E);
        map.put("F",F);
        return map;
    }

    public static Map<String,String> BFS(Map<String,String[]> map,String s){
        Queue<String> queue = new LinkedList<>();//队列保存要访问的节点
        queue.offer(s);//添加要访问的节点
        HashSet<String> set = new HashSet<>();//set集合用于判断此元素是否已经被使用过了
        set.add(s);//每次添加要访问的结点
        Map<String,String> parent = new HashMap<>();//map集合映射路径顺序
        parent.put(s,null);
        while(queue.size()>0){//当队列中还有节点
            String vertex = queue.poll();//取出节点
            String[] nodes = map.get(vertex);//取出当前节点对应的所有邻接节点
            for (String w:nodes) {//遍历所有邻接点
                if (!set.contains(w)){//没有被使用过
                    queue.offer(w);//添加到队列中
                    set.add(w);//将此节点添加到判断集合set中
                    parent.put(w,vertex);//将节点添加到映射路径中去,如果仅仅是输出，可以用其他集合来代替
                }
            }
            System.out.print(vertex+"  ");
        }
         System.out.println();
        
        String s2 = "E";
        while(s2!=null){
            System.out.print(s2+" ");
            s2 = parent.get(s2);
        }
        
        System.out.println();
        return parent;
    }

    public static void main(String[] args) {
        Map<String,String> map = BFS(graph(),"A");
        System.out.println(map);
    }
}

2.dfs：深度优先遍历
：要借助数据结构中的栈

package dfs;

import java.util.*;

public class dfs {
    public static Map<String,String[]> graph(){//构建地图
        Map<String,String[]> map = new HashMap<>();
        String[] A ={"B","C"};
        String[] B ={"A","C","D"};
        String[] C ={"A","B","D","E"};
        String[] D ={"B","C","E","F"};
        String[] E ={"C","D"};
        String[] F ={"D"};
        map.put("A",A);
        map.put("B",B);
        map.put("C",C);
        map.put("D",D);
        map.put("E",E);
        map.put("F",F);
        return map;
    }

    public static List<String> dfs(Map<String,String[]> map,String s){
        Stack<String> stack = new Stack<>();//保存当前或其相邻节点压栈
        stack.add(s);
        HashSet<String> set = new HashSet<>();//判断是否使用过
        set.add(s);
        List<String> list = new ArrayList<>();
        while(!stack.isEmpty()){//栈不空
            String vertix = stack.pop();//栈顶元素出栈
            String[] nodes = map.get(vertix);//取出所有相邻接点
            for (String s1:nodes) {
                if (!set.contains(s1)){//没有使用过
                    stack.push(s1);//压栈
                    set.add(s1);//放入判断集合set
                }
            }
            list.add(vertix);
        }
        return list;
    }

    public static void main(String[] args) {
        List<String> list = dfs(graph(),"F");
        System.out.println(list);
    }
}