Decide structure of README

Author: 4ndrelim

src/algorithms/patternFinding/README.md

@@ -6,6 +6,12 @@ in text editors when searching for a pattern, in computational biology sequence
 in NLP problems, and even for looking for file patterns for effective file management.
 It is hence crucial that we develop an efficient algorithm.
 
+![KMP](../../../assets/kmp.png)
+Image Source: GeeksforGeeks
+
+## Analysis
+**Time complexity**:
+
 Naively, we can look for patterns in a given sequence in O(nk) where n is the length of the sequence and k
 is the length of the pattern. We do this by iterating every character of the sequence, and look at the 
 immediate k-1 characters that come after it. This is not a big issue if k is known to be small, but there's
@@ -15,9 +21,9 @@ KMP does this in O(n+k) by making use of previously identified sub-patterns. It
 by first processing the pattern input in O(k) time, allowing identification of patterns in
 O(n) traversal of the sequence. More details found in the src code.
 
-![KMP](../../../assets/kmp.png)
-Image Source: GeeksforGeeks
-
+**Space complexity**: O(k) auxiliary space to store suffix that matches with prefix of the pattern string
 
-If you have trouble understanding the implementation, 
-here is a good [video](https://www.youtube.com/watch?v=EL4ZbRF587g). 
+## Notes
+A detailed illustration of how the algorithm works is shown in the code. 
+But if you have trouble understanding the implementation, 
+here is a good [video](https://www.youtube.com/watch?v=EL4ZbRF587g) as well. 

src/algorithms/sorting/countingSort/CountingSort.java

@@ -1,45 +1,34 @@
 package src.algorithms.sorting.countingSort;
 
 /**
- * Stable implementation of Counting Sort.
- * 
- * <p></p>
+ * <p></p> Stable implementation of Counting Sort.
  *
- * Brief Description: <br>
+ * <p></p> Brief Description: <br>
  * Counting sort is a non-comparison based sorting algorithm and isn't bounded by the O(nlogn) lower-bound
  * of most sorting algorithms. <br>
  * It first obtains the frequency map of all elements (ie counting the occurrence of every element), then
  * computes the prefix sum for the map. This prefix map tells us which position an element should be inserted. <br>
  * Ultimately, each group of elements will be placed together, and the groups in succession, in the sorted output.
  *
- * <p></p>
- *
- * Assumption for use: <br>
+ * <p></p> Assumption for use: <br>
  * To perform counting sort, the elements must first have total ordering and their rank must be known.
  *
- * <p></p>
- *
- * Implementation Invariant: <br>
+ * <p></p> Implementation Invariant: <br>
  * At the end of the ith iteration, the ith element from the back will be placed in its rightful position.
  *
  * <p></p>
- *
  * COMMON MISCONCEPTION: Counting sort does not require total ordering of elements since it is non-comparison based.
  * This is incorrect. It requires total ordering of elements to determine their relative positions in the sorted output.
  * In fact, in conventional implementation, the total ordering property is reflected by virtue of the structure
  * of the frequency map.
  *
- * <p></p>
- *
- * Complexity Analysis: <br>
+ * <p></p> Complexity Analysis: <br>
  * Time: O(k+n)=O(max(k,n)) where k is the value of the largest element and n is the number of elements. <br>
  * Space: O(k+n)=O(max(k,n)) <br>
  * Counting sort is most efficient if the range of input values do not exceed the number of input values. <br>
  * Counting sort is NOT AN IN-PLACE algorithm. For one, it requires additional space to store freq map. <br>
  *
- * <p></p>
- *
- * Note: Implementation deals with integers but the idea is the same and can be generalised to other objects,
+ * <p></p> Note: Implementation deals with integers but the idea is the same and can be generalised to other objects,
  * as long as what was discussed above remains true.
  */
 public class CountingSort {

src/algorithms/sorting/countingSort/README.md

@@ -0,0 +1,19 @@
+# Counting Sort
+
+Counting sort is a non-comparison based sorting algorithm and isn't bounded by the O(nlogn) lower-bound 
+of most sorting algorithms.
+It first obtains the frequency map of all elements (ie counting the occurrence of every element), then
+computes the prefix sum for the map. This prefix map tells us which position an element should be inserted.
+Ultimately, each group of elements will be placed together, and the groups in succession, in the sorted output.
+
+## Complexity Analysis
+Time: O(k+n)=O(max(k,n)) where k is the value of the largest element and n is the number of elements. <br>
+Space: O(k+n)=O(max(k,n)) <br>
+Counting sort is most efficient if the range of input values do not exceed the number of input values. <br>
+Counting sort is NOT AN IN-PLACE algorithm. For one, it requires additional space to store freq map. <br>
+
+## Notes
+COMMON MISCONCEPTION: Counting sort does not require total ordering of elements since it is non-comparison based.
+This is incorrect. It requires total ordering of elements to determine their relative positions in the sorted output.
+In fact, in conventional implementation, the total ordering property is reflected by virtue of the structure
+of the frequency map.

src/dataStructures/heap/README.md

@@ -1,6 +1,6 @@
 # Heap
 
-## Binary Heap
+### Binary Heap
 A binary heap is often used to introduce the concept of heaps. It is a tree-based data structure that satisfies the 
 following properties:
 1. Complete binary tree - every level, except possibly the last, is completely filled
@@ -11,7 +11,7 @@ making it suitable as an underlying implementation of the ADT, priority queue.
 
 ![max heap](../../../assets/max_heap.png)
 
-## Array-based Heap
+### Array-based Heap
 The complete binary tree property actually allows the heap to be implemented as a contiguous array (since no gaps!).
 The parent-child relationships are derived based on the indices of the elements.
 
@@ -22,7 +22,7 @@ That said, in practice, the array-based implementation of a heap often provides
 former, in cache efficiency and memory locality. This is due to its contiguous memory layout. As such, 
 the implementation shown here is a 0-indexed array-based heap.
 
-## Relevance of increaseKey and decreaseKey operations
+### Relevance of increaseKey and decreaseKey operations
 The decision not to include explicit "decrease key" and "increase key" operations in the standard implementations of
 heaps in Python and Java is primarily due to design choices and considerations of the typical intended use cases.
 Further, this operation, without augmentation, would take O(n) due to having to search for the object to begin with
@@ -34,6 +34,10 @@ This is worth a mention. In cases like Dijkstra where the concern is having to m
 by constantly updating rather than insertion of all edges, it is not really a big issue. After all, the log factor 
 in the order of growth will turn log(E) = log(V^2) in the worst case of a complete graph, to 2log(V) = O(log(V)).
 
+## Complexity Analysis 
+Time: O(log(n)) in general for most native operations, 
+      except heapify (building a heap from a sequence of elements) that takes o(n) <br>
+Space: O(n) where n is the number of elements (whatever the structure, it must store at least n nodes) <br>
 
 ## Notes
 1. Heaps are often presented as max-heaps (eg. in textbooks), hence the implementation follows a max-heap structure

src/dataStructures/linkedList/LinkedList.java

@@ -1,30 +1,33 @@
 package src.dataStructures.linkedList;
 
 /**
- * There are many variations when it comes to implementing linked lists. Here's mine.
- * A linked list that tracks both head and tail may improve the complexity of some of the methods below
- * (e.g being able to branch off and create a new Linked List in O(1) rather than iterating to find size of branched off list)
- * 
- * Constructors:
- * LinkedList()                      -- Initialise a link list with a null head; size = 0
- * LinkedList(Node<T> head)          -- given a node, make this node the head of a new linked list; iterate to find the size
+ * <p></p>
+ * There are many variations when it comes to implementing linked lists. Here's ours. <br>
+ * A linked list that tracks both head and tail may improve the complexity of some methods below <br>
+ * (e.g being able to branch off and create a new Linked List in O(1)
+ * rather than iterating to find size of branched off list)
+ * <p></p>
+ * Constructors: <br>
+ * LinkedList()                      -- Initialise a link list with a null head; size = 0 <br>
+ * LinkedList(Node<T> head)          -- given a node, make node the head of a new linked list;
+ *                                      size is found by iterating to the end from this specified head <br>
  * LinkedList(Node<T>head, int size) -- given a head node and size of linked list specified; 
  *                                      made private to avoid client from constructing a linked list with invalid size
- * 
- * Callable methods are:
- * size()                    -- Gets the size of the linked list
- * insertFront(T object)     -- inserts the object at the front of the linked list
- * insertEnd(T object)       -- inserts the object at the end of the linked list
- * insert(T object, int idx) -- inserts the object at the specified index of the linked list
- * remove(int idx)           -- remove the node at the specified index
- * delete(T object)          -- delete the 1st encounter of the specified object from the linked list
- * pop()                     -- remove the last node from the linked list
- * poll()                    -- remove the first node from the linked list
- * search(T object)          -- search for the 1st encounter of the node that holds the specified object
- * get(int idx)              -- get the node at the specified index
- * reverse()                 -- reverse the linked list (head of linked list now starts from the back)
- * sort()                    -- sorts the linked list by their natural order
- * 
+ * <p></p>
+ * Callable methods are: <br>
+ * size()                    -- Gets the size of the linked list <br>
+ * insertFront(T object)     -- inserts the object at the front of the linked list <br>
+ * insertEnd(T object)       -- inserts the object at the end of the linked list <br>
+ * insert(T object, int idx) -- inserts the object at the specified index of the linked list <br>
+ * remove(int idx)           -- remove the node at the specified index <br>
+ * delete(T object)          -- delete the 1st encounter of the specified object from the linked list <br>
+ * pop()                     -- remove the last node from the linked list <br>
+ * poll()                    -- remove the first node from the linked list <br>
+ * search(T object)          -- search for the 1st encounter of the node that holds the specified object <br>
+ * get(int idx)              -- get the node at the specified index <br>
+ * reverse()                 -- reverse the linked list (head of linked list now starts from the back) <br>
+ * sort()                    -- sorts the linked list by their natural order <br>
+ *
  * @param <T> generic type for objects to be stored in the linked list
  */
 public class LinkedList<T extends Comparable<T>> {
@@ -241,9 +244,9 @@ public void reverse() {
   /**
    * Sorts the linked list by the natural order of the elements.
    * Generally, merge sort is the most efficient sorting algorithm for linked lists.
-   * Addressing a random node in the linked list incurrs O(n) time complexity.
+   * Accessing a random node in the linked list incurs O(n) time complexity.
    * This makes sort algorithms like quicksort and heapsort inefficient since they rely
-   * on the O(1) lookup time of an array.
+   * on the O(1) lookup time, like in an array.
    * 
    * A good video to visualise this algorithm can be found
    * <a = https://www.youtube.com/watch?v=JSceec-wEyw, href = "url">here</a>.

src/dataStructures/linkedList/README.md

@@ -18,11 +18,16 @@ linked lists are stored across memory and are connected to each other via pointe
 *Source: BeginnersBook*
 
 ## Analysis
-Some common operations involved in a linked list includes looking up elements in a linked list and inserting elements into a linked list.
+Time Complexity: Depends on operations, O(n) in general for most operations.
 
-Searching a linked list requires O(n) time complexity whereas inserting into a linked list from a specified index requires O(n) time complexity.
+Most operations require iterating the linked list. For instance,
+searching for an element in a linked list requires iterating from the head to the tail, incurring O(n)
+time complexity in the worst and average case. The best case would be O(1), for instance, when the head is the desired
+element.
 
-## Notes / Further Details / Conclusion
+Space Complexity: O(n) where n is the size of the linked list.
+
+## Notes
 
 ### Memory Requirements & Flexibility
 As a contiguous block of memory must be allocated for an array, its size is fixed.
@@ -38,12 +43,6 @@ we end up needing to store more elements at run time.
 However, linked list gives us the option of adding new nodes at run time based on our requirements, 
 allowing us to allocate memory to store items dynamically, giving us more flexibility.
 
-### Conclusion
-You should aim to use linked list in scenarios where you cannot predict how many elements you need to store
-or if you require constant time insertions to the list.
-
-However, arrays would be preferred if you already know the amount of elements you need to store ahead of time. 
-It would also be preferred if you are conducting a lot of look up operations.
 
 ## Linked List Variants
 The lookup time within a linked list is its biggest issue.