• 出入度
• 邻接表邻接矩阵
• 拓扑排序
  • DFS
  • Kahn算法
• Course Schedule
  • 题目描述
  • 代码实现

转载请注明出处：http://blog.csdn.net/c602273091/article/details/55511145

出入度

图（Graph）是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G(V,E)，其中，G表示一个图，V是图G中顶点的集合，E是图G中边的集合。

各种图的概念请看：【6】

无向边：若顶点Vi到Vj之间的边没有方向，则称这条边为无向边(Edge)，用无序偶(Vi,Vj)来表示。
有向边：若从顶点Vi到Vj的边有方向，则称这条边为有向边，也成为弧(Arc)，用有序偶< Vi,Vj>来表示，Vi称为弧尾，Vj称为弧头。
简单图：在图结构中，若不存在顶点到其自身的边，且同一条边不重复出现，则称这样的图为简单图。
无向完全图：在无向图中，如果任意两个顶点之间都存在边，则称该图为无向完全图。含有n个顶点的无向完全图有n*(n-1)/2条边。
有向完全图：在有向图中，如果任意两个顶点之间都存在方向互为相反的两条弧，则称该图为有向完全图。含有n个顶点的有向完全图有n*(n-1)条边。
稀疏图和稠密图：这里的稀疏和稠密是模糊的概念，都是相对而言的，通常认为边或弧数小于n*logn（n是顶点的个数）的图称为稀疏图，反之称为稠密图。
有些图的边或弧带有与它相关的数字，这种与图的边或弧相关的数叫做权(Weight)，带权的图通常称为网(Network)。

然后介绍度，以顶点V为头的弧的数目称为V的入度(InDegree)，记为ID(V)，以V为尾的弧的数目称为V的出度(OutDegree)，记为OD(V)，因此顶点V的度为TD(V)=ID(V)+OD(V)。一般指的是在有向图（DAG）中，某个顶点，箭头指向它的为入度，从这个顶点出发，指向别的顶点的边就是出度。有几条这样的边，度就是多大。看【7】中的图有详细的介绍。

如果一个有向图恰有一个顶点入度为0，其余顶点的入度均为1，则是一棵有向树。

可以参考【1】中生成出入度的代码。不过【1】中是认为无向图中一条边既是入度、也是出度。所以这里的计算会有些许不同。

邻接表、邻接矩阵

邻接表这个东西也可以看【1】中是怎么写这个邻接矩阵的，我更推荐的是看【2】中鱼c的文章。写得非常好。

其实邻接表和邻接矩阵是离散数学的必修内容，现在就是对它进行一个复习。

首先邻接矩阵的纵轴坐标就是各个边的初始顶点，横坐标就是各个边的箭头的的位置。如果存在i->j这条边，那么就使矩阵M（i， j） = 1，否则为0。

邻接表是另外一种记录图的数据结构。因为图是稀疏的话，那么邻接矩阵就会使得存储很浪费，使用邻接表存储更加节约空间。如果图是稠密的话，使用邻接表是一种不错的方式。

在这里强烈推荐这个博客，写得非常好，非常简单易懂【3】【8】。

在图的存储结构中，还有十字链表、邻接多重表、边集数组。
边集数组：边集数组是由两个一维数组构成，一个是存储顶点的信息，另一个是存储边的信息，这个边数组每个数据元素由一条边的起点下标(begin)、终点下标(end)和权(weight)组成【9】。

另外在【11】中，对图的表示举了比较简单的例子。

拓扑排序

拓扑排序我觉得就是一个有向无环图的问题。有向无环这就是拓扑图的充要条件。

在计算拓扑图方面，有DFS和Kahn算法。这里我主要是参考了【4】

DFS

从wiki上获取它的伪代码为：

L ← Empty list that will contain the sorted nodes
S ← Set of all nodes with no outgoing edges
for each node n in S do
    visit(n)

function visit(node n)
    if n has not been visited yet then
        mark n as visited
        for each node m with an edge from m to n do
            visit(m)
        add n to L

具体的代码实现为：

public class DirectedDepthFirstOrder {
    // visited数组，DFS实现需要用到
    private boolean[] visited;
    // 使用栈来保存最后的结果
    private Stack<Integer> reversePost;

    /** * Topological Sorting Constructor */
    public DirectedDepthFirstOrder(Digraph di, boolean detectCycle)
    {
        // 这里的DirectedDepthFirstCycleDetection是一个用于检测有向图中是否存在环路的类
        DirectedDepthFirstCycleDetection detect = new DirectedDepthFirstCycleDetection(
                di);

        if (detectCycle && detect.hasCycle())
            throw new IllegalArgumentException("Has cycle");

        this.visited = new boolean[di.getV()];
        this.reversePost = new Stack<Integer>();

        for (int i = 0; i < di.getV(); i++)
        {
            if (!visited[i])
            {
                dfs(di, i);
            }
        }
    }

    private void dfs(Digraph di, int v)
    {
        visited[v] = true;

        for (int w : di.adj(v))
        {
            if (!visited[w])
            {
                dfs(di, w);
            }
        }

        // 在即将退出dfs方法的时候，将当前顶点添加到结果集中
        reversePost.push(v);
    }

