Updated docstrings for better code readability

Author: OmkarPathak

pygorithm/data_structures/graph.py

@@ -2,8 +2,8 @@
 # Created On: 12th August 2017
 from collections import defaultdict
 
-
 class Graph(object):
+    ''' class for creating a graph '''
     def __init__(self):
         self.graph = defaultdict(list)
         self.count = 0
@@ -25,7 +25,7 @@ def get_code(self):
         return inspect.getsource(Graph)
 
 
-class WeightedGraph:
+class WeightedGraph(object):
     """
     A graph with a numerical value (weight) on edges
     """
@@ -77,11 +77,12 @@ def kruskal_mst(self):
         return edges_explored
 
     @staticmethod
-    def kruskal_complexity():
+    def kruskal_time_complexity():
         return '''Worst case: O(E log(V)) where E in the number of edges and V the number of vertexes'''
 
     @classmethod
     def kruskal_code(cls):
+        ''' Returns the code for current class '''
         import inspect
         return inspect.getsource(cls.kruskal_mst)
 
@@ -94,11 +95,11 @@ def topological_sort(self):
         for vertex in range(self.count):
             # Call the recursive function only if not visited
             if not visited[vertex]:
-                self.topological_sort_rec(vertex, visited, stack)
+                self._topological_sort_rec(vertex, visited, stack)
 
         return stack
 
-    def topological_sort_rec(self, vertex, visited, stack):
+    def _topological_sort_rec(self, vertex, visited, stack):
         ''' Recursive function for topological Sort '''
         # Mark the current node in visited
         visited[vertex] = True
@@ -107,7 +108,7 @@ def topological_sort_rec(self, vertex, visited, stack):
         try:
             for adjacent_node in self.graph[vertex]:
                 if visited[adjacent_node] == False:
-                    self.topological_sort_rec(adjacent_node, visited, stack)
+                    self._topological_sort_rec(adjacent_node, visited, stack)
         except KeyError:
             return
 
@@ -121,6 +122,7 @@ def get_code(self):
 
 
 class CheckCycleDirectedGraph(object):
+    ''' Class to check cycle in directed graph '''
     def __init__(self):
         self.graph = {}
         self.count = 0
@@ -146,11 +148,11 @@ def check_cycle(self):
         stack = [False] * len(self.graph)
         for vertex in range(len(self.graph)):
             if visited[vertex] == False:
-                if self.check_cycle_rec(visited, stack, vertex) == True:
+                if self._check_cycle_rec(visited, stack, vertex) == True:
                     return True
         return False
 
-    def check_cycle_rec(self, visited, stack, vertex):
+    def _check_cycle_rec(self, visited, stack, vertex):
         ''' Recursive function for finding the cycle '''
         # Mark the current node in visited and also add it to the stack
         visited[vertex] = True
@@ -159,7 +161,7 @@ def check_cycle_rec(self, visited, stack, vertex):
         # mark all adjacent nodes of the current node
         for adjacentNode in self.graph[vertex]:
             if visited[adjacentNode] == False:
-                if self.check_cycle_rec(visited, stack, adjacentNode) == True:
+                if self._check_cycle_rec(visited, stack, adjacentNode) == True:
                     return True
             elif stack[adjacentNode] == True:
                 return True
@@ -176,6 +178,7 @@ def get_code(self):
 
 
 class CheckCycleUndirectedGraph(object):
+    ''' Class to check cycle in undirected graph '''
     def __init__(self):
         self.graph = {}
         self.count = 0
@@ -202,19 +205,19 @@ def check_cycle(self):
         for vertex in range(len(self.graph)):
             # Call the recursive function only if not visited
             if visited[vertex] == False:
-                if self.check_cycle_rec(visited, -1, vertex) == True:
+                if self._check_cycle_rec(visited, -1, vertex) == True:
                     return True
         return False
 
-    def check_cycle_rec(self, visited, parent, vertex):
+    def _check_cycle_rec(self, visited, parent, vertex):
         ''' Recursive function for finding the cycle '''
         # Mark the current node in visited
         visited[vertex] = True
 
         # mark all adjacent nodes of the current node
         for adjacentNode in self.graph[vertex]:
             if visited[adjacentNode] == False:
-                if self.check_cycle_rec(visited, vertex, adjacentNode) == True:
+                if self._check_cycle_rec(visited, vertex, adjacentNode) == True:
                     return True
             elif parent != adjacentNode:
                 return True

pygorithm/data_structures/heap.py

@@ -4,19 +4,22 @@
 
 from pygorithm.data_structures import queue
 
-
-# min-heap implementation as priority queue
 class Heap(queue.Queue):
