/// <summary> /// Find the neighbors from a node. /// </summary> /// <param name="node">The node to be processed.</param> /// <param name="openList">The list to receive the neighbors.</param> static void GetNeighbors(SPNode node, List<SPNode> openList, List<SPNode> closedList) { for (int i = 0; i < node.Neighbors.Count; i++) { SPNode neighbor = node.Neighbors[i]; if (closedList.Contains(neighbor)) continue; if (openList.Contains(neighbor)) continue; neighbor.PreviousNode = node; neighbor.WeightToReachFromPreviousNode = node.WeightToReachFromPreviousNode + neighbor.Weight; openList.Add(neighbor); } }
/// <summary> /// Finds the least cost node (remove it from list before returning). /// </summary> /// <returns>The least cost node in the list.</returns> static SPNode GetLeastCostNode(List<SPNode> openList) { SPNode leastCostNode = openList[0]; int leastCostNodeWeight = leastCostNode.WeightToReachFromPreviousNode; for (int i = 1; i < openList.Count; i++) { SPNode nextNode = openList[i]; int nextNodeWeight = nextNode.WeightToReachFromPreviousNode; if (nextNodeWeight < leastCostNodeWeight) { leastCostNode = nextNode; leastCostNodeWeight = leastCostNode.WeightToReachFromPreviousNode; } } openList.Remove(leastCostNode); return leastCostNode; }
/// <summary> /// Build a list from the shortest path found. /// </summary> static SPNode[] BuildShortestPathList(SPNode targetNode, List<SPNode> list) { SPNode prevNode = targetNode.PreviousNode; List<SPNode> spList = new List<SPNode>(); // If the target node wast found, return null. if (list.Find(x => x.ID == targetNode.ID) == null) return null; spList.Add(targetNode); while ((prevNode != null) && (prevNode != prevNode.PreviousNode)) { spList.Add(prevNode); prevNode = prevNode.PreviousNode; } spList.Reverse(); return spList.ToArray(); }
/// <summary> /// Test C. /// Graph (# represents heavy weight paths. heavy nodes are D and H.): /// /// A----B----C /// # | \ | /// # | \ | /// D ## E----F /// # # | /// # # | /// G ## H ###I // Expected path: A -> B -> F -> I // Expected path: 0 -> 1 -> 5 -> 8 /// </summary> public static void TestC() { SPNode nodeA = new SPNode(0, 1); SPNode nodeB = new SPNode(1, 1); SPNode nodeC = new SPNode(2, 1); SPNode nodeD = new SPNode(3, 3); SPNode nodeE = new SPNode(4, 1); SPNode nodeF = new SPNode(5, 1); SPNode nodeG = new SPNode(6, 1); SPNode nodeH = new SPNode(7, 3); SPNode nodeI = new SPNode(8, 1); nodeA.AddNeighbor(nodeB, nodeD); nodeB.AddNeighbor(nodeA, nodeC, nodeE, nodeF); nodeC.AddNeighbor(nodeB, nodeF); nodeD.AddNeighbor(nodeA, nodeE, nodeG); nodeE.AddNeighbor(nodeB, nodeD, nodeF, nodeH); nodeF.AddNeighbor(nodeC, nodeE, nodeI); nodeG.AddNeighbor(nodeD, nodeH); nodeH.AddNeighbor(nodeE, nodeG, nodeI); nodeI.AddNeighbor(nodeF, nodeH); List<SPNode> nodesList = new List<SPNode>() { nodeA, nodeB, nodeC, nodeD, nodeE, nodeF, nodeG, nodeH, nodeI }; SPNode[] sp = ShortestPath.FindShortestPath(0, 8, nodesList); ShortestPath.DumpPath(new List<SPNode>(sp)); }
/// <summary> /// Checks if the node is present in the list. /// </summary> /// <param name="node">The node to look for.</param> /// <param name="closedList">The list to be searched.</param> /// <returns>true if the node is in the list; false otherwise</returns> static bool CheckNodeInList(SPNode node, List<SPNode> closedList) { SPNode targetNode = closedList.Find(x => x.ID == node.ID); return (targetNode != null); }