Updates to data_structures:

    - queue.py
		- Updated docstrings at top of file
		- Updated docstrings for functions
		- Optimized import statements
		- Removed redundant import statments in methods
	- linked_list.py
		- Updated docstrings at top of file
		- Updated docstrings for functions
		- Optimized import statements
		- Removed redundant import statments in methods
		- Updated conditionals and syntaxing
		- Removed redundant parenthesis around conditionals
		- Removed camel casing on variables
	- heap.py
		- Updated docstrings at top of file
		- Updated docstrings for functions
		- Optimized import statements
		- Removed redundant import statments in methods
		- Updated parent_idx, left_child_idx, right_child_idx, time_complexities to be static
		- removed unused variable 'ROOT' from heapify_down()
	- stack.py
		- Updated docstrings at top of file
		- Updated docstrings for functions
		- Optimized import statements
		- Removed redundant import statments in methods
		- Removed camel casing on methods and variables
		- Updated get_code() in Stack(object) to be static
		- Updated _isOperand(), _precedence() in InfixToPostfix() to be static and private
		- Updated get_code() to be static
		- Updated method _isOperand()
		- Removed redundant parenthesis around conditionals
	- tree.py
	  	- Updated docstrings at top of file
		- Updated docstrings for functions
		- Optimized import statements
		- Removed redundant import statments in methods
		- Removed redundant parenthesis around conditionals
		- Updated min_val_bst_node(), get_code()
		- Removed camel casing on variables and parameter names

Signed-off-by: IanDoarn <[email protected]>

Author: IanDoarn

pygorithm/data_structures/heap.py

@@ -3,40 +3,57 @@
 Contributed: OMKAR PATHAK
 Created On: 11th August 2017
 """
+from __future__ import division
 from pygorithm.data_structures import queue
+import inspect
 
 
 class Heap(queue.Queue):
-    ''' min-heap implementation as queue '''
-    def parent_idx(self, idx):
-        ''' retrieve the parent '''
+    """
+    min-heap implementation as queue
+    """
+
+    @staticmethod
+    def parent_idx(idx):
+        """
+        retrieve the parent
+        """
         return idx // 2
 
-    def left_child_idx(self, idx):
-        ''' retrieve the left child '''
+    @staticmethod
+    def left_child_idx(idx):
+        """
+        retrieve the left child
+        """
         return (idx * 2) + 1
 
-    def right_child_idx(self, idx):
-        ''' retrieve the right child '''
+    @staticmethod
+    def right_child_idx(idx):
+        """
+        retrieve the right child
+        """
         return (idx * 2) + 2
 
     def insert(self, data):
-        ''' inserting an element in the heap '''
+        """
+        inserting an element in the heap
+        """
+        # TODO: Fix this if we want this compatible with 2.7
         super().enqueue(data)
         if self.rear >= 1:  # heap may need to be fixed
             self.heapify_up()
 
     def heapify_up(self):
-        '''
+        """
         Start at the end of the tree (last enqueued item).
 
         Compare the rear item to its parent, swap if
         the parent is larger than the child (min-heap property).
         Repeat until the min-heap property is met.
 
         Best Case:   O(1), item is inserted at correct position, no swaps needed
-        Worst Case:  O(logn), item needs to be swapped throughout all levels of tree
-        '''
+        Worst Case:  O(log n), item needs to be swapped throughout all levels of tree
+        """
         child = self.rear
         parent = self.parent_idx(child)
         while self.queue[child] < self.queue[self.parent_idx(child)]:
@@ -46,38 +63,45 @@ def heapify_up(self):
             parent = self.parent_idx(child)
 
     def pop(self):
-        ''' Removes the lowest value element (highest priority, at root) from the heap '''
+        """
+        Removes the lowest value element (highest priority, at root) from the heap
+        """
         min = super().dequeue()
         if self.rear >= 1:  # heap may need to be fixed
             self.heapify_down()
         return min
 
     def favorite(self, parent):
-        ''' Determines which child has the highest priority by 3 cases '''
+        """
+        Determines which child has the highest priority by 3 cases
+        """
         left = self.left_child_idx(parent)
         right = self.right_child_idx(parent)
 
-        if left <= self.rear and right <= self.rear:  # case 1: both nodes exist
+        # case 1: both nodes exist
+        if left <= self.rear and right <= self.rear:
             if self.queue[left] <= self.queue[right]:
                 return left
             else:
                 return right
-        elif left <= self.rear:  # case 2: only left exists
+        # case 2: only left exists
+        elif left <= self.rear:
             return left
-        else:  # case 3: no children (if left doesn't exist, neither can the right)
+        # case 3: no children (if left doesn't exist, neither can the right)
+        else:
             return None
 
     def heapify_down(self):
-        '''
+        """
         Select the root and sift down until min-heap property is met.
 
         While a favorite child exists, and that child is smaller
         than the parent, swap them (sift down).
 
         Best Case:   O(1), item is inserted at correct position, no swaps needed
         Worst Case:  O(logn), item needs to be swapped throughout all levels of tree
-        '''
-        cur = ROOT = 0  # start at the root
+        """
+        cur = 0  # start at the root
         fav = self.favorite(cur)  # determine favorite child
         while self.queue[fav] is not None:
             if self.queue[cur] > self.queue[fav]:
@@ -88,10 +112,13 @@ def heapify_down(self):
             else:
                 return
 
-    def time_complexities(self):
-        return '''[Insert & Pop] Best Case: O(1), Worst Case: O(logn)'''
+    # TODO: Is this necessary?
+    @staticmethod
+    def time_complexities():
+        return "[Insert & Pop] Best Case: O(1), Worst Case: O(logn)"
 
     def get_code(self):
-        ''' returns the code for the current class '''
-        import inspect
+        """
+        returns the code for the current class
+        """
         return inspect.getsource(Heap)