+    ''' min-heap implementation as queue '''
     def parent_idx(self, idx):
+        ''' retrieve the parent '''
         return idx // 2
 
     def left_child_idx(self, idx):
+        ''' retrieve the left child '''
         return (idx * 2) + 1
 
     def right_child_idx(self, idx):
+        ''' retrieve the right child '''
         return (idx * 2) + 2
 
     def insert(self, data):
+        ''' inserting an element in the heap '''
         super().enqueue(data)
         if self.rear >= 1:  # heap may need to be fixed
             self.heapify_up()

pygorithm/data_structures/linked_list.py

@@ -4,7 +4,9 @@
 # Linked List and Node can be accomodated in separate classes for convenience
 
 class Node(object):
-    # Each node has its data and a pointer that points to next node in the Linked List
+    ''' Node class for creating a node for linked list.
+        Each node has its data and a pointer that points to next node in the Linked List
+    '''
     def __init__(self, data, next=None):
         ''' constructor '''
         self.data = data

pygorithm/data_structures/tree.py

@@ -3,6 +3,9 @@
 
 # Node class to create a node for binary tree
 class Node(object):
+    ''' Node class for creating a node for tree.
+        Each node has its data and a pointer that points to next node in the Linked List
+    '''
     def __init__(self, data = None):
         self.left = None
         self.right = None
@@ -38,39 +41,39 @@ def get_code(self):
         import inspect
         return inspect.getsource(Node)
 
-# BinaryTree class to create a binary tree
 class BinaryTree(object):
+    ''' BinaryTree class to create a binary tree '''
     def __init__(self):
         self._inorder = []
         self._preorder = []
         self._postorder = []
 
-    # in this we traverse first to the leftmost node, then print its data and then traverse for rightmost node
     def inorder(self, root):
         '''
         @type: root:   Node object
+        in this we traverse first to the leftmost node, then print its data and then traverse for rightmost node
         '''
         if root:
             self.inorder(root.get_left())                # traverse to leftmost child
             self._inorder.append(root.get_data())        # get the data of current node
             self.inorder(root.get_right())               # traverse to rightmost child
         return self._inorder
 
-    # in this we first print the root node and then traverse towards leftmost node and then to the rightmost node
     def preorder(self, root):
         '''
         @type: root:   Node object
+        in this we first print the root node and then traverse towards leftmost node and then to the rightmost node
         '''
         if root:
             self._preorder.append(root.get_data())       # get the data of current node
             self.preorder(root.get_left())               # traverse to leftmost child
             self.preorder(root.get_right())              # traverse to rightmost child
         return self._preorder
 
-    # in this we first traverse to the leftmost node and then to the rightmost node and then print the data
     def postorder(self, root):
         '''
         @type: root:   Node object
+        in this we first traverse to the leftmost node and then to the rightmost node and then print the data
         '''
         if root:
             self.postorder(root.get_left())              # traverse to leftmost child
@@ -85,6 +88,7 @@ def get_code(self):
         return inspect.getsource(BinaryTree)
 
 class BSTNode(object):
+    ''' class for creating a node for Binary Search tree '''
     def __init__(self, data):
         self.data = data
         self.leftChild = None
@@ -141,6 +145,7 @@ def insert(self, data):
                 return True
 
     def min_val_bst_node(self, BSTNode):
+        ''' for returning the node with the lowest value '''
         current = BSTNode
 
         # loop down to find the leftmost leaf
@@ -196,28 +201,29 @@ def find(self, data):
     def inorder(self, root):
         '''
         @type: root:   Node object
+        in this we first traverse to the leftmost node and then print the data and then move to the rightmost child
         '''
         if root:
             self.inorder(root.get_left())                # traverse to leftmost child
             self._inorder.append(root.get_data())        # get the data of current node
             self.inorder(root.get_right())               # traverse to rightmost child
         return self._inorder
 
-    # in this we first print the root node and then traverse towards leftmost node and then to the rightmost node
     def preorder(self, root):
         '''
         @type: root:   Node object
+        in this we first print the root node and then traverse towards leftmost node and then to the rightmost node
         '''
         if root:
             self._preorder.append(root.get_data())       # get the data of current node
             self.preorder(root.get_left())               # traverse to leftmost child
             self.preorder(root.get_right())              # traverse to rightmost child
         return self._preorder
 
-    # in this we first traverse to the leftmost node and then to the rightmost node and then print the data
     def postorder(self, root):
         '''
         @type: root:   Node object
+        in this we first traverse to the leftmost node and then to the rightmost node and then print the data
         '''
         if root:
             self.postorder(root.get_left())              # traverse to leftmost child