参考：《算法图解》（人民邮电出版社）

六度关系理论与寻找芒果商

每个人都有自己的关系网，假如下面是你微信好友的关系网，其中you节点代表你自己：

和you直接相连的联系人是直接好友，比如图中的Tony，你可以通过一步就联系到Tony。而对于直接好友的好友，比如图中的Alice，Alice虽然是Tony的好友，但不是你的好友，你无法直接联系到Alice，只能通过直接好友Tony作为桥梁才能联系到Alice。

我们把图中的像Tony、Tom、John这样的直接好友称为一度关系，也就是下图中绿色圆圈中的好友。而下图中蓝色圆圈和黄色圆圈中的好友则分别是二度关系和三度关系：

有一种理论讲到，你和世界上任何人之间最多只隔了六度关系，换句话说，你最多通过六个人就可以联系到这世界上的任何人。

暂且不去争论这个理论的对错，我们下面来考虑一个实际问题：假如你想找到你的关系网中和你关系最近的芒果商有谁？该怎么找呢？（这里假定名字以大写或小写的字母M开头的人就是芒果商，虽然比较搞笑，但为了简单起见先这么定）一种可行的思路就是采用广度优先搜索的策略。

既然是想找到关系最近的芒果商，那肯定优先找一度关系中的联系人比较好，一度关系联系人找了个遍之后，如果没有发现任何人是芒果商，那接着去找二度联系人、三度联系人、...、N度联系人。

在算法实现的过程中，查找过程中最好用队列去存储待找的联系人，一开始把这个队列初始化为开始节点，每找一个联系人之后，就把这个联系人的所有直接联系人添加到队列的尾部，供后面查找。此外，为了避免重复查找，还需要创建一个已经处理过的联系人列表，每处理完一个联系人后都把他都加入到这个列表中。

下面是详细的算法实现，几乎每一行都写了详细的注释，还是比较好理解的:)

算法实现：找到芒果商

# coding:utf-8
# 广度优先搜索寻找图中关系最近的芒果商
# BFS特点：地毯式稳步推进，不留死角。
def BFS(graph,start):
    '''
    广度优先搜索查找在图graph中从start节点到goal节点之间的最短路径列表和所有的可达路径
    
    :param graph: 图的散列表结构对象
    :param start: 开始节点
    :return: 离start节点最近的芒果商，如果有多个芒果商都最近，则返回找到的第一个；如果没有找到芒果商，则返回None
    '''
    # 定义一个节点队列，用于存储待查找的节点，初始化为[start]，在查找的过程中会不断更新该队列
    search_queue = [start]
    # 已经处理过的节点的列表，防止重复查找
    searched = []
    # 只要search_queue队列不为空，就查找下去
    while search_queue:
        # 从search_queue队列出队一个节点
        node = search_queue.pop(0)
        # 如果node是芒果商，则返回
        if is_mangoman(node):
            return node
        
        # 遍历node节点的所有邻居节点，把每个邻居节点分别添加到search_queue队列中去
        for neighbor_node in graph.get(node,[]):
            # 如果neighbor_node不在searched列表中，则将其入队
            if neighbor_node not in searched:
                search_queue.append(neighbor_node)
    return None

def is_mangoman(name):
    '''
    根据一个人名判断一个人是否是芒果商
    
    :param name: 人名
    :return: True或False
    '''
    if not name:
        return False
    # 名字以'm'或'M'开头就认为是芒果商（虽然这确实有点搞笑）
    if name.startswith('m') or name.startswith('M'):
        return True
    else:
        return False
    
def main():
    # 构建图，有一个前提假设：图中的姓名没有重复的（保证唯一性）
    graph = {
        'you':['Tony','John','Tom'],
        'Tony':['Alice','Andy'],
        'John':['Nancy','Ben'],
        'Tom':['Andy','Mike'],
        'Andy':['Mike','Mercy'],
        'Nancy':['Ben'],
        'Ben':['Tom']
    }
    start = 'you'
    mangoman = BFS(graph,start)
    print 'the closest mangoman to {0} is: {1}'.format(start,mangoman)