    public Iterable<Integer> getReversePost()
    {
        return reversePost;
    }
}

Kahn算法

Kahn的伪代码为：

L← Empty list that will contain the sorted elements
S ← Set of all nodes with no incoming edges
while S is non-empty do
    remove a node n from S
    insert n into L
    foreach node m with an edge e from nto m do
        remove edge e from thegraph
        ifm has no other incoming edges then
            insert m into S
if graph has edges then
    return error (graph has at least onecycle)
else 
    return L (a topologically sortedorder)

它的具体实现为：

public class KahnTopological
{
    private List<Integer> result;   // 用来存储结果集
    private Queue<Integer> setOfZeroIndegree;  // 用来存储入度为0的顶点
    private int[] indegrees;  // 记录每个顶点当前的入度
    private int edges;
    private Digraph di;

    public KahnTopological(Digraph di)
    {
        this.di = di;
        this.edges = di.getE();
        this.indegrees = new int[di.getV()];
        this.result = new ArrayList<Integer>();
        this.setOfZeroIndegree = new LinkedList<Integer>();

        // 对入度为0的集合进行初始化
        Iterable<Integer>[] adjs = di.getAdj();
        for(int i = 0; i < adjs.length; i++)
        {
            // 对每一条边 v -> w 
            for(int w : adjs[i])
            {
                indegrees[w]++;
            }
        }

        for(int i = 0; i < indegrees.length; i++)
        {
            if(0 == indegrees[i])
            {
                setOfZeroIndegree.enqueue(i);
            }
        }
        process();
    }

    private void process()
    {
        while(!setOfZeroIndegree.isEmpty())
        {
            int v = setOfZeroIndegree.dequeue();

            // 将当前顶点添加到结果集中
            result.add(v);

            // 遍历由v引出的所有边
            for(int w : di.adj(v))
            {
                // 将该边从图中移除，通过减少边的数量来表示
                edges--;
                if(0 == --indegrees[w])   // 如果入度为0，那么加入入度为0的集合
                {
                    setOfZeroIndegree.enqueue(w);
                }
            }
        }
        // 如果此时图中还存在边，那么说明图中含有环路
        if(0 != edges)
        {
            throw new IllegalArgumentException("Has Cycle !");
        }
    }

    public Iterable<Integer> getResult()
    {
        return result;
    }
}

在【4】中还涉及了哈密顿路径，可以看看，写得不错。作者总结了其中DFS和Kahn的算法不同点以及前提条件。DFS是要先证明不存在环才可以使用，Kahn不需要。

DFS的检测闭环和拓扑排序写在一起就是：

public class DirectedDepthFirstTopoWithCircleDetection {
    private boolean[] visited;
    // 用于记录dfs方法的调用栈，用于环路检测
    private boolean[] onStack;
    // 用于当环路存在时构造之
    private int[] edgeTo;
    private Stack<Integer> reversePost;
    private Stack<Integer> cycle;

    /** * Topological Sorting Constructor */
    public DirectedDepthFirstTopoWithCircleDetection(Digraph di)
    {
        this.visited = new boolean[di.getV()];
        this.onStack = new boolean[di.getV()];
        this.edgeTo = new int[di.getV()];
        this.reversePost = new Stack<Integer>();

        for (int i = 0; i < di.getV(); i++)
        {
            if (!visited[i])
            {
                dfs(di, i);
            }
        }
    }

    private void dfs(Digraph di, int v)
    {
        visited[v] = true;
        // 在调用dfs方法时，将当前顶点记录到调用栈中
        onStack[v] = true;

        for (int w : di.adj(v))
        {
            if(hasCycle())
            {
                return;
            }
            if (!visited[w])
            {
                edgeTo[w] = v;
                dfs(di, w);
            }
            else if(onStack[w])
            {
                // 当w已经被访问，同时w也存在于调用栈中时，即存在环路
                cycle = new Stack<Integer>();
                cycle.push(w);
                for(int start = v; start != w; start = edgeTo[start])
                {
                    cycle.push(v);
                }
                cycle.push(w);
            }
        }

        // 在即将退出dfs方法时，将顶点添加到拓扑排序结果集中，同时从调用栈中退出
        reversePost.push(v);
        onStack[v] = false;
    }

    private boolean hasCycle() 
    {
        return (null != cycle);
    }

    public Iterable<Integer> getReversePost()
    {
        if(!hasCycle())
        {
            return reversePost;
        }
        else 
        {
            throw new IllegalArgumentException("Has Cycle: " + getCycle());
        }
    }

    public Iterable<Integer> getCycle() 
    {
        return cycle;
    }
}

这两种方法的复杂度都是O(E+V)。

最后推荐程序员必须会的10种算法这篇文章：【5】

207. Course Schedule

题目描述

There are a total of n courses you have to take, labeled from 0 to n – 1.

Some courses may have prerequisites, for example to take course 0 you have to first take course 1, which is expressed as a pair: [0,1]

Given the total number of courses and a list of prerequisite pairs, is it possible for you to finish all courses?

