A Performance Comparison of Shortest Path Algorithms in Directed Graphs ^†

Abstract

This study examines the performance characteristics of four commonly used short-path algorithms, including Dijkstra, Bellman–Ford, Floyd–Warshall, and Dantzig, on randomly generated directed graphs. We analyze theoretical computational complexity and empirical execution time using a custom-built testing framework. The experimental results demonstrate significant performance differences across varying graph densities and sizes, with Dijkstra’s algorithm showing superior performance for sparse graphs while Floyd–Warshall and Dantzig provide more consistent performance for dense graphs. Time complexity analysis confirms the theoretical expectations: Dijkstra’s algorithm performs best on sparse graphs with O (E + V log V) complexity, Bellman–Ford shows O (V · E) complexity suitable for graphs with negative edges, while Floyd–Warshall and Dantzig both demonstrate O(V³) complexity that becomes efficient for dense graphs. This research provides practical insights for algorithm selection based on specific graph properties, guiding developers and researchers in choosing the most efficient algorithm for their particular graph structure requirements.

1. Introduction

Finding the shortest path between vertices in a graph is a fundamental problem in computer science with numerous practical applications, including network routing, transportation planning, robotics, and social network analysis. Several algorithms have been developed to solve this problem, each with its own advantages and limitations depending on the graph characteristics and constraints [1,2,3].

The shortest path problem involves finding a path between two vertices in a graph such that the sum of the weights of its constituent edges is minimized. For directed graphs, this problem becomes more complex, especially when considering factors such as edge weights, graph density, and the presence of negative cycles [4,5,6].

The current study is focused on comparing four widely used shortest path algorithms: (1) Dijkstra’s algorithm, a greedy algorithm that works efficiently for graphs with non-negative edge weights [7]; (2) the Bellman–Ford algorithm, which is capable of handling graphs with negative edge weights and detecting negative cycles [8,9]; (3) the Floyd–Warshall algorithm, an all-pairs shortest path algorithm based on dynamic programming [10,11]; and (4) Dantzig’s algorithm, a variant of Dijkstra’s algorithm that processes vertices in a different order [12,13].

While the theoretical time complexities of these algorithms are well established, their practical performance can vary significantly depending on the graph structure, size, and implementation details. This research aims to provide empirical evidence comparing these algorithms across various graph configurations to assist in algorithm selection for specific use cases.

In this study, the main objectives are to compare the execution times of the four algorithms on randomly generated directed graphs of varying sizes and densities; analyze how theoretical complexity translates to practical performance; identify the conditions under which each algorithm performs optimally; and provide recommendations for algorithm selection based on graph properties.

2. Methods

2.1. Testing Framework

A custom testing framework was developed in C# using the Windows Forms framework for visualization and the Microsoft Automatic Graph Layout (MSAGL) library for graph rendering [14,15,16]. The framework allows for the following:

• Random generation of directed graphs with controllable parameters;
• Implementation and execution of the four shortest path algorithms;
• Measurement of execution time and visualization of results;
• Comparison of algorithm performance across multiple metrics.

2.2. Graph Generation Methodology

Here, ‘sparse’ refers to graphs where $E \approx O\left(V\right)$, and ‘dense’ refers to graphs where $E \approx O\left(V^2\right)$. The framework generates random directed graphs with the following configurable parameters:

• Minimum and maximum number of vertices (V).
• Minimum and maximum edge density (as a ratio of possible edges).
• Edge weight range (1–10 in the current implementation).

For each generated graph, source (S) and target (T) vertices are randomly selected to establish the shortest path problem instance. The graph generation process ensures the following:

• No self-loops are created (edges from a vertex to itself);
• Edge weights are positive integers;
• Source and target vertices are distinct.

3. Results and Discussion

All four algorithms for finding the shortest path in a graph—Dijkstra, Bellman—Ford, Floyd—Warshall, and Dantzig—were implemented to solve the single-source, single-target shortest path problem. Figure 1 shows the user interface of the testing framework with controls for graph generation parameters and algorithm visualization.

3.1. Algorithm Implementations

All four algorithms were implemented to solve the single-source, single-target shortest path problem.

