Added Graph

Author: mohanakrishnavh

.idea/workspace.xml

@@ -0,0 +1,36 @@
+from DataStructures.LinkedList import LinkedList
+
+
+class Graph:
+    def __init__(self, vertices, is_directed=True):
+        self.is_directed = is_directed
+        # Total number of vertices in the Graph
+        self.vertices = vertices
+        # Dictionary that holds the adjacency list for all the vertices
+        self.adjacency_list = {}
+
+    def _add_edge_helper(self, source, destination):
+        if source in self.adjacency_list:
+            adjacency_list_of_source = self.adjacency_list[source]
+        else:
+            adjacency_list_of_source = LinkedList()
+        adjacency_list_of_source.insert(destination, 0)
+        self.adjacency_list[source] = adjacency_list_of_source
+
+    def add_edge(self, source, destination):
+        if self.is_directed is False:
+            self._add_edge_helper(destination, source)
+
+        self._add_edge_helper(source, destination)
+
+    def add_edges(self, list_of_edges):
+        for edge in list_of_edges:
+            self.add_edge(edge[0], edge[1])
+
+    def print_graph(self):
+        for key in self.adjacency_list:
+            adjacency_list_of_key = self.adjacency_list[key]
+            print('{0} => '.format(key), end='')
+            adjacency_list_of_key.print_list()
+
+

DataStructures/Graph/Graph.py

@@ -0,0 +1,5 @@
+from DataStructures.Graph import Graph
+
+directed_graph_1 = Graph(4, True)
+directed_graph_1.add_edges([[0, 1], [0, 1], [0, 2], [1, 3], [2, 3]])
+directed_graph_1.print_graph()

DataStructures/Graph/graph_driver.py

@@ -60,4 +60,4 @@ def add_two_numbers(l1: Node, l2: Node) -> Node:
 
 head = add_two_numbers(l1.head, l2.head)
 l3 = LinkedList()
-l3.print_list(head)
+l3.print_list(head)

DataStructures/__pycache__/Graph.cpython-36.pyc

@@ -0,0 +1,18 @@
+import math
+
+
+def find_minimum(arr):
+    """
+    Time Complexity: O(n)
+    Space Complexity: O(1)
+    """
+    min_value = math.inf
+
+    for x in arr:
+        if x < min_value:
+            min_value = x
+
+    return min_value
+
+
+print(find_minimum([10, 2, 5, 6, 8]))

Leetcode/add_two_numbers.py

@@ -0,0 +1,25 @@
+from collections import OrderedDict
+
+
+def first_non_repeating_integer(arr):
+    """
+    Time Complexity: O(n)
+    Space Complexity: O(m)
+    """
+    count_map = OrderedDict()
+
+    for x in arr:
+        if x in count_map:
+            count_map[x] = count_map[x]+1
+        else:
+            count_map[x] = 1
+
+    for key, value in count_map.items():
+        if count_map[key] == 1:
+            return key
+
+    return -1
+
+
+print(first_non_repeating_integer([9, 2, 3, 2, 6, 6]))
+print(first_non_repeating_integer([4, 5, 1, 2, 0, 4]))

Leetcode/find_minimum.py

@@ -0,0 +1,27 @@
+def merge_sorted_array(list_1, list_2):
+    l1 = 0
+    l2 = 0
+
+    l1_length = len(list_1)
+    l2_length = len(list_2)
+
+    while l1 < l1_length and l2 < l2_length:
+        if list_1[l1] < list_2[l2]:
+            l1 += 1
+        else:
+            list_1.insert(l1, list_2[l2])
+            l1 += 1
+            l2 += 1
+
+    if l2 < l2_length:
+        list_1.extend(list_2[l2:])
+
+    return list_1
+
+
+array_1 = [1, 3, 4, 5]
+array_2 = [2, 6, 7, 8]
+print(merge_sorted_array(array_1, array_2))
+
+
+

Leetcode/first_non_repeating_integer.py

@@ -0,0 +1,39 @@
+def product_except_self(arr):
+    """
+    Time Complexity: O(n^2)
+    Space Complexity: O(1)
+    """
+    result = []
+    for i, x in enumerate(arr):
+        product = 1
+        for j, y in enumerate(arr):
+            if i != j:
+                product *= y
+        result.append(product)
+
+    return result
+
+
+def product_except_self_2(arr):
+    """
+    Time Complexity: O(n)
+    Space Complexity: O(1)
+    """
+    result = []
+    size = len(arr)
+
+    left = 1
+    for i in range(0, size):
+        result.append(left)
+        left = left * arr[i]
+
+    right = 1
+    for i in range(size-1, -1, -1):
+        result[i] = result[i] * right
+        right = right * arr[i]
+
+    return result
+
+
+print(product_except_self([1, 2, 3, 4]))
+print(product_except_self_2([1, 2, 3, 4]))

Leetcode/merge_sorted_arrays.py

@@ -0,0 +1,44 @@
+def rearrange(arr):
+    """
+    Time Complexity: O(n)
+    Space Complexity: O(n)
+    """
+    left = []
+    right = []
+    zeros = []
+
+    for x in arr:
+        if x < 0:
+            left.append(x)
+        elif x > 0:
+            right.append(x)
+        else:
+            zeros.append(x)
+
+    return left + zeros + right
+
+
+def rearrange_pythonic(arr):
+    """
+    Time Complexity: O(n)
+    Space Complexity: O(1)
+    """
+    return [i for i in arr if i < 0] + [i for i in arr if i == 0] + [i for i in arr if i > 0]
+
+
+def rearrange_inplace(arr):
+    left_most_pos_idx = 0
+    size = len(arr)
+
+    for i in range(size):
+        if arr[i] < 0:
+            if i is not left_most_pos_idx:
+                arr[i], arr[left_most_pos_idx] = arr[left_most_pos_idx], arr[i]
+            left_most_pos_idx += 1
+
+    return arr
+
+
+print(rearrange([10, -1, 20, 4, 0, 5, -9, -6]))
+print(rearrange_pythonic([10, -1, 20, 4, 0, 5, -9, -6]))
+print(rearrange_inplace([10, -1, 20, 4, 5, -9, -6]))