# Find shortest paths in a network C#

This example shows one method for finding shortest paths in a network such as a street, telephone, or computer network. It’s a fairly advanced example adapted from my book Essential Algorithms: A Practical Approach to Computer Algorithms. See the book for more in-depth discussion and for a description of lots of other interesting algorithms.

To use the program, open the File menu and select Open to load a network from a text file. Click the left mouse button on a node to build the shortest path tree (described shortly) rooted at that node. Then right-click on a node to display the shortest path from the root node to the node you right-clicked.

The following PathSNode class represents a node in the network.

class PathSNode
{
public enum NodeStatusType
{
NotInList,
WasInList,
NowInList
}

public int Id;
public Point Location;
public Dictionary Links = new Dictionary();
public int Dist;                    // Distance from root.
public NodeStatusType NodeStatus;   // Path tree status.
}

Most of this is straightforward. The Links field holds the links that lead in or out of this node. The Dist, NodeStatus, and InLink fields are used by the shortest path algorithm described later.

{
{
Unused,
InTree,
InPath
}

public PathSNode Node1, Node2;
public int Cost;
}

This class is also fairly straightforward, except perhaps for the LinkUsage field. It’s also used by the algorithm described shortly.

The following FindPathTree method uses a label setting method to find a shortest path tree rooted at a particular node. By following links from a destination node back through the tree, you can trace the shortest path from the root node to the destination node.

// Find a shortest path tree rooted at this node
// using a label setting algorithm.
private void FindPathTree(PathSNode root)
{
if (root == null) return;
Root = root;

List candidates = new List();

// Reset all nodes' Marked and NodeStatus values,
ResetPathTree();

root.Dist = 0;
root.NodeStatus = PathSNode.NodeStatusType.NowInList;

// Process the candidates.
while (candidates.Count > 0)
{
// Find the candidate closest to the root.
int best_dist = int.MaxValue;
int best_i = -1;
for (int i = 0; i < candidates.Count; i++)
{
PathSNode candidate_node = candidates[i];
int new_dist = candidate_node.Dist;
if (new_dist < best_dist)
{
best_i = i;
best_dist = new_dist;
}
}

// Add this node to the shortest path tree.
PathSNode node = candidates[best_i];
candidates.RemoveAt(best_i);
node.NodeStatus = PathSNode.NodeStatusType.WasInList;

// Examine the node's neighbors.
{
PathSNode to_node;
{
}
else
{
}
if (to_node.NodeStatus ==
PathSNode.NodeStatusType.NotInList)
{
// The node has not been in the candidate list.
to_node.NodeStatus =
PathSNode.NodeStatusType.NowInList;
}
else if (to_node.NodeStatus ==
PathSNode.NodeStatusType.NowInList)
{
// The node is in the candidate list.
// Update its Dist and inlink values if necessary.
int new_dist = best_dist + link.Cost;
if (new_dist < to_node.Dist)
{
to_node.Dist = new_dist;
}
}
} // while (candidates.Count > 0)

GotPathTree = true;

// Mark the inlinks so they are easy to draw.
foreach (PathSNode node in Nodes.Values)
{
{
}
}

Destination = null;

// Redraw the network.
this.Refresh();
}

The basic idea is this. The algorithm builds a shortest path tree incrementally. It keeps a candidate list that holds nodes that are one link away from some node that is in the current shortest path tree. It keeps track of the best distance so far through the tree to every node in the tree and to the nodes in the candidate list.

While the candidate list is not empty, the program finds the node in the list with the shortest distance to the root node. Because that node is the closest one to the root, adding other nodes to the shortest path tree cannot improve the path to this node. (You can think about why this is true, but the idea is that any path to this node via some other node that is not yet in the tree would be longer.) The program adds that node to the shortest path tree and removes it from the candidate list.

Next the program considers all of the neighbors of the newly added node. If the path to a neighbor via this node is shorter than the path it has currently recorded to the root node, then the program updates the neighbor’s path to use the newly added node. It then adds the neighbor to the candidate list (if it is not already in the list).

The program continues this process, removing a node from the candidate list, adding it to the shortest path tree, and adding its neighbors to the candidate list until the list is empty. At that point the shortest path tree is complete.

This algorithm is called a “label setting” algorithm because once you add a node to the shortest path tree, it is labeled with it’s final distance to the root node and that distance is never changed. (In contrast, a “label correcting” algorithm may add a node to the tree with a given distance and then later update its distance when it finds a better path to the node.)

I know this discussion is fairly terse. See the code for additional details such as how the program loads a network from a text file and how it handles mouse clicks. See my book Essential Algorithms: A Practical Approach to Computer Algorithms for a more complete explanation, more information on shortest path algorithms, and other useful algorithms.

This entry was posted in algorithms and tagged , , , , , , , , , , , , . Bookmark the permalink.

### 5 Responses to Find shortest paths in a network C#

1. Nera says:

thank you for this coding.
There is a question.
One node can remove it?

• RodStephens says:

This example doesn’t let you build the network. You can edit the network files to make a network. Or you could build a program to do it. (Or hire me to do it.) I think the algorithms book I mention in the post also shows how to do that.

2. hi
can you share all program.
i am making program for planar graph drawer.. i didnt find algortihm for node. becasue my nodes crashing 😀

maybe your program can be help my problem. forgive me may english

see you..

• RodStephens says:

Do you mean you want a program to create graphs? I don’t have one for this right now. My book Essential Algorithms: A Practical Approach to Computer Algorithms includes a network builder that does this, but you should be able to build your own with some work. Make different tools to put the program into different modes. Use one to place new nodes and another to connect nodes with segments.

3. Gray says:

Thankyou so much for sharing this wonderful code, with a precise explanation

This site uses Akismet to reduce spam. Learn how your comment data is processed.