Better Comments added

bharathikannann · bharathikannann · commit 1f95beab0a0d · 2021-06-30T14:14:09.000+05:30
diff --git a/README.md b/README.md
@@ -58,13 +58,14 @@ Keep coding! :)
   - <details>
     <summary>Available Methods</summary>
 
-    - delete() 
-    - insertAtFirst() 
-    - insertAtLast() 
-    - insertAtPosition() 
-    - length() 
-    - reversePrint() 
-    - show()
+    - *delete()* - Delete an element
+    - *deleteList* - Delete the entire doubly linked list
+    - *insertAtFirst()* - Inserting at first
+    - *insertAtLast()* - Insert node at last
+    - *insertAtPosition()* - Insert at a certain position
+    - *length()* - Count of nodes in our doubly linked list
+    - *reversePrint()* - Print all the elements in reverse
+    - *show()* - To print all the elements
     </details>
 <span></span>
 
@@ -74,8 +75,8 @@ Keep coding! :)
   - <details>
     <summary>Available Methods</summary>
 
-    - rotateClockwise()
-    - rotateAntiClocwise()
+    - *rotateClockwise()* - Rotate Colockwise
+    - *rotateAntiClocwise()* - Rotate AntiClockwise
     </details>
 <span></span> 
 
@@ -103,9 +104,9 @@ Keep coding! :)
   - <details>
     <summary>Available Methods</summary>
 
-    - add()
-    - search()
-    - show()
+    - *add()* - Add words to trie
+    - *search()* - Search elements in trie
+    - *show()* - Display all words in trie
     </details>
 <span></span> 
 
@@ -116,37 +117,39 @@ Keep coding! :)
   - <details>
     <summary>Available Methods</summary>
 
-    - delete() 
-    - empty() 
-    - getDiffEvenOddRows() 
-    - getLevelOfNode() 
-    - height() 
-    - ifMirrorStructureTree() 
-    - ifMirrorTree() 
-    - ifSameStructureTree() 
-    - ifSameTree() 
-    - inorderUsingStack() 
-    - insert() 
-    - isFoldable() 
-    - isIdentical() 
-    - leftSideOfTree() 
-    - levelOrderTraversal() 
-    - levelOrderTraversalLineByLine() 
-    - levelWiseSum() 
-    - maxWidth() 
-    - mirrorTree() 
-    - noOfNodes() 
-    - postorder() 
-    - preorder() 
-    - printAtGivenLevel() 
-    - printBetweenTwoLevels() 
-    - printLeaves() 
-    - recursiveSearch() 
-    - reverseLevelOrderTraversal() 
-    - rightSideOfTree() 
-    - search() 
-    - spiralOrder() 
-    - sum()
+    - *delete()* - Delete the entire tree
+    - *empty()* - Checks empty or not
+    - *getDiffEvenOddRows()* - Difference of even and odd rows
+    - *getLevelOfNode()* -Get level of data
+    - *height()* - Height of the tree
+    - *ifMirrorStructureTree()* - If two trees are mirror structure or not
+    - *ifMirrorTree()* - If two trees are mirror ot not
+    - *ifSameStructureTree()* - If two trees are having same structure or not
+    - *ifSameTree()* - If two trees are same or not
+    - *inorder* - Inorder traversal
+    - *inorderUsingStack()* - Inorder traversal using stack
+    - *insert()* - Insert the data in a BST
+    - *isFoldable()* - Is the tree foldable or not
+    - *isIdentical()* - Two trees are identical or not
+    - *leftSideOfTree()* -Left side of the tree
+    - *levelOrderTraversal()* -Print values by level order
+    - *levelOrderTraversalLineByLine()* - Level order traversal line by line
+    - *levelWiseSum()* - Sum of all data in each level
+    - *maxWidth()* - Get maximum width of the tree
+    - *mirrorTree()* - Mirror the tree
+    - *noOfNodes()* - No of nodes in the tree
+    - *noofLeafNodes* - Number of leaf nodes
+    - *postorder()* - Postorder traversal
+    - *preorder()* - Preorder Traversal
+    - *printAtGivenLevel()* - Print values only at a certain level
+    - *printBetweenTwoLevels()* - Print data between any two levels
+    - *printLeaves()* - Print leaf nodes
+    - *recursiveSearch()* - Search using recursion
+    - *reverseLevelOrderTraversal()* - Level order traversal in reverse
+    - *rightSideOfTree()* - Right side of the tree
+    - *search()* - Return true if an element exists
+    - *spiralOrder()* -Print in spiral order
+    - *sum()* - Sum of all the values
     </details>
 <span></span> 
 
@@ -158,15 +161,15 @@ Keep coding! :)
 
 # Dynamic Programming
 
