最近接触了一下拓朴排序，手痒写了下代码，给自己找了点麻烦，dfs特地没有用递归做；
关于拓朴排序的原理有很多人写得很好了，请参考以下文章：
https://blog.csdn.net/qinzhaokun/article/details/48541117
https://blog.csdn.net/yafeichang/article/details/53893120
https://www.cnblogs.com/xiangkejin/p/6965124.html
https://www.cnblogs.com/xiangkejin/p/6965124.html
第一篇非常好，截取其中一段：
对于基于DFS的算法，加入结果集的条件是：顶点的出度为0。这个条件和Kahn算法中入度为0的顶点集合似乎有着异曲同工之妙，这两种算法的思想犹如一枚硬币的两面，看似矛盾，实则不然。一个是从入度的角度来构造结果集，另一个则是从出度的角度来构造。
#!/user/bin/env python
# -*- coding:utf8 -*-
__author__ = 'zky@msn.cn'
''' 基于邻接矩阵的有向图 '''
class Digraph(object):
def __init__(self, V, E):
self._V = V
self._E = E
self.num_vertexes = len(V)
self.num_edges = len(E)
# init adjacency matrix
self._AM = []
for i in range(self.num_vertexes):
self._AM.append([0 for i in range(self.num_vertexes)])
for e in self._E:
v_h, v_t = e
self._AM[v_h][v_t] = 1
def dfs(self, v, order="post", result=None):
if order == "pre":
return self._dfs_pre_order(v, result)
else:
return self._dfs_post_order(v, result)
''' 非递归前序深度遍历 '''
def _dfs_pre_order(self, v, result=None):
if not v in self._V:
print "not found %s" % v
return None
result_pre = []
if result is not None:
result_pre = result
if v in result_pre:
return result_pre
finished = False
stack_pre = []
stack_pre.append(v)
while not finished:
v = stack_pre.pop()
result_pre.append(v)
i = self._V.index(v)
for j in range(self.num_vertexes)[::-1]:
if self._AM[i][j]:
v = self._V[j]
if v not in result_pre and v not in stack_pre: # not checked yet
stack_pre.append(v)
if 0 == len(stack_pre):
finished = True
return result_pre
''' 非递归后序深度遍历 '''
'''
使用两个栈，分别保存节点路径和待处理节点
'''
def _dfs_post_order(self, v, result=None):
if not v in self._V:
print "not found %s" % v
return None
result_post = []
if result is not None:
result_post = result
if v in result_post:
return result_post
finished = False
stack_checking = []
stack_waiting = []
stack_waiting.append(v)
while not finished:
v = stack_waiting.pop()
while len(stack_checking) and v == stack_checking[-1]:
result_post.append(v)
stack_checking.pop()
if 0 == len(stack_waiting):
finished = True
assert 0 == len(stack_checking)
else:
v = stack_waiting.pop()
if v not in stack_checking and v not in result_post: # not checked yet
stack_checking.append(v)
stack_waiting.append(v) # push it back to make a sentinel
i = self._V.index(v)
for j in range(self.num_vertexes)[::-1]:
if self._AM[i][j]:
v = self._V[j]
stack_waiting.append(v)
if 0 == len(stack_checking) and 0 == len(stack_waiting):
finished = True
return result_post
''' 非递归广度遍历 '''
def bfs(self, v):
if not v in self._V:
print "not found %s" % v
return False
result = []
checking = 0
finished = False
result.append(v)
while not finished:
i = self._V.index(v)
for j in range(self.num_vertexes):
if self._AM[i][j]:
v = self._V[j]
if v not in result: # not checked yet
result.append(v)
checking += 1
if checking == len(result):
finished = True
else:
v = result[checking]
return result
def topological_sort(self, algo="dfs"):
if algo == "kahn":
return self._kahn_topological_sort()
else:
return self._dfs_topological_sort()
''' 基于DFS的拓朴排序 '''
def _dfs_topological_sort(self):
result = []
for v in self._V:
if v not in result:
self.dfs(v, "post", result)
result.reverse()
return result
''' 基于Kahn算法的拓朴排序 '''
def _kahn_topological_sort(self):
result = []
# calc indegree and get zero degree set
indegree = [0 for i in range(self.num_vertexes)]
zero_degree_set = []
for e in self._E:
v_h, v_t = e
indegree[v_t] += 1
for i in range(self.num_vertexes):
if indegree[i] == 0:
zero_degree_set.append(i)
while len(zero_degree_set):
i = zero_degree_set.pop()
v = self._V[i]
result.append(v)
for j in range(self.num_vertexes):
if self._AM[i][j]:
indegree[j] -= 1
if indegree[j] == 0:
zero_degree_set.append(j)
return result
def test(V, E, AM, topology):
print "="*80
G = Digraph(V, E)
#print G._AM
#print AM
assert G._AM == AM
print topology
print "="*10 + "bfs" + "="*10
for v in V:
print v, G.bfs(v)
print "="*10 + "dfs pre order" + "="*10
for v in V:
print v, G.dfs(v, "pre")
print "="*10 + "dfs post order" + "="*10
for v in V:
print v, G.dfs(v, "post")
print "="*10 + "topological sort" + "="*10
print "dfs", G.topological_sort("dfs")
print "kahn", G.topological_sort("kahn")
def test1():
topology =
'''
->v0------>v4
/ ^ ^
/ | |
v1 | |
| |
| |
->v2------>v3
'''
V = ["v0", "v1", "v2", "v3", "v4"]
E = [
(0, 4),
(1, 0),
(1, 2),
(2, 3),
(2, 0),
(3, 4),
]
AM = [ #v0,v1,v2,v3,v4
[0, 0, 0, 0, 1], # v0
[1, 0, 1, 0, 0], # v1
[1, 0, 0, 1, 0], # v2
[0, 0, 0, 0, 1], # v3
[0, 0, 0, 0, 0], # v4
]
test(V, E, AM, topology)
def test2():
topology =
'''
0------------->6<---7<---8
| /
| | /
| v --<2 /
| 1 / / ->9--->10
| 3<- / |
| / ->4<- v
|/ / 11--->12
v /
5--
'''
V = ["v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8", "v9", "v10", "v11", "v12"]
E = [
(0, 1),
(0, 5),
(0, 6),
(2, 0),
(2, 3),
(3, 5),
(5, 4),
(6, 4),
(6, 9),
(7, 6),
(8, 7),
(9, 10),
(9, 11),
(9, 12),
(11, 12),
]
AM = [ #v0,v1,v2,v3,v4,v5,v6,v7,v8,v9,v10,v11,v12
[0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0], # v0
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], # v1
[1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], # v2
[0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0], # v3
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], # v4
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0], # v5
[0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0], # v6
[0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0], # v7
[0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], # v8
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1], # v9
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], # v10
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], # v11
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], # v12
]
test(V, E, AM, topology)
if __name__ == '__main__':
test1()
test2()
输出：
================================================================================
->v0------>v4
/ ^ ^
/ | |
v1 | |
| |
| |
->v2------>v3
==========bfs==========
v0 ['v0', 'v4']
v1 ['v1', 'v0', 'v2', 'v4', 'v3']
v2 ['v2', 'v0', 'v3', 'v4']
v3 ['v3', 'v4']
v4 ['v4']
==========dfs pre order==========
v0 ['v0', 'v4']
v1 ['v1', 'v0', 'v4', 'v2', 'v3']
v2 ['v2', 'v0', 'v4', 'v3']
v3 ['v3', 'v4']
v4 ['v4']
==========dfs post order==========
v0 ['v4', 'v0']
v1 ['v4', 'v0', 'v3', 'v2', 'v1']
v2 ['v4', 'v0', 'v3', 'v2']
v3 ['v4', 'v3']
v4 ['v4']
==========topological sort==========
dfs ['v1', 'v2', 'v3', 'v0', 'v4']
kahn ['v1', 'v2', 'v3', 'v0', 'v4']
================================================================================
0------------->6<---7<---8
| /
| | /
| v --<2 /
| 1 / / ->9--->10
| 3<- / |
| / ->4<- v
|/ / 11--->12
v /
5--
==========bfs==========
v0 ['v0', 'v1', 'v5', 'v6', 'v4', 'v9', 'v10', 'v11', 'v12']
v1 ['v1']
v2 ['v2', 'v0', 'v3', 'v1', 'v5', 'v6', 'v4', 'v9', 'v10', 'v11', 'v12']
v3 ['v3', 'v5', 'v4']
v4 ['v4']
v5 ['v5', 'v4']
v6 ['v6', 'v4', 'v9', 'v10', 'v11', 'v12']
v7 ['v7', 'v6', 'v4', 'v9', 'v10', 'v11', 'v12']
v8 ['v8', 'v7', 'v6', 'v4', 'v9', 'v10', 'v11', 'v12']
v9 ['v9', 'v10', 'v11', 'v12']
v10 ['v10']
v11 ['v11', 'v12']
v12 ['v12']
==========dfs pre order==========
v0 ['v0', 'v1', 'v5', 'v4', 'v6', 'v9', 'v10', 'v11', 'v12']
v1 ['v1']
v2 ['v2', 'v0', 'v1', 'v5', 'v4', 'v6', 'v9', 'v10', 'v11', 'v12', 'v3']
v3 ['v3', 'v5', 'v4']
v4 ['v4']
v5 ['v5', 'v4']
v6 ['v6', 'v4', 'v9', 'v10', 'v11', 'v12']
v7 ['v7', 'v6', 'v4', 'v9', 'v10', 'v11', 'v12']
v8 ['v8', 'v7', 'v6', 'v4', 'v9', 'v10', 'v11', 'v12']
v9 ['v9', 'v10', 'v11', 'v12']
v10 ['v10']
v11 ['v11', 'v12']
v12 ['v12']
==========dfs post order==========
v0 ['v1', 'v4', 'v5', 'v10', 'v12', 'v11', 'v9', 'v6', 'v0']
v1 ['v1']
v2 ['v1', 'v4', 'v5', 'v10', 'v12', 'v11', 'v9', 'v6', 'v0', 'v3', 'v2']
v3 ['v4', 'v5', 'v3']
v4 ['v4']
v5 ['v4', 'v5']
v6 ['v4', 'v10', 'v12', 'v11', 'v9', 'v6']
v7 ['v4', 'v10', 'v12', 'v11', 'v9', 'v6', 'v7']
v8 ['v4', 'v10', 'v12', 'v11', 'v9', 'v6', 'v7', 'v8']
v9 ['v10', 'v12', 'v11', 'v9']
v10 ['v10']
v11 ['v12', 'v11']
v12 ['v12']
==========topological sort==========
dfs ['v8', 'v7', 'v2', 'v3', 'v0', 'v6', 'v9', 'v11', 'v12', 'v10', 'v5', 'v4', 'v1']
kahn ['v8', 'v7', 'v2', 'v3', 'v0', 'v6', 'v9', 'v11', 'v12', 'v10', 'v5', 'v4', 'v1']