feat: replace Bellman Ford Algorithm with queue version

Author: TripleCamellya

pydatastructs/graphs/algorithms.py

@@ -697,11 +697,9 @@ def shortest_paths(graph: Graph, algorithm: str,
         The algorithm to be used. Currently, the following algorithms
         are implemented,
 
-        'bellman_ford' -> Bellman-Ford algorithm as given in [1].
+        'bellman_ford' -> Bellman-Ford algorithm as given in [1], with a queue to improve performance on sparse graphs.
 
         'dijkstra' -> Dijkstra algorithm as given in [2].
-
-        'queue_improved_bellman_ford' -> Queue Improved Bellman-Ford algorithm as given in [3].
     source: str
         The name of the source the node.
     target: str
@@ -744,7 +742,6 @@ def shortest_paths(graph: Graph, algorithm: str,
 
     .. [1] https://en.wikipedia.org/wiki/Bellman%E2%80%93Ford_algorithm
     .. [2] https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm
-    .. [3] https://en.wikipedia.org/wiki/Bellman%E2%80%93Ford_algorithm#Improvements
     """
     raise_if_backend_is_not_python(
         shortest_paths, kwargs.get('backend', Backend.PYTHON))
@@ -757,27 +754,34 @@ def shortest_paths(graph: Graph, algorithm: str,
     return getattr(algorithms, func)(graph, source, target)
 
 def _bellman_ford_adjacency_list(graph: Graph, source: str, target: str) -> tuple:
-    distances, predecessor = {}, {}
+    distances, predecessor, visited, cnts = {}, {}, {}, {}
 
     for v in graph.vertices:
         distances[v] = float('inf')
         predecessor[v] = None
+        visited[v] = False
+        cnts[v] = 0
     distances[source] = 0
+    verticy_num = len(graph.vertices)
 
-    edges = graph.edge_weights.values()
-    for _ in range(len(graph.vertices) - 1):
-        for edge in edges:
-            u, v = edge.source.name, edge.target.name
-            w = edge.value
-            if distances[u] + edge.value < distances[v]:
-                distances[v] = distances[u] + w
-                predecessor[v] = u
+    que = Queue([source])
 
-    for edge in edges:
-        u, v = edge.source.name, edge.target.name
-        w = edge.value
-        if distances[u] + w < distances[v]:
-            raise ValueError("Graph contains a negative weight cycle.")
+    while que:
+        u = que.popleft()
+        visited[u] = False
+        neighbors = graph.neighbors(u)
+        for neighbor in neighbors:
+            v = neighbor.name
+            edge_str = u + '_' + v
+            if distances[u] != float('inf') and distances[u] + graph.edge_weights[edge_str].value < distances[v]:
+                distances[v] = distances[u] + graph.edge_weights[edge_str].value
+                predecessor[v] = u
+                cnts[v] = cnts[u] + 1
+                if cnts[v] >= verticy_num:
+                    raise ValueError("Graph contains a negative weight cycle.")
+                if not visited[v]:
+                    que.append(v)
+                    visited[v] = True
 
     if target != "":
         return (distances[target], predecessor)
@@ -814,37 +818,6 @@ def _dijkstra_adjacency_list(graph: Graph, start: str, target: str):
 
 _dijkstra_adjacency_matrix = _dijkstra_adjacency_list
 
-def _queue_improved_bellman_ford_adjacency_list(graph: Graph, source: str, target: str) -> tuple:
-    distances, predecessor, visited = {}, {}, {}
-
-    for v in graph.vertices:
-        distances[v] = float('inf')
-        predecessor[v] = None
-        visited[v] = False
-    distances[source] = 0
-
-    que = Queue([source])
-
-    while que:
-        u = que.popleft()
-        visited[u] = False
-        neighbors = graph.neighbors(u)
-        for neighbor in neighbors:
-            v = neighbor.name
-            edge_str = u + '_' + v
-            if distances[u] != float('inf') and distances[u] + graph.edge_weights[edge_str].value < distances[v]:
-                distances[v] = distances[u] + graph.edge_weights[edge_str].value
-                predecessor[v] = u
-                if not visited[v]:
-                    que.append(v)
-                    visited[v] = True
-
-    if target != "":
-        return (distances[target], predecessor)
-    return (distances, predecessor)
-
-_queue_improved_bellman_ford_adjacency_matrix = _queue_improved_bellman_ford_adjacency_list
-
 def all_pair_shortest_paths(graph: Graph, algorithm: str,
                             **kwargs) -> tuple:
     """

pydatastructs/graphs/tests/test_algorithms.py

@@ -321,10 +321,6 @@ def _test_shortest_paths_negative_edges(ds, algorithm):
     _test_shortest_paths_negative_edges("Matrix", 'bellman_ford')
     _test_shortest_paths_positive_edges("List", 'dijkstra')
     _test_shortest_paths_positive_edges("Matrix", 'dijkstra')
-    _test_shortest_paths_positive_edges("List", 'queue_improved_bellman_ford')
-    _test_shortest_paths_positive_edges("Matrix", 'queue_improved_bellman_ford')
-    _test_shortest_paths_negative_edges("List", 'queue_improved_bellman_ford')
-    _test_shortest_paths_negative_edges("Matrix", 'queue_improved_bellman_ford')
 
 def test_all_pair_shortest_paths():