《算法导论》BFS和DFS实现

1. 广度优先搜索BFS可以用在最小生成树算法（Prim）和单源最短路径算法（Dijkstra），借助优先队列存放同一深度的待访问结点
2. 深度优先搜索DFS，本质是回溯算法，“一条路走到头再回来”

参考《算法导论》第六部分图算法的第22章-图的基本算法：

1. 图G(V, E)用邻接矩阵G表示
2. 用三种颜色标记顶点的状态，记录搜索轨迹（顶点未发现“white”，发现为“gray”，遍历完为“black”)
3. 用数组color、parent表示各顶点的颜色状态和父节点

以下是BFS的python代码实现：

def BFS(G, s):
    """
        G: Adajcent Matrix
        s: The index of source node to traverse
    """
    # initialize
    numVertex = len(G)
    color = ['white']*numVertex
    level = ['inf']*numVertex
    parent = ['null']*numVertex

    color[s] = 'gray'
    level[s] = 0
    parent[s] = 0 
    queue = []  
    queue.append(s)

    while queue:
        u = queue.pop(0)
        print u
        # find adjacent node of u
        for v in xrange(numVertex):
            if G[u][v] == 0:
                continue
            if color[v] == 'white':
                queue.append(v)
                color[v] = 'gray'
                level[v] = level[u] + 1
                parent[v] = u
        color[u] = 'black'

    print 'level', level
    print 'color', color    
    print 'parent', parent

if __name__ == "__main__":
    G = [[1, 1, 0, 1, 0, 0],
         [1, 1, 0, 0, 1, 0],
         [0, 0, 1, 0, 1, 1],
         [1, 0, 0, 1, 0, 0],
         [0, 1, 1, 0, 1, 1],
         [0, 0, 1, 0, 1, 1]]
    BFS(G,2)

DFS的python实现

def DFS(G):
    """
        G: Adajcent Matrix
        s: The index of source node to traverse
    """
    numVertex = len(G)
    color = ['white']*numVertex
    parent = ['null']*numVertex

    for u in xrange(numVertex):
        if color[u] == 'white':
            DFS_VISIT(u, color, parent)

    print 'color', color
    print 'parent', parent

def DFS_VISIT(u, color, parent):
    color[u] = 'gray'
    print u 
    for v in xrange(len(color)):
        if G[u][v] == 0:
            continue
        if color[v] == 'white':
            parent[v] = u
            DFS_VISIT(v, color, parent)
    color[u] = 'black'

if __name__ == "__main__":
    G = [[1, 1, 0, 1, 0, 0],
         [1, 1, 0, 0, 1, 0],
         [0, 0, 1, 0, 1, 1],
         [1, 0, 0, 1, 0, 0],
         [0, 1, 1, 0, 1, 1],
         [0, 0, 1, 0, 1, 1]]
    DFS(G)