Graph implementation (#46)

* Added all the test files into one test_cases folder

* Created a folder named Graph_implementation and added 3 files in it, 1)Graph.py which contains all the methods, 2) SearchAlgorithms.py which contains some searching algos. and 3)main.py

Author: Ayushlion8

Graph_implementation/Graph.py

@@ -0,0 +1,44 @@
+class Graph:
+    def __init__(self):
+        self.graph = {}
+
+    def add_edge(self, u, v):
+        if u not in self.graph:
+            self.graph[u] = []
+        self.graph[u].append(v)
+
+    def add_vertex(self, vertex):
+        if vertex not in self.graph:
+            self.graph[vertex] = []
+
+    def get_vertices(self):
+        return list(self.graph.keys())
+
+    def get_edges(self):
+        edges = []
+        for vertex, neighbors in self.graph.items():
+            for neighbor in neighbors:
+                edges.append((vertex, neighbor))
+        return edges
+
+    def is_vertex_exist(self, vertex):
+        return vertex in self.graph
+
+    def is_edge_exist(self, u, v):
+        return u in self.graph and v in self.graph[u]
+
+    def remove_edge(self, u, v):
+        if self.is_edge_exist(u, v):
+            self.graph[u].remove(v)
+
+    def remove_vertex(self, vertex):
+        if self.is_vertex_exist(vertex):
+            del self.graph[vertex]
+            for u in self.graph:
+                self.graph[u] = [v for v in self.graph[u] if v != vertex]
+
+    def clear(self):
+        self.graph = {}
+
+    def __str__(self):
+        return str(self.graph)

Graph_implementation/SearchAlgorithms.py

@@ -0,0 +1,90 @@
+from collections import deque
+
+def bfs(graph, start):
+    visited = set()
+    queue = deque([start])
+    result = []
+
+    while queue:
+        node = queue.popleft()
+        if node not in visited:
+            visited.add(node)
+            result.append(node)
+            queue.extend(graph.get(node, []) - visited)
+
+    return result
+
+def dfs(graph, start):
+    visited = set()
+    stack = [start]
+    result = []
+
+    while stack:
+        node = stack.pop()
+        if node not in visited:
+            visited.add(node)
+            result.append(node)
+            stack.extend(graph.get(node, []) - visited)
+
+    return result
+
+import heapq
+
+def dijkstra(graph, start):
+    distances = {vertex: float('infinity') for vertex in graph}
+    distances[start] = 0
+    priority_queue = [(0, start)]
+    
+    while priority_queue:
+        current_distance, current_vertex = heapq.heappop(priority_queue)
+        
+        if current_distance > distances[current_vertex]:
+            continue
+        
+        for neighbor, weight in graph[current_vertex].items():
+            distance = current_distance + weight
+            
+            if distance < distances[neighbor]:
+                distances[neighbor] = distance
+                heapq.heappush(priority_queue, (distance, neighbor))
+    
+    return distances
+
+
+
+def a_star(graph, start, goal):
+    open_set = [(0, start)]
+    came_from = {}
+    g_score = {vertex: float('infinity') for vertex in graph}
+    g_score[start] = 0
+    f_score = {vertex: float('infinity') for vertex in graph}
+    f_score[start] = heuristic(start, goal)
+    
+    while open_set:
+        _, current = heapq.heappop(open_set)
+        
+        if current == goal:
+            return reconstruct_path(came_from, current)
+        
+        for neighbor, cost in graph[current].items():
+            tentative_g_score = g_score[current] + cost
+            
+            if tentative_g_score < g_score[neighbor]:
+                came_from[neighbor] = current
+                g_score[neighbor] = tentative_g_score
+                f_score[neighbor] = tentative_g_score + heuristic(neighbor, goal)
+                heapq.heappush(open_set, (f_score[neighbor], neighbor))
+    
+    return None
+
+def heuristic(node, goal):
+    # Define your heuristic function here (e.g., Manhattan distance, Euclidean distance, etc.)
+    pass
+
+def reconstruct_path(came_from, current):
+    path = [current]
+    while current in came_from:
+        current = came_from[current]
+        path.append(current)
+    return path[::-1]
+

Graph_implementation/main.py

@@ -0,0 +1,14 @@
+from Graph_implementation.Graph import Graph
+from Graph_implementation.SearchAlgorithms import bfs, dfs, dijkstra, a_star 
+
+# Create a graph and add edges
+g = Graph()
+g.add_edge('A', 'B')
+g.add_edge('A', 'C')
+g.add_edge('B', 'D')
+g.add_edge('B', 'E')
+g.add_edge('C', 'F')
+
+# Test BFS and DFS
+print("BFS:", bfs(g.graph, 'A'))
+print("DFS:", dfs(g.graph, 'A'))