-- [Edit distance](dynamic_programming/edit_distance.py)
-- [Egg drop](dynamic_programming/egg_drop.py)
-- [Fibanocci sequence](dynamic_programming/fibanocci_sequence.py)
-- [Generate parenthesis](dynamic_programming/generate_parenthesis.py) 
-- [Kadane algorithm](dynamic_programming/kadane_algorithm.py)
-- [Knapsack 0/1](dynamic_programming/knapsack01.py) 
-- [Longest common subsequence](dynamic_programming/longest_common_subsequence.py)
-- [Min no of coins](dynamic_programming/min_no_of_coins.py)
-- [Range sum query](dynamic_programming/range_sum_query.py)
+- [Edit distance](dynamic_programming/edit_distance.py) - Number of edit distance required to change one string to another
+- [Egg drop](dynamic_programming/egg_drop.py) - Minimum no of trials needed in worst case to find the floor where the egg breaks
+- [Fibanocci sequence](dynamic_programming/fibanocci_sequence.py) - Generate fibanocci sequence
+- [Generate parenthesis](dynamic_programming/generate_parenthesis.py) - Generate matched parenthesis with n number of open and closed brackets
+- [Kadane algorithm](dynamic_programming/kadane_algorithm.py) - Largest sub array problem
+- [Knapsack 0/1](dynamic_programming/knapsack01.py) - knapsack 0/1 problem
+- [Longest common subsequence](dynamic_programming/longest_common_subsequence.py) - Longest common subsequence of two strings
+- [Min no of coins](dynamic_programming/min_no_of_coins.py) - Minimum number of coins needed to make the given amount
+- [Range sum query](dynamic_programming/range_sum_query.py) - Return the sum between two indices
 
 # Searches
 
diff --git a/dynamic_programming/egg_drop.py b/dynamic_programming/egg_drop.py
@@ -1,5 +1,5 @@
 # Egg dropping problem
-# Minimum no of trials needed in worst case to find the floor
+# Minimum no of trials needed in worst case to find the floor where the egg breaks
 def egg_drop(eggs, floors):
     INT_MAX = 32767   
     dp = [[0] * (floors + 1) for _ in range(eggs + 1)]
diff --git a/dynamic_programming/fibanocci_sequence.py b/dynamic_programming/fibanocci_sequence.py
@@ -1,3 +1,4 @@
+# Generate fibanocci sequence
 def fibanocci_sequence(n: int) -> int:
     if n<=1:
         return n
diff --git a/dynamic_programming/min_no_of_coins.py b/dynamic_programming/min_no_of_coins.py
@@ -1,3 +1,4 @@
+# Minimum number of coins needed to make the given amount
 def min_no_of_coins(amount:int, coins: list) -> int:
     # DP stores the number of coin used for each amount
     # Initialize all values to amount + 1 as a dummy value
diff --git a/hashing/hash_table.py b/hashing/hash_table.py
@@ -10,7 +10,7 @@ def get_hash(self, key):
         for char in key:
             hash += ord(char)   # Ord returns the ASCII value of character
         return hash % self.size # Mod of total hash vs size is the final hash
-    
+    # ------------------------------------------------------------------------------------------
     # https://docs.python.org/3/reference/datamodel.html#emulating-container-types
     # By using __setitem__, __delitem__, __getitem__ we can easily work with hash objects
     def __setitem__(self, key, val):
@@ -22,13 +22,13 @@ def __setitem__(self, key, val):
                 found = True
         if not found:                                 # If not found append at last
             self.arr[h].append((key, val))
-    
+    # ------------------------------------------------------------------------------------------
     def __delitem__(self, key):
         h = self.get_hash(key)
         for idx, element in enumerate(self.arr[h]):   # Find the position in sepearte chains and delete at that position
             if element[0] == key:
                 del self.arr[h][idx]
-                
+    # ------------------------------------------------------------------------------------------            
     def __getitem__(self, key):
         h = self.get_hash(key)
         for element in self.arr[h]:
diff --git a/linked_list/doubly_linked_list.py b/linked_list/doubly_linked_list.py
@@ -1,18 +1,8 @@
-# ### Author: [BHARATHI KANNAN N](https://github.com/bharathikannann)
+# Author: BHARATHI KANNAN N - Github: https://github.com/bharathikannann, linkedin: https://linkedin.com/in/bharathikannann 
 # 
 # ## Doubly Linked List
 # - A doubly linked list is a linked data structure that consists of a set of sequentially linked records called nodes. Each node contains three fields: two link fields (references to the previous and to the next node in the sequence of nodes) and one data field.
 # - The two node links allow traversal of the list in either direction. 
