dijkstra算法 计算最短路径 js整理

从起点到终点的最短权重路径

• 建立三个散列表

1. 各个顶点的邻居信息及开销对应表
2. 初始化到各个点的开销，未知的按无穷大计算
3. 初始化各个顶点的对应的父级，未知的按null算

// 记录各个顶点的邻居情况
const graph = {
	 S: { A: 5, B: 2 },
	 A: { C: 4, D: 2 },
	 B: { A: 8, D: 7 },
	 C: { F: 3, D: 6 },
	 D: { F: 1 },
	 F: {}
}
// 记录初始情况起点到各个顶点的开销
const costs = {
	 A: 5,
	 B: 2,
	 C: Infinity,
	 D: Infinity,
	 F: Infinity,
}
// 记录初始情况各个顶点的父级
const parents = {
	 A: 'S',
	 B: 'S',
	 C: null,
	 D: null,
	 F: null
}

• 一个数组
  记录已经遍历过的节点，避免重复遍历

const processed = []

• 每次遍历需要查找最小开销的节点
  默认最小开销为无穷大，遍历开销列表costs中开销最小的节点返回，如果改节点已经被处理过就跳过该节点

function findLowestCostNode () {
  let lowestCost = Infinity
  let lowestCostNode = null
  for (let i in costs) {
    if (costs[i] <= lowestCost && processed.indexOf(i) < 0) {
      lowestCost = costs[i]
      lowestCostNode = i
    }
  }
  return lowestCostNode
}

• 遍历最小开销的节点的邻居，修改开销表和父级表中的数据

function dijkstra () {
   let node = findLowestCostNode()
   if (!node) {
     return
   }
   let cost = costs[node] // 记录起点到当前节点的开销
   let neiber = graph[node]
   for (let i in neiber) {
     let newCost = neiber[i] + cost
     if (costs[i] > newCost) {
       costs[i] = newCost
       parents[i] = node
     }
   }
   processed.push(node)
   dijkstra()
}

• 调用和结果打印

dijkstra()
let arr = ['F']
function printPath (node) {
  console.log(parents[node])
  if (parents[node] !== undefined) {
    arr.unshift(parents[node])
    printPath(parents[node])
  }
}
printPath('F')
console.log('最短路径:', arr.join('->'))
console.log('最短用时:', costs.F)