3.1.1. Dijkstra’s Algorithm

The implementation of Dijkstra’s algorithm follows the standard approach, where the vertices ($Vs$) are marked as “colored” once they are permanently labeled; a priority queue implicitly manages the next vertex to process. The algorithm terminates once the target vertex is colored or all reachable vertices are processed. The time complexity of the algorithm is $O(E+V log V)$, where $E$ is the number of edges and $V$ is the number of vertices.

3.1.2. Bellman–Ford Algorithm

During the implementation of the Bellman–Ford algorithm, the distances from the source to all vertices are initialized as$infinity(\infty )$, except for the source $\left(0\right)$. It relaxes all edges $V-1$ times, where $V$is the number of vertices, and terminates early if no relaxation is performed in an iteration. The time complexity of the algorithm is $O(V·E)$, where $V$is the number of vertices and $E$ is the number of edges.

3.1.3. Floyd–Warshall Algorithm

In Floyd–Warshall’s implementation, we initialize a distance matrix representing direct edges between vertices. The algorithm iteratively improves paths by considering all vertices as intermediate points and constructs the shortest path by tracing through the resulting matrices. The time complexity of the algorithm is $O\left(V^3\right)$, where $V$is the number of vertices.

3.1.4. Dantzig’s Algorithm

The implementation of Dantzig’s algorithm involves coloring the vertices of the graph with labels as they are processed (similar to Dijkstra coloring). The edge with the minimum weight connecting a labeled vertex to an un-tagged vertex is chosen. The algorithm continues until all vertices are labeled or the target is reached. The time complexity of the algorithm is $O\left(V^3\right)$in the worst case, where $V$is the number of vertices.

3.2. Performance Metrics and Testing Environment

The following metrics were tested for each algorithm: execution time in microseconds, time complexity based on the graph size and path weight (if such a path existed), and whether the algorithm was able to find the shortest path.

All tests were conducted on a system with the following specifications:

• Processor: AMD Ryzen 7 7800X3D 8-Core Processor;
• Memory: 32 GB DDR5 6400 MHz;
• Operating System: Windows 10;
• Development Environment: Visual Studio 2022.

3.3. Comparative Execution Time

Execution times were measured across multiple randomly generated graphs of varying sizes and densities. Figure 2 shows the execution of the software with a solved path highlighted in green, demonstrating how the program visualizes the solution.

In

Table 1. Execution time comparison (in microseconds) of shortest path algorithms across different graph sizes.

Graph Size	Dijkstra	Bellman—Ford	Floyd—Warshall	Dantzig
7V, 14E	1.7	5.8	10.9	10.4
17V, 28E	3.9	6.8	30.1	29.9
41V, 82E	8.3	29.2	283.3	295.6
659V, 1538E	309.5	3601.2	1,112,193	9617.9
657V, 2168E	3015.2	5315.2	1,429,713	1,521,213
1000V, 2800E	3298.4	10,902.2	4,492,317	551,157.7

, the execution times of all four algorithms are shown for different graph configurations, from small graphs with a few vertices to large graphs with over 1000 vertices.

The execution time results show significant variations among the algorithms. Dijkstra’s algorithm consistently performs fastest for sparse graphs, with execution times typically below 10 microseconds for small graphs $(V<20)$and scaling well up to medium-sized graphs.

The algorithm of Bellman–Ford shows moderate performance, with execution times typically 2–3 times slower than Dijkstra’s for comparable graphs.

The algorithms of Floyd–Warshall and Dantzig show similar performance characteristics, with execution times growing significantly for larger graphs.

For very large graphs $(V>500)$, the execution time differences become significant, with Dijkstra’s algorithm outperforming the Floyd–Warshall algorithm by factors of 100–1000×.

For larger graphs where visualization was disabled, the performance differences became more pronounced:

• Dijkstra’s algorithm maintained relatively good performance up to several hundred vertices (around 3298 microseconds for 1000 vertices);
• The Bellman–Ford algorithm’s performance deteriorated more rapidly with increasing vertices and edges (10,902 microseconds for 1000 vertices);
• The Floyd–Warshall and Dantzig algorithms showed consistent but slower performance for larger graphs, with execution times in the millions of microseconds for graphs with 1000 vertices.