-# 
-# ### Available methods
-# 
-# - insertAtFirst()
-# - insertAtLast()
-# - insertAtPosition()
-# - show()
-# - delete()
-# - length()
-# - reversePrint()
 
 #Structure of the node for our doubly linked list
 class Node(object):
diff --git a/linked_list/linked_list.py b/linked_list/linked_list.py
@@ -1,10 +1,9 @@
-# ### Author: [BHARATHI KANNAN N](https://github.com/bharathikannann)
-# 
+# Author: BHARATHI KANNAN N - Github: https://github.com/bharathikannann, linkedin: https://linkedin.com/in/bharathikannann 
 # ## Linked List
 # 
-# - Linked list is a linear collection of data elements whose order is not given by their physical placement in memory. Instead, each element points to the next.<br>
-# - In its most basic form, each node contains: data, and a reference<br>
-# - This structure allows for efficient insertion or removal of elements from any position in the sequence during iteration.<br>
+# - Linked list is a linear collection of data elements whose order is not given by their physical placement in memory. Instead, each element points to the next.
+# - In its most basic form, each node contains: data, and a reference
+# - This structure allows for efficient insertion or removal of elements from any position in the sequence during iteration.
 # - Linked lists are among the simplest and most common data structures. They can be used to implement several other common abstract data types, including lists, stacks, queues, etc..,
 # 
 # ### Time Complexity:
@@ -15,29 +14,6 @@
 # - Deletion: O(1)
 # - Indexing: O(n)
 # - Searching: O(n)
-# 
-# ## Available methods
-# 
-# - insertAtFirst() 
-# - insertAtPosition() 
-# - insertAtLast()
-# - delete()
-# - show()
-# - ifNodeExists()
-# - length()
-# - rotateCloclwise()
-# - rotateAntiClockwise()
-# - reverse()
-# - reverseRecursion()
-# - getMiddleElement()
-# - isFirstSecondHalfMatch()
-# - isPalindrome()
-# - deleteGreaterValuesOnRight()
-# - pairwiseSwapElements()
-# - deleteAlternateNodes()
-# - moveLastNodeToFront()
-# - getCountOfValue()
-# - deleteList()
 
 #Structure of the node for our linked list
 class Node():
@@ -117,7 +93,7 @@ def insertAtPosition(self, data, position):
             temp.next = newNode
     
     # ------------------------------------------------------------------------------------------
-    # Deleting the data at any position
+    # Deleting the data at any position 
     # Steps
     # 1. If head is the data to be deleted and if is none return none and if it the element to be deleted
     # change the head to the next of head by using temp node
@@ -534,7 +510,4 @@ def getCountOfValue(self, n):
     2
     Delete entire list
     No element present in the list
-    '''
-
-
-# <big> To refer all of these implementations in java [click here](https://github.com/bharathikannann/Data-Structures-and-Algorithms/blob/master/LinkedList/LinkedList.java) </big>
+    '''
diff --git a/linked_list/merge_two_sorted_linked_lists.py b/linked_list/merge_two_sorted_linked_lists.py
@@ -1,6 +1,6 @@
-# ### Author: [BHARATHI KANNAN N](https://github.com/bharathikannann)
+# Author: BHARATHI KANNAN N - Github: https://github.com/bharathikannann, linkedin: https://linkedin.com/in/bharathikannann 
 # 
-# <big>Merging Two Sorted Linked lists</big><br>
+# Merging Two Sorted Linked lists
 # Merge sort algorithm
 class Node():
     def __init__(self, data, next=None):
diff --git a/linked_list/reversing_linked_list.py b/linked_list/reversing_linked_list.py
@@ -1,6 +1,6 @@
-# ### Author: [BHARATHI KANNAN N](https://github.com/bharathikannann)
+# Author: BHARATHI KANNAN N - Github: https://github.com/bharathikannann, linkedin: https://linkedin.com/in/bharathikannann 
 # 
-# <big>Sorting in Linked lists</big><br>
+# Sorting in Linked lists
 # Merge sort algorithm
 
 class Node():
diff --git a/linked_list/rotating_linked_list.py b/linked_list/rotating_linked_list.py
@@ -1,6 +1,6 @@
-# ### Author: [BHARATHI KANNAN N](https://github.com/bharathikannann)
+# Author: BHARATHI KANNAN N - Github: https://github.com/bharathikannann, linkedin: https://linkedin.com/in/bharathikannann 
 # 
-# <big>Sorting in Linked lists</big><br>
+# Sorting in Linked lists
 # Merge sort algorithm
 
 class Node():
