图

图

1 定义

图是由n个顶点和x条边组成的图像。

List<List<Integer>> nodeAndEdges = new ArrayList<List<Integer>>();
java 可以用嵌套list来表述，外层list的序号表示顶点，它关联的内存list表示到其它顶点的边；
eg: <0,<1,2,3>>顶点0，和顶点1、2、3相链接。

ps：这里图的表示方法采用的邻接表，还存在邻接矩阵、星型图。

2 遍历方式

2.1 深度遍历

这里没考虑

List<List<Integer>> nodeAndEdges = new ArrayList<List<Integer>>();
int[] visited = new int[nodeAndEdges.size()];
for（int i = 0; i<nodeAndEdges.size();i++){
	if(visited[i] == 0){
		dfs(i);	
	}
}

public void dfs(int i){
	visited[i] = 1;
	syso(i);
    for(int j = 0; j<nodeAndEdges.get(i).size();j++){
    	if(visited[nodeAndEdges.get(i).get(j)] == 0)
        	dfs(nodeAndEdges.get(i).get(j));
    }
}

2.2 广度遍历

List<List<Integer>> nodeAndEdges = new ArrayList<List<Integer>>();
int[] visited = new int[nodeAndEdges.size()];
Queue list = new LinkedList();
list.add(nodeAndEdges.get(0));
visited[0] = 1;
while( list.size()!= 0){
	syso(顶点值);
	List<Integer> val = list.removeFirst();
	for(int v:val){
		if(visited[v] == 0)
			list.add(nodeAndEdges.get(v));
			visited[v] = 1；
	}
}

3 leedcode原题

207 课程表

思路：利用三个状态， 0 ：表示顶点未遍历 ；1 顶点遍历中； 2顶点遍历完成；如果在深度遍历一个顶点的过程中发现其边上的顶点处于1状态，那么就证明存在环路，也就说存在相互依赖。（让我先到了spring的循环依赖，利用三级缓存解决）。

class Solution {
    //记录顶点和边的集合
    List<List<Integer>> edges;
    //记录是否访问顶点的集合
    int[] visited;
    //表示是否存在环
    boolean valied = true;

    public boolean canFinish(int numCourses, int[][] prerequisites) {
        edges = new ArrayList<List<Integer>>();
        visited = new int[numCourses];
        for(int i = 0; i<numCourses;i++){
            edges.add(new ArrayList<Integer>());
        }
        //初始化每个顶点的边
        for(int[] val:prerequisites){
            edges.get(val[1]).add(val[0]);
        }
        //深度遍历
        for(int i =0; i<numCourses && valied;i++){
            if(visited[i]==0)
            {dfs(i);}
        }
        return valied;

    }
    public void dfs(int i){
        //前序，标记该节点为正在遍历的节点
        visited[i] = 1;
        //遍历该节点的边
        for(int val : edges.get(i)){
            //只遍历没访问过的
            if(visited[val] == 0){
                dfs(val);
                //剪枝
                if(!valied) return;
            }// 1 表示正在遍历中，也就是存在环了，改变标记位，退出。
            else if(visited[val]== 1){
                valied = false;
                return;
            }
        }
        //表示该节点深度遍历完成
        visited[i] = 2;
    }
}

广度方法：

思路：记录每一个节点的入度，也就说比如课程1的学习需要课程2 和课程3，那么课程1的入度2为2；

​ 如果说，课程2 和课程3 的入度为0，那么说明这两个课程可以单独学习，那么我们学习完课程2 之后，课程1的入度就减少1，学习完课程3之后，在减少1，那么课程1的入度为0，那么它就可以学习了。

​ 简单的说，就是记录每个课程有多少个前提课，然后把这些前提课先遍历了，遍历之后看看每一门课程的入度是不是都为0，如果存在不为0的那么就是有环。

class Solution {
    List<List<Integer>> edgs;
    //入度记录
    int[] visited;
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        edgs = new ArrayList<List<Integer>>();
        for (int i = 0 ; i<numCourses;i++){
            edgs.add(new ArrayList<>());
        }
        visited = new int[numCourses];
        for(int i = 0 ; i<prerequisites.length;i++){
            //添加顶点和边的集合
            edgs.get(prerequisites[i][1]).add(prerequisites[i][0]);
            //入度初始化
            visited[prerequisites[i][0]]++;
        }
        Queue<Integer> queue = new LinkedList<>();
        //将入度初始值为0的课程，直接放到队列，因为它们可以直接遍历
        for(int i = 0; i<numCourses;i++){
            if(visited[i] == 0){
                queue.offer(i);
            }
        }
        while(!queue.isEmpty()){
            //获取依赖课程
            List<Integer> edge = edgs.get(queue.peek());
            for(int v:edge){
                //遍历一个就入度减一，这里的意思就是既然遍历了a课程，那么说明a课程已经可以学了，
                //那么依赖a课程的其它课程入度减一
                visited[v]--;
                if(visited[v]==0) queue.offer(v);
            }
            //完成之后删除
            queue.poll();
        }
        //判断所入度的数组是否存在非0 
        for(int v:visited){
            if(v != 0) return false;
        }
        return true;

    }
}