Merge branch 'ivanmmarkovic:master' into master

Author: simakuutio

.gitignore

@@ -1,2 +1,3 @@
 /__pycache__/
-/venv/
+/venv/
+/.idea/

README.md

@@ -55,6 +55,7 @@ but it also contains other data structures, algorithms and problems.
 - [Palindrome](https://github.com/ivanmmarkovic/Problem-Solving-with-Algorithms-and-Data-Structures-using-Python/blob/master/recursion/palindrome.py)
 - [Reverse linked list - recursive solution](https://github.com/ivanmmarkovic/Problem-Solving-with-Algorithms-and-Data-Structures-using-Python/blob/master/recursion/reverse-linked-list.py)
 - [Reverse linked list - iterative solution](https://github.com/ivanmmarkovic/Problem-Solving-with-Algorithms-and-Data-Structures-using-Python/blob/master/recursion/reverse-linked-list-iterative.py)
+- [Reverse linked list - iterative solution stack](https://github.com/ivanmmarkovic/Problem-Solving-with-Algorithms-and-Data-Structures-using-Python/blob/master/recursion/reverse-linked-list-iterative-stack.py)
 - [Reverse list](https://github.com/ivanmmarkovic/Problem-Solving-with-Algorithms-and-Data-Structures-using-Python/blob/master/recursion/reverse-list.py)
 - [Reverse string](https://github.com/ivanmmarkovic/Problem-Solving-with-Algorithms-and-Data-Structures-using-Python/blob/master/recursion/reverse-string.py)
 - [Sum numbers - binary recursion](https://github.com/ivanmmarkovic/Problem-Solving-with-Algorithms-and-Data-Structures-using-Python/blob/master/recursion/sum-numbers-binary-recursion.py)
@@ -108,11 +109,20 @@ but it also contains other data structures, algorithms and problems.
 - [Dijkstra algorithm - Shortest path](https://github.com/ivanmmarkovic/Problem-Solving-with-Algorithms-and-Data-Structures-using-Python/tree/master/graphs/dijkstra)
     - [Priority Queue implementation](https://github.com/ivanmmarkovic/Problem-Solving-with-Algorithms-and-Data-Structures-using-Python/tree/master/graphs/dijkstra/priority-queue-impl-adjacency-map)
     - [Matrix implementation](https://github.com/ivanmmarkovic/Problem-Solving-with-Algorithms-and-Data-Structures-using-Python/tree/master/graphs/dijkstra/matrix-impl)
+- [Bellman-Ford algorithm](https://github.com/ivanmmarkovic/Problem-Solving-with-Algorithms-and-Data-Structures-using-Python/tree/master/graphs/bellman-ford)
+- [Bellman-Ford algorithm - negative weight cycle](https://github.com/ivanmmarkovic/Problem-Solving-with-Algorithms-and-Data-Structures-using-Python/tree/master/graphs/bellman-ford-negative-weight-cycle)
 - [Minimum Spanning Tree](https://github.com/ivanmmarkovic/Problem-Solving-with-Algorithms-and-Data-Structures-using-Python/tree/master/graphs/minimum-spanning-tree)
     - [Minimum Spanning Tree in undirected graph](https://github.com/ivanmmarkovic/Problem-Solving-with-Algorithms-and-Data-Structures-using-Python/tree/master/graphs/minimum-spanning-tree/breadth-first-search)
     - [Prim's algorithm - Minimum Spanning Tree in undirected weighted graph](https://github.com/ivanmmarkovic/Problem-Solving-with-Algorithms-and-Data-Structures-using-Python/tree/master/graphs/minimum-spanning-tree/prims-algorithm)
+    - [Kruskal's algorithm - Minimum Spanning Tree in undirected weighted graph](https://github.com/ivanmmarkovic/Problem-Solving-with-Algorithms-and-Data-Structures-using-Python/tree/master/graphs/minimum-spanning-tree/kruskals-algorithm)
 - [Is graph bipartite](https://github.com/ivanmmarkovic/Problem-Solving-with-Algorithms-and-Data-Structures-using-Python/tree/master/graphs/is-graph-bipartite)
-- [Union find](https://github.com/ivanmmarkovic/Problem-Solving-with-Algorithms-and-Data-Structures-using-Python/tree/master/graphs/union-find-path-compression)
-
+- [Union find](https://github.com/ivanmmarkovic/Problem-Solving-with-Algorithms-and-Data-Structures-using-Python/tree/master/graphs/union-find)
+    - [Number of connected components](https://github.com/ivanmmarkovic/Problem-Solving-with-Algorithms-and-Data-Structures-using-Python/tree/master/graphs/union-find/number-of-connected-components)
+    - [Union find path compression](https://github.com/ivanmmarkovic/Problem-Solving-with-Algorithms-and-Data-Structures-using-Python/tree/master/graphs/union-find/union-find-path-compression)
+- [Kosaraju's algorithm](https://github.com/ivanmmarkovic/Problem-Solving-with-Algorithms-and-Data-Structures-using-Python/tree/master/graphs/kosarajus-algorithm)
 ### [Trie](https://github.com/ivanmmarkovic/Problem-Solving-with-Algorithms-and-Data-Structures-using-Python/tree/master/trie)
 - [Trie](https://github.com/ivanmmarkovic/Problem-Solving-with-Algorithms-and-Data-Structures-using-Python/tree/master/trie)
+
+
+### [Substring search](https://github.com/ivanmmarkovic/Problem-Solving-with-Algorithms-and-Data-Structures-using-Python/tree/master/substring-search)
+- [Brute force algorithm](https://github.com/ivanmmarkovic/Problem-Solving-with-Algorithms-and-Data-Structures-using-Python/blob/master/substring-search/brute_force.py)

graphs/bellman-ford-negative-weight-cycle/.idea/.gitignore

@@ -0,0 +1,62 @@
+
+#  Bellman-Ford algorithm
+#  Find shortest paths from one vertex,
+#  to all other vertices in weighted graph.
+#  Runtime O(V*E)
+
+# Negative weight cycle will be found with one more loop through edges
+# If there is a need to update distance than it is a negative weight cycle
+
+class Graph:
+    def __init__(self):
+        self.vertices: list = []
+        self.edges: list = []
+        self.distance: dict = {}
+        self.prev: dict = {}
+
+    def add_vertex(self, label: str):
+        self.vertices.append(label)
+        self.distance[label] = None
+        self.prev[label] = None
+
+    def add_edge(self, label1: str, label2: str, weight: int):
+        self.edges.append([label1, label2, weight])
+
+    def bellman_ford(self, source: str):
+        self.distance[source] = 0
+
+        for _ in range(len(self.vertices)):
+
+            for edge in self.edges:
+                label1: str = edge[0]
+                label2: str = edge[1]
+                weight: int = edge[2]
+
+                if self.distance[label1] is None:
+                    continue
+                if self.distance[label2] is None:
+                    self.distance[label2] = self.distance[label1] + weight
+                    self.prev[label2] = label1
+                    continue
+                if self.distance[label1] + weight < self.distance[label2]:
+                    self.distance[label2] = self.distance[label1] + weight
+                    self.prev[label2] = label1
+                    continue
+
+        for edge in self.edges:
+            label1: str = edge[0]
+            label2: str = edge[1]
+            weight: int = edge[2]
+
+            if self.distance[label1] is None:
+                continue
+            if self.distance[label2] is None:
+                continue
+            if self.distance[label1] + weight < self.distance[label2]:
+                print(f'Negative weight cycle from {label1} to {label2}')
+
+    def print_distances(self, source: str):
+        for v in self.vertices:
+            if v != source:
+                distance: int = self.distance[v]
+                print(f'Distance from {source} to {v} is {distance}')

graphs/bellman-ford-negative-weight-cycle/.idea/Bellman–Ford.iml

@@ -0,0 +1,47 @@
+
+#  Bellman-Ford algorithm
+#  Find shortest paths from one vertex,
+#  to all other vertices in weighted graph.
+#  Runtime O(V*E)
+
+class Graph:
+    def __init__(self):
+        self.vertices: list = []
+        self.edges: list = []
+        self.distance: dict = {}
+        self.prev: dict = {}
+
+    def add_vertex(self, label: str):
+        self.vertices.append(label)
+        self.distance[label] = None
+        self.prev[label] = None
+
+    def add_edge(self, label1: str, label2: str, weight: int):
+        self.edges.append([label1, label2, weight])
+
+    def bellman_ford(self, source: str):
+        self.distance[source] = 0
+
+        for _ in range(len(self.vertices)):
+
+            for edge in self.edges:
+                label1: str = edge[0]
+                label2: str = edge[1]
+                weight: int = edge[2]
+
+                if self.distance[label1] is None:
+                    continue
+                if self.distance[label2] is None:
+                    self.distance[label2] = self.distance[label1] + weight
+                    self.prev[label2] = label1
+                    continue
+                if self.distance[label1] + weight < self.distance[label2]:
+                    self.distance[label2] = self.distance[label1] + weight
+                    self.prev[label2] = label1
+                    continue
+
+    def print_distances(self, source: str):
+        for v in self.vertices:
+            if v != source:
+                distance: int = self.distance[v]
+                print(f'Distance from {source} to {v} is {distance}')

graphs/bellman-ford-negative-weight-cycle/.idea/inspectionProfiles/profiles_settings.xml

@@ -3,40 +3,41 @@
 
 class Graph:
     def __init__(self):
-        self._vertices: list = []
-        self._colors: dict = {}
-        self._adjacency_matrix: dict = {}
-
-    def add_vertex(self, label: str):
-        self._vertices.append(label)
-        self._colors[label] = None
-        self._adjacency_matrix[label]: list = []
-
-    def add_edge(self, label1: str, label2: str):
-        self._adjacency_matrix[label1].append(label2)
-        self._adjacency_matrix[label2].append(label1)
-
-    def bipartite_check(self) -> bool:
-        for vertex in self._vertices:
-            if self._colors[vertex] is not None:
+        self.vertices: list = []
+        self.adjacency_list: dict = {}
+        self.color: dict = {}
+
+    def add_vertex(self, label: str = None):
+        self.vertices.append(label)
+        self.adjacency_list[label]: list = []
+        self.color[label] = None
+
+    def add_edge(self, label1: str = None, label2: str = None):
+        self.adjacency_list[label1].append(label2)
+        self.adjacency_list[label2].append(label1)
+
+    def is_bipartite(self) -> bool:
+        for vertex in self.vertices:
+            if self.color[vertex] is not None:
                 continue
-            self._colors[vertex] = "red"
             q: Queue = Queue()
+            self.color[vertex] = "red"
             q.enqueue(vertex)
             while not q.is_empty():
-                v = q.dequeue()
-                for neighbour in self._adjacency_matrix[v]:
-                    if self._colors[neighbour] == self._colors[v]:
+                tmp: str = q.dequeue()
+                for neighbour in self.adjacency_list[tmp]:
+                    if self.color[neighbour] == self.color[tmp]:
                         return False
-                    if self._colors[neighbour] is None:
-                        if self._colors[v] == "red":
-                            self._colors[neighbour] = "blue"
+                    if self.color[neighbour] is None:
+                        if self.color[tmp] == "red":
+                            self.color[neighbour] = "blue"
                         else:
-                            self._colors[neighbour] = "red"
+                            self.color[neighbour] = "red"
                         q.enqueue(neighbour)
         return True
 
 
 
 
 
+