Updated and cleaned up code

Author: aladdinpersson

Algorithms/cryptology/ceasar_shifting_cipher/ceasar_shift_cipher.py

@@ -41,13 +41,13 @@ def decrypt(cipher, shift=3):
 
     return decrypted
 
-def main():
-    message = 'attackatnoon'
-    cipher = encrypt(message, shift=3)
-    decrypted = decrypt(cipher, shift=3)
-
-    print('Original message: ' + message)
-    print('Encrypted message: ' + cipher)
-    print('Decrypted message: ' + decrypted)
-
-main()
+# def main():
+#     message = 'attackatnoon'
+#     cipher = encrypt(message, shift=3)
+#     decrypted = decrypt(cipher, shift=3)
+#
+#     print('Original message: ' + message)
+#     print('Encrypted message: ' + cipher)
+#     print('Decrypted message: ' + decrypted)
+#
+# main()

Algorithms/graphtheory/bellman-ford/bellman_ford.py

@@ -9,23 +9,12 @@
   2019-03-04 Initial programming
 '''
 
-def make_graph(file):
-    try:
-        f = open(file, 'r')
-    except IOError:
-        raise IOError("File does not exist!")
-
-    line_list = f.readlines()
-
-    G = {int(line.split()[0]): {(int(tup.split(',')[0])): int(tup.split(',')[1])
-                                for tup in line.split()[1:] if tup} for line in line_list if line}
-
-    f.close()
-
-    return G
-
-
 def bellman_ford(G, start):
+    '''
+    :param G: {from_node1: {to_node1, cost1, to_node2, cost2}, from_node2: {etc}}
+    :param start: node to start from
+    '''
+
     if len(G) == 0:
         raise ValueError("There should be something in the graph")
 
@@ -56,14 +45,12 @@ def bellman_ford(G, start):
 
     return shortest_distance, predecessor
 
-if __name__ == '__main__':
-    # G = make_graph('data.txt')
-
-    G = {1: {2: -10, 3: 20},
-         2: {4: 40},
-         3: {4: 5},
-         4: {}}
-
-    print(f'Current graph is: {G}')
-    shortest, predecessor = bellman_ford(G, 1)
-    print(shortest)
+# if __name__ == '__main__':
+#     G = {1: {2: -10, 3: 20},
+#          2: {4: 40},
+#          3: {4: 5},
+#          4: {}}
+#
+#     print(f'Current graph is: {G}')
+#     shortest, predecessor = bellman_ford(G, 1)
+#     print(shortest)

Algorithms/graphtheory/breadth-first-search/BFS_queue_iterative.py

@@ -1,18 +1,18 @@
-from collections import deque
-
-def load_graph(file='exgraph.txt'):
-    data = open(file, 'r')
-    G = {}
-
-    for line in data:
-        lst = [int(x) for x in line.split()]
-        G[lst[0]] = lst[1:]
+'''
+Programmed by Aladdin Persson 
+    2019-02-17 Initial programming
+    2020-03-29 Cleaned up code, removed load graph, I think a small example is sufficient
+               and instead only have the BFS function.
+'''
 
-    num_nodes = len(G)
-
-    return G, num_nodes
+from collections import deque
 
 def BFS(G, start_node=1):
+    '''
+    :param G: Graph with G = {from_node1:[to_node1, to_node2], from_node2: [to_node,] etc}
+    :param start_node: starting node to run BFS from
+    :return: returns visited boolean array and path in which order it visited them
+    '''
     visited = [False for i in range(1,len(G)+1)]
 
     Q = deque()
@@ -33,17 +33,13 @@ def BFS(G, start_node=1):
 
     return visited, path
 
+# Small Example Run
+# if __name__ == '__main__':
+#     G = {1:[2,3], 2:[1,4], 3:[1,4],4:[]}
+#     visited, path = BFS(G)
+#
+#     if all(visited) == True:
+#         print("Return: This graph is connected!")
 
-
-if __name__ == '__main__':
-    G, num_nodes = load_graph()
-    # G = {1:[2,3], 2:[1,4], 3:[1,4],4:[]}
-
-    visited, path = BFS(G)
-
-    if all(visited) == True:
-        print("Return: This graph is connected!")
-    else:
-        print("Not all nodes were reachable, i.e the graph is not connected.")
-
-
+#     else:
+#         print("Not all nodes were reachable, i.e the graph is not connected.")

Algorithms/graphtheory/depth-first-search/DFS_recursive.py

@@ -4,50 +4,31 @@
 # Programmed by Aladdin Persson 
 #   2019-02-16 Initial programming
 
-# Improvements:
-#   * Check implementation with stack/queue
-
-def load_graph(file='exgraph.txt'):
-    data = open(file, 'r')
-    G = {}
-
-    for line in data:
-        lst = [int(x) for x in line.split()]
-        G[lst[0]] = lst[1:]
-
-    num_nodes = len(G)
-
-    return G, num_nodes
-
-
 def DFS(G, curr_node, visited):
+    '''
+    :param G: G = {from_node1:[to_node1, to_node2], from_node2: [to_node,] etc}
+    :param curr_node: Node currently at, run from beginning this is the starting node
+    :param visited: since it is recursive, visited is updated and needs to be sent in on recursive call
+    :return: visited is initialized outside of DFS and updates this boolean array with which nodes has been visited
+    '''
     if visited[curr_node - 1]:
         return
 
     visited[curr_node-1] = True
 
-    # G is a dictionary
     neighbours = G[curr_node]
 
     for next_node in neighbours:
         DFS(G, next_node, visited)
 
-if __name__ == '__main__':
-    print('Loading graph and print:')
-
-    try:
-        G, num_nodes = load_graph()
-        print(G)
-
-    except TypeError:
-        raise("Error loading graph.")
-
-    # G = {1: [2], 2: [1, 3, 4], 3: [2], 4: [2, 5], 5: [4]}
-
-    visited = [False for i in range(1, len(G) + 1)]
-    start_node = 1
-
-    DFS(G, start_node, visited)
-
-    if any(visited) == False:
-        print("Result: This graph is connected!")
+# Small Eaxmple
+# if __name__ == '__main__':
+#      G = {1: [2], 2: [1, 3, 4], 3: [2], 4: [2, 5], 5: [4]}
+#
+#     visited = [False for i in range(1, len(G) + 1)]
+#     start_node = 1
+#
+#     DFS(G, start_node, visited)
+#
+#     if any(visited) == False:
+#         print("Result: This graph is connected!")

Algorithms/graphtheory/depth-first-search/DFS_stack_iterative.py

@@ -7,20 +7,12 @@
     2020-03-29 Cleaned up code, made test cases
 '''
 
