0000
0000
7月前 · 88 人阅读 · 文章来源: segmentfault

深度优先搜索(DFS)

上一次已经提到,的遍历一般有两种算法,即广度优先和深度优先。其中深度优先搜索算法会从第一个指定的顶点开始遍历图,沿着路径直到这条路径最后一个顶点,接着原路回退并探索下一条路径。换句话说,它是先深度后广度地访问顶点,如下图1。

图1

与广度优先算法不同,深度优先算法不需要一个起始顶点,只要顶点v没有被访问,就访问该顶点。
我们用三种状态来反映顶点的状态:

  • 白色:表示该顶点还没有被访问。
  • 灰色:表示该顶点被访问过,但并未被探索过。
  • 黑色:表示该顶点被访问过且被完全探索过。

访问某一顶点v的步骤如下:

  • 标注v为被发现的(灰色)
  • 对于v的所有未访问的邻点w:访问顶点w
  • 标注v为已被探索的(黑色)

因此深度优先搜索的步骤是递归的,这意味着深度优先搜索算法使用栈来存储函数调用(由递归调用所创建的栈)。
与广度优先算法类似,在算法开始之前,我们需要将所有顶点置为白色(本文的所有代码都是在中实现的Graph类中添加的)。

    function Graph() {
        var vertices = [];
        var adjList = new Dictionary();
        // 图类的其他代码省略...
        var initializeColor = function(){
            var color = [];
            for (var i=0; i<vertices.length; i++){
                color[vertices[i]] = 'white';
            }
            return color;
        };
    }

接下来实现深度优先算法的核心代码:

    this.dfs = function(callback){
        var color = initializeColor(); // 将所有顶点初始化为白色
        for (var i=0; i<vertices.length; i++){
            if (color[vertices[i]] === 'white'){ // 对每一个没有被访问过的顶点调用dfsVisit方法
                dfsVisit(vertices[i], color, callback); // {1}
            }
        }
        function dfsVisit(u, color, callback){
            color[u] = 'grey'; // 将顶点u置为灰,表明访问过但还没有完全探索
            callback && callback(u); // 执行回调函数
            var neighbors = adjList.get(u); // 获取顶点u的所有相邻顶点
            for (var i=0; i<neighbors.length; i++){ // 探索所有相邻顶点
                var w = neighbors[i];
                if (color[w] === 'white'){ // 如果相邻的顶点没有被访问过,则对其执行dfsVisit方法
                    dfsVisit(w, color, callback);
                }
            }
            color[u] = 'black'; // 将顶点u置为黑,表明已经完全访问。
        };
    };

对图1中的图执行上述搜索算法的过程如图2。

图2

由于我们是从起始点A开始搜索的,{1}处的代码只会执行一次,因为所有其他顶点都有一条路径到达A点。如果从B点开始搜索,{1}处的代码便会执行两次。

搜索时间

给定一个图G,要得到任意顶点u的发现时间(d[u])以及完成对该顶点的搜索时间(f[u]),可以在上述代码的基础上做一定修改(修改的位置用空行隔开):

    this.DFS = function(){
        var color = initializeColor(), //{2}
            len = vertices.length,

            d = new Array(len).fill([]), // 用于保存任意顶点u的发现时间
            f = new Array(len).fill([]), // 用于保存任意顶点u探索完成的时
            time = 0; // 用于记录探索时间

        for (var i=0; i<vertices.length; i++){
            if (color[vertices[i]] === 'white'){
                DFSVisit(vertices[i], color, d, f);
            }
        }

        return { // 返回探索数据
            discovery: d,
            finished: f
        };
        function DFSVisit(u, color, d, f){
            console.log('discovered ' + u);
            color[u] = 'grey';

            d[u] = ++time; // 发现顶点u后,时间+1

            var neighbors = adjList.get(u);
            for (var i=0; i<neighbors.length; i++){
                var w = neighbors[i];
                if (color[w] === 'white'){
                    DFSVisit(w,color, d, f);
                }
            }
            color[u] = 'black';
            
            f[u] = ++time; // 探索完顶点u后,时间+1
            
            console.log('explored ' + u);
        };
    };

对于深度优先算法,边是从最近发现的顶点u处被向外探索的。只有连接到未发现的顶点的边被探索了。当u所有的边都被探索了,该算法回退到u被发现的地方去探索其他的边。这个过程持续到我们发现了所有从原始顶点能够触及的顶点。如果还留有任何其他未被发现的顶点,我们对新源顶点重复这个过程。重复该算法,直到图中所有的顶点都被探索了。
观察上述代码可以发现,time的值只能在图的顶点数量的一到两倍之间,并且d[u]<f[u],即发现时间的值比完成时间的值小。

拓扑排序

给定图3,假定每个顶点都是一个我们需要去执行的任务。

图3

这是一个有向无环图(DAG),即任务的执行是有顺序的,例如,任务F不能在任务A之前执行,并且该图没有环。
当我们需要编排一些任务或步骤的执行顺序时,这称为拓扑排序。比如,当我们在开发一个项目时,首先我们得从客户那里得到需求,接着开发客户要求的东西,最后交付项目,但不能先交付项目再去收集需求。
拓扑排序只能应用于DAG。用深度优先搜索算法对图3中的任务图进行拓扑排序:

graph = new Graph();
myVertices = ['A','B','C','D','E','F'];
for (i=0; i<myVertices.length; i++){
    graph.addVertex(myVertices[i]);
}
graph.addEdge('A', 'C');
graph.addEdge('A', 'D');
graph.addEdge('B', 'D');
graph.addEdge('B', 'E');
graph.addEdge('C', 'F');
graph.addEdge('F', 'E');
var result = graph.DFS();

最终各顶点的发现和探索完成时间会保存在result中。图4直观地注明了各个顶点的发现时间/探索完成时间。

图4

那么按照探索完成时间的倒序来排序得到的拓扑排序为:
B - A - D - C - F - E
需要注意的是,算法不同,得到的拓扑排序可能不同,比如下面的拓扑排序也是可能的:
A - B - C - D - F - E

收藏 0
关键词: 数据结构与算法 javascript
评论