3.4. Complexity Analysis

The time complexity of each algorithm was calculated for each test case, as shown in

Table 2. Theoretical complexity values for different graph configurations.

Graph Size	Dijkstra O(E + V log V)	Bellman—Ford O(V·E)	Floyd—Warshall O(V3)	Dantzig O(V3)
7V, 14E	27.6	98	343	343
17V, 28E	76.9	476	4913	4913
41V, 82E	234.3	3362	68,921	68,921
659V, 1538E	5890.4	1,078,922	29,418,309	29,418,309
657V, 2168E	6430.4	1,424,376	283,593,393	283,593,393
1000V, 2800E	9707.8	2,800,000	1,000,000,000	1,000,000,000

. These calculations confirm the expected asymptotic behavior.

The execution time results show significant variations among the algorithms: Dijkstra$-O(E+V log V)$, Bellman–Ford—$O(V·E)$, Floyd–Warshall—$O\left(V^3\right),$ and Dantzig—$O\left(V^3\right)$.

These theoretical values were consistent with the observed execution times, confirming that the implementation of each algorithm matches its expected performance characteristics. For example, in a graph with 659 vertices and 1538 edges, the complexity values were Dijkstra: 5890.4; Bellman–Ford: 1,078,922; Floyd–Warshall: 29,418,309; and Dantzig: 29,418,309.

The relative performance of these algorithms’ changes with graph density. For sparse graphs (where $E\approx V$), Dijkstra’s algorithm maintains its advantage, but for dense graphs (where $E$ approaches V²), the difference becomes less pronounced.

3.5. Path-Finding Success

All algorithms correctly identified when no path existed between the source and target vertices, as demonstrated in Figure 3, where all four algorithms report \”No Path Found\” for the same graph. When paths existed, all algorithms found the same optimal path, though their execution times varied significantly.

Figure 4 shows a successful path-finding operation on a medium-sized graph, with the optimal path highlighted in green. All four algorithms found the same path with a weight of 27, but their execution times varied from 8.3 microseconds for Dijkstra to 283.3 microseconds for Floyd–Warshall.

3.6. Algorithm Performance Characteristics

The obtained results in the current study demonstrate clear performance trade-offs among the algorithms [17,18,19].

• Dijkstra’s algorithm.

The algorithm of Dijkstra is characterized by the best performance for sparse graphs with positive edge weights. The performance advantage decreases as the density of the graph increases. This algorithm is best suited for real-time applications with large but sparse graphs. A graph’s complexity increases with size at a speed that corresponds to its $O(E+V log V)$ execution time. The pseudocode of Dijkstra’s algorithm is presented in Algorithm 1.

Algorithm 1: Dijkstra’s Algorithm

2.

Bellman–Ford Algorithm.

The algorithm of Bellman–Ford is characterized by moderate performance for small to medium graphs. It works with negative edge weights, which will be further developed in future work. The performance of the algorithm deteriorates more rapidly than that of Dijkstra’s algorithm as the graph size increases. The running time scales with the product of vertices and edges, as expected. The pseudocode of the algorithm of Bellman—Ford is presented in Algorithm 2.

Algorithm 2: Bellman–Ford Algorithm

3.

Floyd—Warshall Algorithm.

The algorithm of Floyd–Warshall is characterized by constant performance regardless of the graph structure. It calculates shortest paths for all pairs, providing more information than a single-source, single-destination problem would require. The algorithm is more efficient when multiple shortest paths need to be computed from the same graph, and the running time scales cubically with the number of vertices. The pseudocode of the algorithm of Floyd–Warshall is presented in Algorithm 3.

Algorithm 3: Floyd–Warshall Algorithm

4.

Dantzig’s Algorithm

The algorithm of Danzig for finding the shortest path in a given graph is characterized by a performance similar to that of the Floyd–Warshall algorithm. It can terminate its operation earlier when the target vertex is found. It is also characterized by more predictable performance in different graph structures and shows cubic scaling with respect to the number of vertices. The pseudocode of Danzig’s algorithm is presented in Algorithm 4.

Algorithm 4: Dantzig’s Algorithm

