数据结构之--图

• 在计算机科学中，一个图就是一些顶点的集合，这些顶点通过一系列边 结对（连接）。顶点用圆圈表示，边就是这些圆圈之间的连线
• 顶点有时也被称为节点或者交点，边有时也称为链接
• 边可以是单向的，也可以是双向的
• 如果图中存在单向边，我们就称之为有向图
  
  广度优先搜索
• 广度优先搜索，又称宽度优先搜索，是一种用于在树结构或图结构中遍 历搜索的算法。简单的说，BFS是从图中的任意节点（或树中的根节点）
  开始，探索确定当前深度所有节点的邻居节点，接着进入下一深度探索。 如果所有节点均被访问，则算法中止。

public boolean findWhetherExistsPath(int n, int[][] graph, int start, int target) {
        ArrayList<ArrayList<Integer>> adj = new ArrayList<>();
        for(int i =0;i<n;i++){
            adj.add(new ArrayList<>());
        }

        for(int i=0;i<graph.length;i++){
            adj.get(graph[i][0]).add(graph[i][1]);
        }
         Queue<Integer> queue = new LinkedList<>();
         boolean[] valied = new boolean[n];
        queue.add(start);
        while (!queue.isEmpty()){
            Integer cur = queue.poll();
            ArrayList<Integer> integers = adj.get(cur);
            int size = integers.size();
            for(int i =0;i<size;i++){
                Integer integer = integers.get(i);

                if(!valied[integer]){
                    valied[integer]=true;
                    if(integer==target){
                        return true;
                    }
                    queue.add(integer);
                }

            }

        }
        return false;
    }

深度优先搜索

• DFS则会尽可能深的搜索分支，只要当前节点有邻居未被访问，就继续 深入搜索；若当前节点的所在边都己被探寻过，搜索将回溯到发现当前
  节点那条边的起始节点。这一过程一直进行到已发现从源节点可达的所 有节点为止。如果还存在未被发现的节点，则选择其中一个作为源节点
  并重复以上过程，直到所有节点都被访问为止。

  ArrayList<ArrayList<Integer>> adj = new ArrayList<>();
    public boolean findWhetherExistsPath(int n, int[][] graph, int start, int target) {

        for(int i =0;i<n;i++){
            adj.add(new ArrayList<>());
        }

        for(int i=0;i<graph.length;i++){
            adj.get(graph[i][0]).add(graph[i][1]);
        }

         boolean[] valied = new boolean[n];
         valied[start]=true;
        return findWhetherExistsPath_ds(n,valied,start,target);
    }

    public boolean findWhetherExistsPath_ds(int n, boolean[] valied, int start, int target) {
         if(start==target){
             return true;
         }
         for(int i =0; i<adj.get(start).size();i++){
             Integer integer = adj.get(start).get(i);
             if(!valied[integer]) {
                 valied[integer]=true;
                boolean result =  findWhetherExistsPath_ds(n, valied, integer, target);
                if(result){
                    return true;
                }
             }
         }
         return false;
    }