深度优先

深度遍历下面的图，打印结果，

有了之前实现的广度优先的两个类，修该一下便得出结果，

顶点类，finish是遍历完成时间，深度deep则是发现时间

class Vertex(object):
    time = 0#时间截
    
    def __init__(self,Name = 'unNamed',Deep = 0,Color = "white",Parent = None):
        self.name = Name
        self.deep = Deep
        self.color = Color
        self.parent = Parent
        self.finish = 0
    
    def __str__(self, *args, **kwargs):
        return self.name
    
    def __repr__(self, *args, **kwargs):
        return self.__str__()
    
    def print_info(self):
        print("vertext:",self,",deep:",self.deep,\
              ",finish:",self.finish,",parent:",self.parent) 

def main():
    v = Vertex()
    v.name = "v"
    
    w = Vertex()
    w.name = "w"
    w.deep = 1
    w.parent = v
    
    edge = [v,w]
    
    print ("edge:",edge)
    
    for eachVertex in edge:
        eachVertex.print_info()
    
if __name__ == "__main__":
    main()
    

graph模块：

from vertex import Vertex
from collections import deque


class Graph(object):
    def __init__(self):
        #Adjs邻接表字典，数据结构：{Vertex1:[x,y,z], vertex2:[a,b,c,d],......}
        #要访问某个顶点的所有邻居，Adjs[Vertex]
        #返回为该顶点的邻居列表，如[v,x,y,z]
        self.Adjs = {} 
    def addAdj(self,Vertex,*neighbors): 
        '添加邻接链表'
        list = [] 
        for neighbor in neighbors:
            list.append(neighbor)
        self.Adjs[Vertex] = list

def DFS_VISIT(G,u):
    Vertex.time += 1
    u.deep = Vertex.time
    u.color = 'gray'
    
    for v in G.Adjs[u]:
        if v.color == "white":
            v.parent = u
            DFS_VISIT(G, v)
    u.color = 'black'
    Vertex.time += 1
    u.finish = Vertex.time
     

def DFS(G,VertexList):
    Vertex.time #时间截初始化为0
    
    for vertex in VertexList:#vertex是邻接表字典的关键字，即为每个顶点
        if vertex.color == "white":
            DFS_VISIT(G, vertex)
        
def main():
        
    #初始化顶点   
    u = Vertex("u")
    v = Vertex("v")
    w = Vertex("w")
    x = Vertex("x")
    y = Vertex("y")
    z = Vertex("z")
    
    G = Graph() 
    #添加邻接链表 
    G.addAdj(u,x,v)
    G.addAdj(v,y)    
    G.addAdj(w,y,z)
    G.addAdj(x,v)
    G.addAdj(y,x)
    G.addAdj(z,z)
    
    preffered = [u,v,w,x,y,z]#控制遍历的先后顺序
    DFS(G,preffered)#广度优先
    
    for each in G.Adjs:
        each.print_info()
    
if __name__ == "__main__":
    main()

        

打印的结果：

vertext: x ,deep: 2 ,finish: 7 ,parent: u
vertext: u ,deep: 1 ,finish: 8 ,parent: None
vertext: y ,deep: 4 ,finish: 5 ,parent: v
vertext: v ,deep: 3 ,finish: 6 ,parent: x
vertext: z ,deep: 10 ,finish: 11 ,parent: w
vertext: w ,deep: 9 ,finish: 12 ,parent: None

这里有一个细节，就是DFS(G,VertexList)中VertexList是用于控制遍历的先后顺序的。不同的顺序能产生不同的结果

如果比考虑顺序问题，则只需要吧DFS改为：

def DFS(G):
    Vertex.time #时间截初始化为0
    
    for vertex in G.Adjs:#vertex是邻接表字典的关键字，即为每个顶点
        if vertex.color == "white":
            DFS_VISIT(G, vertex)

产生的结果也是正确的，其结果依赖字典Adjs里的先后顺序：

vertext: x ,deep: 1 ,finish: 6 ,parent: None
vertext: u ,deep: 7 ,finish: 8 ,parent: None
vertext: y ,deep: 3 ,finish: 4 ,parent: v
vertext: v ,deep: 2 ,finish: 5 ,parent: x
vertext: z ,deep: 9 ,finish: 10 ,parent: None
vertext: w ,deep: 11 ,finish: 12 ,parent: None