算法入门——广度优先遍历、Dijkstra python实现

广度优先搜索算法(Breadth First Search，BSF)，思想是：

• 1.从图中某顶点v出发，首先访问定点v
• 2.在访问了v之后依次访问v的各个未曾访问过的邻接点；
• 3.然后分别从这些邻接点出发依次访问它们的邻接点，并使得“先被访问的顶点的邻接点先于后被访问的顶点的邻接点被访问;
• 4.直至图中所有已被访问的顶点的邻接点都被访问到;
• 5.如果此时图中尚有顶点未被访问，则需要另选一个未曾被访问过的顶点作为新的起始点，重复上述过程，直至图中所有顶点都被访问到为止。

python代码（队列实现）：

graph={}#字典，散列表
graph["you"]=["alice","bob","claire"]
graph["bob"]=["anuj","peggy"]
graph["alice"]=["peggy"]
graph["claire"]=["thom","jonny"]
graph["anuj"]=[]
graph["peggy"]=[]
graph["thom"]=[]
graph["jonny"]=[]



from collections import deque
def search(name):
    search_queue=deque()
    search_queue+=graph[name]
    searched=[]
    while search_queue:
        person=search_queue.popleft()
        if person not in searched:
            if person_is_seller(person):
                print(per"seller!")
                return True
            else:
                search_queue+=graph[person]
                searched.append(person)
    return False


def person_is_seller(name):
    return name[-1]=='m'


search("you")

 

 

迪杰斯特拉算法是求从某一个起点到其余所有结点的最短路径，是一对多的映射关系，是一种贪婪算法.

迪杰斯特拉算法每次只找离起点最近的一个结点，并将之并入已经访问过结点的集合（以防重复访问，陷入死循环），然后将刚找到的最短路径的结点作为中间结点来更新相邻结点的路径长度，这样循环找到图中一个个结点的最短路径。

python实现:

graph={}
#graph["you"]=["alice","bob","claire"]

graph["start"]={}
graph["start"]["a"]=6
graph["start"]["b"]=2

graph["a"]={}
graph["a"]["fin"]=1

graph["b"]={}
graph["b"]["a"]=3
graph["b"]["fin"]=5

graph["fin"]={}

infinity=float("inf")
costs={}
costs["a"]=6
costs["b"]=2
costs["fin"]=infinity

parents={}
parents["a"]="start"
parents["b"]="start"
parents["fin"]=None

processed=[]#记录处理过的节点

def find_lowest_cost_node(costs):
    lowest_cost=float("inf")
    lowest_cost_note=None
    for node in costs:
        if costs[node]<lowest_cost and node not in processed:#该节点开销更低切未被处理过
            lowest_cost=costs[node]
            lowest_cost_note=node
    return lowest_cost_note


node= find_lowest_cost_node(costs)
while node is not None:
    cost=costs[node]
    neighbors=graph[node]
    for n in neighbors.keys():
        new_cost=cost+neighbors[n]
        if new_cost<costs[n]:
            costs[n]=new_cost#更新代价
            parents[n]=node#更新父节点s
    processed.append(node)
    node=find_lowest_cost_node(costs)