迪克斯特拉’；python中的s算法

我试图在我的python代码上实现Dijkstra的算法，但我不能真正正确地实现算法。我使用的算法来自以下youtube链接：

所以我的类基本上有以下3个变量：

self.nodes = [] #a,b,c
self.neighbours = {} # a:[b,c], b:[c], c:[a]
self.weights = {} #[a,b] = 2, [a,c] = 5

下面是我如何使用视频中提供的算法部分实现我的最短路径功能：

def dijkstra(self, start, end):

    nodes = {}

    for n in self.nodes:
        if n == start:
                nodes[n] = 0
        else:
                nodes[n] = float('inf')

    unvisited = self.neighbours
    visited = []
    current_node = start
    current_distance = 0

    while unvisited:
        for n in unvisited[current_node]:
            print(n)
            #calc_weight = nodes[n] + self.weights[n, current_node]
            #if (unvisited[n] is None or calc_weight > nodes[n]):
                    #nodes[n] = calc_weight
        visited.append(current_node)
        del unvisited[current_node]

        if not unvisited: break

我还没有真正完成，因为我知道我遗漏了一些东西。谁能帮我一下吗。谢谢你

def dijkstra（self，start，end）：
def dijkstra(self, start, end):

    nodes = self.neighbours #{'A': {'B':2}, 'B': {'C':4}, ... }

    unvisited = {n: 1000 for n in self.nodes} #unvisited node & distance
    unvisited[start] = 0 #set start vertex to 0
    visited = {} #list of all visited nodes
    parent = {} #predecessors

    while unvisited:
        min_node = min(unvisited, key=unvisited.get) #get smallest distance

        for neighbour in nodes[min_node].items():
            if neighbour not in visited:
                new_distance = unvisited[min_node] + nodes[min_node][neighbour]
                if new_distance < unvisited[neighbour]:
                    unvisited[neighbour] = new_distance
                    parent[neighbour] = min_node

        visited[min_node] = unvisited[min_node]
        unvisited.pop(min_node)

    print(parent, visited)

nodes=self.neights{'A'：{'B'：2}，'B'：{'C'：4}，…}
未访问={n:1000表示self.nodes中的n}#未访问的节点和距离
未访问[开始]=0#将开始顶点设置为0
已访问={}#所有已访问节点的列表
父={}#前辈
未访问时：
min_node=min（未访问，key=unvisited.get）#获取最小距离
对于节点[min_node]中的邻居。项（）
如果邻居未到访：
新距离=未访问的[最小节点]+节点[最小节点][邻居]
如果新距离<未访问[邻居]：
未访问[邻居]=新距离
父[邻居]=最小节点
已访问[最小节点]=未访问[最小节点]
unvisited.pop（最小节点）
打印（家长，已访问）

def dijkstra（自我、开始、结束）：
nodes=self.neights{'A'：{'B'：2}，'B'：{'C'：4}，…}
未访问={n:1000表示self.nodes中的n}#未访问的节点和距离
未访问[开始]=0#将开始顶点设置为0
已访问={}#所有已访问节点的列表
父={}#前辈
未访问时：
min_node=min（未访问，key=unvisited.get）#获取最小距离
对于节点[min_node]中的邻居。项（）
如果邻居未到访：
新距离=未访问的[最小节点]+节点[最小节点][邻居]
如果新距离<未访问[邻居]：
未访问[邻居]=新距离
父[邻居]=最小节点
已访问[最小节点]=未访问[最小节点]
unvisited.pop（最小节点）
打印（家长，已访问）

wikipedia:。甚至还有伪代码。你的问题解决了吗？@Shasha99没有。我似乎无法正确使用该算法。前面的评论没有帮助，一个让我找到了另一个算法，它不是真正的答案，而第二个让我找到了一个hello world程序。我实际上是在说：你应该实现最小堆以获得最佳解决方案。wikipedia:。甚至还有伪代码。你的问题解决了吗？@Shasha99没有。我似乎无法正确使用该算法。前面的评论没有帮助，一个引导我到另一个算法，它不是真正的答案，而第二个引导我到一个hello world程序。我实际上是在谈论这个：你应该实现最小堆以获得最佳解决方案。为了在目标（结束）时退出循环节点被命中您需要：

如果min\u node==end:break

对于未定义的边，您需要

节点[min\u node]。get（nexter，1000）

而不是

节点[min\u node][nexter]

同样，使用

float（“inf”）

优于

1000

。以便在目标（end）到达时退出循环节点被击中，您需要：

如果min\u node==end:break

对于未定义的边，您需要

节点[min\u node]。获取（邻居，1000）

而不是

节点[min\u node][邻居]

同样，使用

浮点（“inf”）

比

1000更可取。