Based on the obtained results, the following recommendations can be made:

1. For sparse graphs with positive edge weights, Dijkstra’s algorithm demonstrates clear superiority in performance. As observed in our experiments, it significantly outperformed the other algorithms by several orders of magnitude for large-scale sparse graphs.

2. For graphs with negative edge weights, the Bellman−Ford algorithm is the recommended choice among the four algorithms, as it is theoretically capable of handling such cases. However, this recommendation is based on the algorithm’s known properties rather than the empirical results of this study, which focused on graphs with positive weights.

3. For dense graphs where the ratio of edges to vertices is high, the algorithm of Floyd–Warshall may outperform the algorithm of Dijkstra due to its consistent $O\left(V^3\right)$time complexity, which is unaffected by edge density. The performance advantage becomes evident as the number of graph vertices grows beyond several hundred. For dense graphs (e.g., 1000V with 2800E), Floyd–Warshall’s execution time (4,492,317 μs) was significantly higher than Dijkstra’s (3298.4 μs) for single-source problems. However, its all-pairs computation becomes advantageous when multiple shortest paths are needed, justifying its upfront cost in such scenarios.

4. When multiple shortest path calculations are needed on the same graph, Floyd–Warshall’s all-pairs approach provides substantial efficiency benefits that outweigh its initially higher computational complexity.

5. For extremely large graphs (e.g.,$V>1000$), specialized implementations or alternative algorithms should be considered, as even Dijkstra’s algorithm begins to show significant execution time increases.

In the implementation of this study, randomly generated graphs were used, which may not fully represent the specifics of graph structures in the real world, where certain patterns and characteristics may be more common. The tests were conducted only on graphs with positive edge weights, limiting the full representation of the Bellman−Ford algorithm, which also works with negative weights. This development will be added to the next study of algorithms [20,21,22,23].

The performance of algorithms for finding shortest paths can be further improved by adding various optimizations to them. Dijkstra’s algorithm can improve its performance by using a priority queue. This is of great importance when dealing with multi-vertex graphs, as well as in real-world applications where optimal resource utilization and task execution times are critical to application performance.

The largest graphs tested had 1000 edges, which may not be sufficient to observe the asymptotic behavior of very large graphs that may be encountered in real-world applications. The current study does not consider memory usage, which can be an important factor for large graphs, especially when evaluating the Floyd–Warshall algorithm, where the need for O(V²) storage space is critical.

During our next research on this topic, we plan to include additional structures and metrics, including memory consumption and scalability, to measure the performance of each algorithm.

4. Conclusions

This study presents a developed software application with a graphical user interface, which allows for a comparison of four of the most common algorithms for finding the shortest path, which are applied to different types of graphs. Based on the results obtained, the expectations for the time complexity of the algorithms are confirmed. The developed application provides users with practical guidelines for choosing an appropriate algorithm depending on the specific characteristics of the given graph.

As a result, Dijkstra’s algorithm is more efficient for sparse graphs with positive edge weights, making it highly applicable to real systems, especially those with limited time resources. The Bellman−Ford algorithm, on the other hand, has the advantage of processing negative weights, although this is at the cost of a higher computational cost, which limits its application to graphs of small to medium size. It is well known that the Floyd−Warshall and Dantzig algorithms work well regardless of a graph’s density, and they have the advantage of calculating the shortest paths between all pairs of vertices despite their greater spatial and temporal resources.

It is important to note that the tool developed in the current study is useful for generating, configuring, and visualizing graph structures, allowing a deeper empirical investigation of algorithmic behavior in a controlled environment.

Further work on this project will include extending it to include additional algorithms, such as A*, bidirectional search, and their modifications. In addition, research on real graph data, as well as an analysis of parallel implementations, could significantly enhance the understanding of the algorithms’ practical efficiency and applicability for specific domains.

Further research could explore the integration of machine learning techniques to enhance shortest path algorithms. For instance, genetic algorithms or neural networks could be employed to predict path weights or prune search spaces, potentially improving the efficiency of traditional algorithms like Dijkstra’s. Recent studies [24,25] demonstrate promising results in this direction. Future iterations of this work will investigate these hybrid approaches.