-
-def load_graph(file='exgraph.txt'):
-    data = open(file, 'r')
-    G = {}
-
-    for line in data:
-        lst = [int(x) for x in line.split()]
-        G[lst[0]] = lst[1:]
-
-    num_nodes = len(G)
-
-    return G, num_nodes
-
 def DFS(G, start_node):
+    '''
+    :param G: Graph with G = {from_node1:[to_node1, to_node2], from_node2: [to_node,] etc}
+    :param start_node: starting node to run BFS from
+    :return: returns visited boolean array and path in which order it visited them
+    '''
     visited = [False for i in range(1, len(G) + 1)]
     path = [start_node]
     stack = []
@@ -38,12 +30,12 @@ def DFS(G, start_node):
 
     return visited, path
 
-if __name__ == '__main__':
-    G, num_nodes = load_graph()
-    start_node = 1
-    visited = DFS(G, start_node)
-
-    if all(visited) == True:
-        print("Return: This graph is connected!")
-    else:
-        print("Not all nodes were reachable, i.e the graph is not connected.")
+# if __name__ == '__main__':
+#     G = {1: [2, 3], 2: [1, 4], 3: [1, 4], 4: []}
+#     start_node = 1
+#     visited = DFS(G, start_node)
+#
+#     if all(visited) == True:
+#         print("Return: This graph is connected!")
+#     else:
+#         print("Not all nodes were reachable, i.e the graph is not connected.")

README.md

@@ -59,7 +59,7 @@ Whenever I face an interesting problem I document the algorithm that I learned t
 
 # Sorting algorithms
 *  :white_check_mark: [Bubble sort](https://github.com/AladdinPerzon/Algorithms-Collection-Python/blob/master/Algorithms/sorting/bubblesort.py) **- O(n<sup>2sup>)** 
-*  :small_red_triangle: [Hope sort](https://github.com/AladdinPerzon/Algorithms-Collection-Python/blob/master/Algorithms/sorting/hopesort.py) **- O(1), hopefully **
+*  :small_red_triangle: [Hope sort](https://github.com/AladdinPerzon/Algorithms-Collection-Python/blob/master/Algorithms/sorting/hopesort.py) **- O(1), hopefully**
 *  :white_check_mark: [Insertion sort](https://github.com/AladdinPerzon/Algorithms-Collection-Python/blob/master/Algorithms/sorting/insertionsort.py) **- O(n<sup>2sup>)** 
 *  :white_check_mark: [Selection sort](https://github.com/AladdinPerzon/Algorithms-Collection-Python/blob/master/Algorithms/sorting/selectionsort.py) **- O(n<sup>2sup>)** 
 *  :white_check_mark: [Merge sort](https://github.com/AladdinPerzon/Algorithms-Collection-Python/blob/master/Algorithms/sorting/mergesort.py) **- O(nlog(n))**