For example:

2, [[1,0]]

There are a total of 2 courses to take. To take course 1 you should have finished course 0. So it is possible.

2, [[1,0],[0,1]]

There are a total of 2 courses to take. To take course 1 you should have finished course 0, and to take course 0 you should also have finished course 1. So it is impossible.

Note:
The input prerequisites is a graph represented by a list of edges, not adjacency matrices. Read more about how a graph is represented.
You may assume that there are no duplicate edges in the input prerequisites.

代码实现

class Solution {
public:
    int findPos(vector<int> rem, int num) {
        int remsz = rem.size();
        for(int i = 0; i < remsz; i++) 
            if(rem[i] == num) return i;
        return - 1;    
    }

    bool canFinish(int numCourses, vector<pair<int, int>>& pre) {
        int num[10000] = {0}, nump = pre.size();
        queue<int> stt;
        vector<int> rem;
        for(int i = 0; i < nump; i++)  { 
            if(num[pre[i].second] == 0) num[pre[i].second] = -1;
            if(num[pre[i].first] == -1 || num[pre[i].first] == 0)  num[pre[i].first] = 1;
            else  num[pre[i].first]++; 
        }    
        for(int i = 0; i < numCourses; i++) {  
            if(num[i] == -1)  stt.push(i); 
            else if(num[i] > 0) rem.push_back(i); 
        }    
        while(!stt.empty()) {
            int remsz = rem.size();
            if(!remsz) break;            
            int tp = stt.front();
            stt.pop();
            for(int i = 0; i < nump; i++) {
                if(pre[i].second == tp) { 
                    num[pre[i].first]--;
                    if(!num[pre[i].first]) {
                        stt.push(pre[i].first);
                        rem.erase(rem.begin() + findPos(rem, pre[i].first));
                    }    
                }
            }
        }

        return rem.empty();
    }
};

上面使用的就是Kahn算法实现的课程调度。

在【10】里面，提出了BFS和DFS的实现。

BFS：

class Solution {
public:
    bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {
        vector<unordered_set<int>> graph = make_graph(numCourses, prerequisites);
        vector<int> degrees = compute_indegree(graph);
        for (int i = 0; i < numCourses; i++) {
            int j = 0;
            for (; j < numCourses; j++)
                if (!degrees[j]) break;
            if (j == numCourses) return false;
            degrees[j] = -1;
            for (int neigh : graph[j])
                degrees[neigh]--;
        }
        return true;
    }
private:
    vector<unordered_set<int>> make_graph(int numCourses, vector<pair<int, int>>& prerequisites) {
        vector<unordered_set<int>> graph(numCourses);
        for (auto pre : prerequisites)
            graph[pre.second].insert(pre.first);
        return graph;
    }
    vector<int> compute_indegree(vector<unordered_set<int>>& graph) {
        vector<int> degrees(graph.size(), 0);
        for (auto neighbors : graph)
            for (int neigh : neighbors)
                degrees[neigh]++;
        return degrees;
    }
}; 

DFS：

class Solution {
public:
    bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {
        vector<unordered_set<int>> graph = make_graph(numCourses, prerequisites);
        vector<bool> onpath(numCourses, false), visited(numCourses, false);
        for (int i = 0; i < numCourses; i++)
            if (!visited[i] && dfs_cycle(graph, i, onpath, visited))
                return false;
        return true;
    }
private:
    vector<unordered_set<int>> make_graph(int numCourses, vector<pair<int, int>>& prerequisites) {
        vector<unordered_set<int>> graph(numCourses);
        for (auto pre : prerequisites)
            graph[pre.second].insert(pre.first);
        return graph;
    } 
    bool dfs_cycle(vector<unordered_set<int>>& graph, int node, vector<bool>& onpath, vector<bool>& visited) {
        if (visited[node]) return false;
        onpath[node] = visited[node] = true; 
        for (int neigh : graph[node])
            if (onpath[neigh] || dfs_cycle(graph, neigh, onpath, visited))
                return true;
        return onpath[node] = false;
    }
};

参考链接：
对于各种算法的一个总结：

【1】图的邻接矩阵及出入度的计算方法：http://m.blog.csdn.net/article/details?id=9078919
【2】邻接表和邻接矩阵：http://blog.fishc.com/2523.html
【3】学习数据结构不错的网站：http://blog.fishc.com/category/structure
【4】拓扑排序的介绍：http://m.blog.csdn.net/article/details?id=7714519
【5】程序员十大算法：http://www.wtoutiao.com/p/1c2pI1k.html
【6】图的入门：http://blog.fishc.com/2485.html
【7】图的介绍：http://blog.fishc.com/2499.html
【8】邻接矩阵：http://blog.fishc.com/2514.html
【9】图的特殊的存储结构：http://blog.fishc.com/2535.html
【10】BFS/DFS的课程调度实现：https://discuss.leetcode.com/topic/17273/18-22-lines-c-bfs-dfs-solutions
【11】图的表示：https://www.khanacademy.org/computing/computer-science/algorithms/graph-representation/a/representing-graphs