if __name__ == '__main__':
    main()
    '''
    输出：
    the closest mangoman to you is: Mike
    '''

算法实现进阶：找到能够联系到芒果商的最短路径

上面的算法只是找到了和你关系最近的芒果商，但是并没有得出通过什么路径可以联系到这个联系人，下面优化算法，找到这样的路径：

# coding:utf-8
# 广度优先搜索求图中的最短路径：寻找芒果商
# BFS特点：地毯式稳步推进，不留死角。
def BFS(graph,start,goal):
    '''
    广度优先搜索查找在图graph中从start节点到goal节点之间的最短路径列表和所有的可达路径
    
    :param graph: 图的散列表结构对象
    :param start: 开始节点
    :param goal: 目标节点
    :return: 从start节点到goal节点之间的最短路径列表和所有的可达路径列表
    '''
    # 定义一个路径队列，用于存储可能的路径，初始化为[[start]]，在查找的过程中会不断更新该队列
    paths_queue = [[start]]
    # 所有从start到goal可达的路径的列表
    all_paths = []
    # 只要paths_queue队列不为空，就查找下去
    while paths_queue:
        # 从paths_queue队列出队一个路径
        path = paths_queue.pop(0)
        # 获取该路径中的最后一个节点
        last_node = path[-1]
        # 如果last_node等于goal，说明当前路径path就是一条从start到goal可达的路径
        if last_node == goal:
            # 如果当前路径不在all_paths中，则把当前路径path添加到all_paths列表中
            if path not in all_paths:
                all_paths.append(path)
        
        # 遍历last_node节点的所有邻居节点，把每个邻居节点分别添加到path后面形成新的路径，添加到路径队列中去
        for neighbor_node in graph.get(last_node,[]):
            # 创建一个新的路径对象，防止内存覆盖
            new_path = list(path)
            # 添加邻居节点到new_path中形成一条新的路径
            new_path.append(neighbor_node)
            # 如果new_path不在队列中，则将其入队
            if new_path not in paths_queue:
                paths_queue.append(new_path)
    # 从all_paths中过滤出最短路径列表
    shortest_paths_len = len(min(all_paths,key = lambda path:len(path)))
    shortest_paths = [path for path in all_paths if len(path) == shortest_paths_len]
    return shortest_paths,all_paths
    
def output(paths):
    '''
    更好地输出路径
    
    :param paths: 路径列表，每条路径都是一个节点列表
    :return: 一个路径字符串
    '''
    for path in paths:
        print '->'.join(path)

def main():
    # 构建图，有一个前提假设：图中的姓名没有重复的（保证唯一性）
    graph = {
        'you':['Tony','John','Tom'],
        'Tony':['Alice','Andy'],
        'John':['Nancy','Ben'],
        'Tom':['Andy','Mike'],
        'Andy':['Mike','Mercy'],
        'Nancy':['Ben'],
        'Ben':['Tom']
    }
    start,goal = 'you','Mike'
    shortest_paths,all_paths = BFS(graph,start,goal)
    print '>>> shortest_paths from {0} to {1}:'.format(start,goal)
    output(shortest_paths)
    
    print '\n'
    print '>>> all_paths from {0} to {1}:'.format(start,goal)
    output(all_paths)

if __name__ == '__main__':
    main()
    '''
    输出：
    >>> shortest_paths from you to Mike:
    you->Tom->Mike

    >>> all_paths from you to Mike:
    you->Tom->Mike
    you->Tony->Andy->Mike
    you->Tom->Andy->Mike
    you->John->Ben->Tom->Mike
    you->John->Nancy->Ben->Tom->Mike
    you->John->Ben->Tom->Andy->Mike
    you->John->Nancy->Ben->Tom->Andy->Mike
    '''

BFS算法时间复杂度

O(V+E)
其中V为图中的节点数，E为图中的边数。

BFS算法特点一句话总结

地毯式稳步推进，不留死角。

总结

本文中通过BFS算法找到了你的关系网中离你最近的芒果商，一开始只是找到了离你最近的芒果商，而并不知道路径该怎么走；后来进一步又优化了算法，找到了能够联系到芒果商的最短路径。

代码已经更新至：我的GitHub