python写算法求最短路径_python最短路径算法，基于dijkstra

graph.py

#!/usr/bin/python

class Edge(object):

def __init__(self, start, end, weight):

self.startNodeId = start

self.endNodeId = end

self.weight = weight

class Node(object):

def __init__(self, nodeId, edgeList):

self.nodeId = nodeId

self.edgeList = edgeList

class Path(object):

def __init__(self, curNodeId):

self.visited = False

self.weight = 8888

self.curNodeId = curNodeId

self.routeList = []

class Graph(object):

def __init__(self, nodeList):

self.nodeList = nodeList

self.pathDic = {}

def initPaths(self, originNodeId):

self.pathDic = {}

originNode = None

for node in self.nodeList:

if node.nodeId == originNodeId:

originNode = node

self.pathDic[node.nodeId] = Path(node.nodeId)

if originNode is None:

print "originNode is none"

return

else:

for edge in originNode.edgeList:

path = self.pathDic[edge.endNodeId]

if path is None:

print "path is None"

return

else:

path.weight = edge.weight

path.routeList.append(originNodeId)

path = self.pathDic[originNodeId]

path.weight = 0

path.visit = True

path.routeList.append(originNodeId)

def getMinPath(self, originNodeId):

destNode = None

weight = 8888

for node in self.nodeList:

path = self.pathDic[node.nodeId]

if path.visited == False and path.weight < weight:

weight = path.weight

destNode = node

return destNode

def dijkstra(self, originNodeId, destNodeId):

self.initPaths(originNodeId)

curNode = self.getMinPath(originNodeId)

while curNode is not None:

curPath = self.pathDic[curNode.nodeId]

curPath.visited = True

for edge in curNode.edgeList:

minPath = self.pathDic[edge.endNodeId]

if minPath.weight > (curPath.weight + edge.weight):

minPath.weight = curPath.weight + edge.weight

minPath.routeList = curPath.routeList + [curNode.nodeId]

curNode = self.getMinPath(originNodeId)

route = self.pathDic[destNodeId].routeList

if route == []:

return route

else:

return route + [destNodeId]

test.py

#!/usr/bin/python

#coding:utf-8

from dijkstra import Edge as Edge

from dijkstra import Node as Node

from dijkstra import Graph as Graph

edge11 = Edge("A", "B", 10)

edge12 = Edge("A", "C", 20)

edge13 = Edge("A", "E", 30)

edge21 = Edge("B", "C", 5)

edge22 = Edge("B", "E", 10)

edge31 = Edge("C", "D", 30)

edge51 = Edge("E", "D", 10)

node1 = Node("A", [edge11, edge12, edge13])

node2 = Node("B", [edge21, edge22])

node3 = Node("C", [edge31])

node4 = Node("D", [])

node5 = Node("E", [edge51])

graph = Graph([node1, node2, node3, node4, node5])

startNodeId = raw_input("请输入起点: ")

endNodeId = raw_input("请输入终点: ")

print "最短路径:", graph.dijkstra(startNodeId, endNodeId), "\n"