diff --git a/linked_list/sorting_linked_list.py b/linked_list/sorting_linked_list.py
@@ -1,6 +1,6 @@
-# ### Author: [BHARATHI KANNAN N](https://github.com/bharathikannann)
+# Author: BHARATHI KANNAN N - Github: https://github.com/bharathikannann, linkedin: https://linkedin.com/in/bharathikannann 
 # 
-# <big>Sorting in Linked lists</big><br>
+# Sorting in Linked lists
 # Merge sort algorithm
 
 class Node():
diff --git a/queue/queue.py b/queue/queue.py
@@ -1,9 +1,7 @@
-# ### Author: [BHARATHI KANNAN N](https://github.com/bharathikannann)
+# Author: BHARATHI KANNAN N - Github: https://github.com/bharathikannann, linkedin: https://linkedin.com/in/bharathikannann 
 # 
 # ### Queue
-# 
 # A queue is a collection of entities that are maintained in a sequence and can be modified by the addition of entities at one end of the sequence and the removal of entities from the other end of the sequence.
-# 
 # The operation of adding an element to the rear of the queue is known as `enqueue`, and the operation of removing an element from the front is known as `dequeue`.
 
 #Structure of the node for our linked list
@@ -19,7 +17,7 @@ def __init__(self):
         self.front = self.rear = None
         # Size for our queue
         self.size = 0
-        
+    # ------------------------------------------------------------------------------------------    
     def enqueue(self, data):
         # Create new node
         newNode = Node(data)
@@ -34,7 +32,7 @@ def enqueue(self, data):
         self.rear = self.rear.next
         # Increment size
         self.size += 1
-        
+    # ------------------------------------------------------------------------------------------    
     def dequeue(self):
         # If queue is empty
         if(self.rear == None):
diff --git a/stack/stack.py b/stack/stack.py
@@ -1,12 +1,10 @@
-# ### Author: [BHARATHI KANNAN N](https://github.com/bharathikannann)
+# Author: BHARATHI KANNAN N - Github: https://github.com/bharathikannann, linkedin: https://linkedin.com/in/bharathikannann 
 # 
 # ### Stack
 # 
 # A stack is an abstract data type that serves as a collection of elements, with two main principal operations:
-# 
 # - Push, which adds an element to the collection, and
 # - Pop, which removes the most recently added element.
-# 
 # The order in which elements come off a stack gives rise to its alternative name, LIFO (last in, first out).
 #Structure of the node for our linked list
 class Node:
diff --git a/trees/binary_search_tree.py b/trees/binary_search_tree.py
diff --git a/trees/red_black_tree.py b/trees/red_black_tree.py
diff --git a/trees/tree.py b/trees/tree.py
diff --git a/trie/trie.py b/trie/trie.py

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,4 @@`
	`1`	`+# Generate fibanocci sequence`
`1`	`2`	`def fibanocci_sequence(n: int) -> int:`
`2`	`3`	`if n<=1:`
`3`	`4`	`return n`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,4 @@`
	`1`	`+# Minimum number of coins needed to make the given amount`
`1`	`2`	`def min_no_of_coins(amount:int, coins: list) -> int:`
`2`	`3`	`# DP stores the number of coin used for each amount`
`3`	`4`	`# Initialize all values to amount + 1 as a dummy value`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`		`-# ### Author: [BHARATHI KANNAN N](https://github.com/bharathikannann)`
	`1`	`+# Author: BHARATHI KANNAN N - Github: https://github.com/bharathikannann, linkedin: https://linkedin.com/in/bharathikannann`
`2`	`2`	`#`
`3`		`-# <big>Merging Two Sorted Linked lists</big><br>`
	`3`	`+# Merging Two Sorted Linked lists`
`4`	`4`	`# Merge sort algorithm`
`5`	`5`	`class Node():`
`6`	`6`	`def __init__(self, data, next=None):`
Original file line number	Diff line number	Diff line change
`@@ -1,12 +1,10 @@`
`1`		`-# ### Author: [BHARATHI KANNAN N](https://github.com/bharathikannann)`
	`1`	`+# Author: BHARATHI KANNAN N - Github: https://github.com/bharathikannann, linkedin: https://linkedin.com/in/bharathikannann`
`2`	`2`	`#`
`3`	`3`	`# ### Stack`
`4`	`4`	`#`
`5`	`5`	`# A stack is an abstract data type that serves as a collection of elements, with two main principal operations:`
`6`		`-#`
`7`	`6`	`# - Push, which adds an element to the collection, and`
`8`	`7`	`# - Pop, which removes the most recently added element.`
`9`		`-#`
`10`	`8`	`# The order in which elements come off a stack gives rise to its alternative name, LIFO (last in, first out).`
`11`	`9`	`#Structure of the node for our linked list`
`12`	`10`	`class Node:`