docs: Clean-up minor errors

Author: 4ndrelim

README.md

@@ -16,7 +16,7 @@ Gradle is used for development.
 - Adelson-Velskii and Landis (AVL) Binary Search Tree
 - [Disjoint Set / Union Find](src/main/java/dataStructures/disjointSet)
     * [Quick Find](src/main/java/dataStructures/disjointSet/quickFind)
-    * [Weighted Union]((src/main/java/dataStructures/disjointSet)/weightedUnion)
+    * [Weighted Union](src/main/java/dataStructures/disjointSet/weightedUnion)
       * Path compression
 - [Hashing](src/main/java/dataStructures/hashSet)
     * [Chaining](src/main/java/dataStructures/hashSet/chaining)

src/main/java/algorithms/sorting/bubbleSort/README.md

@@ -9,7 +9,7 @@ largest (or smallest) element in the unsorted region to the sorted region (often
 ![bubble sort img](../../../../../../docs/assets/images/BubbleSort.jpeg)
 
 ### Implementation Invariant
-After the kth iteration, the biggest k items are correctly sorted at the final k positions of the array. 
+**After the kth iteration, the biggest k items are correctly sorted at the final k positions of the array**. 
 
 The job of the kth iteration of the outer loop is to bubble the kth-largest element to the kth position of the array 
 from the right (i.e. its correct position). 

src/main/java/algorithms/sorting/countingSort/README.md

@@ -11,15 +11,15 @@ encountered. <br>
 
 ### Implementation Invariant
 
-At the end of the ith iteration, the ith element (of the original array) from the back will be placed in
-its correct position.
+**At the end of the ith iteration, the ith element (of the original array) from the back will be placed in
+its correct position**.
 
 Note: An alternative implementation from the front is easily done with minor modification.
 The catch is that this implementation would not be stable.
 
 ### Common Misconception
 
-_Counting sort does not require total ordering of elements since it is non-comparison based._
+_"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 our implementation, the total ordering property is reflected by virtue of the structure of the frequency map.

src/main/java/algorithms/sorting/cyclicSort/README.md

@@ -7,8 +7,8 @@ Though under some conditions (discussed later), the best case could be done in O
 
 ### Implementation Invariant
 
-At the end of the ith iteration, the ith element
-(of the original array, from either the back or front depending on implementation), is correctly positioned.
+**At the end of the ith iteration, the ith element
+(of the original array, from either the back or front depending on implementation), is correctly positioned**.
 
 ### Comparison to Selection Sort
 

src/main/java/algorithms/sorting/insertionSort/README.md

@@ -14,7 +14,7 @@ it into arr[0, k-1] following sorted order, returning us arr[0, k] in sorted ord
 ![InsertionSort](../../../../../../docs/assets/images/InsertionSort.png)
 
 ### Implementation Invariant
-The loop invariant: At the end of kth iteration, the first (k+1) items in the array are in sorted order.
+The loop invariant: **At the end of kth iteration, the first (k+1) items in the array are in sorted order**.
 
 At the end of the (n-1)th iteration, all n items in the array will be in sorted order.
 

src/main/java/algorithms/sorting/selectionSort/README.md

@@ -13,7 +13,7 @@ would be in the sorted array.
 Let the array of length n to be sorted be A.
 
 The loop invariant is:
-At the end of the kth iteration, the smallest k items are correctly sorted in the first k positions of the array.
+**At the end of the kth iteration, the smallest k items are correctly sorted in the first k positions of the array**.
 
 So, at the end of the (n-1)th iteration of the loop, the smallest (n-1) items are correctly sorted in the first (n-1)
 positions of the array, leaving the last item correctly positioned in the last index of the array. Therefore,

src/main/java/dataStructures/disjointSet/README.md

@@ -12,8 +12,8 @@ query if there already exists a path between 2 nodes.
 
 Generally, there are 2 main operations:
 
-1. Union: Join two subsets into a single subset
-2. Find: Determine which subset a particular element is in. In practice, this is often done to check
+1. **Union**: Join two subsets into a single subset
+2. **Find**: Determine which subset a particular element is in. In practice, this is often done to check
    if two elements are in the same subset or component.
 
 The Disjoint Set structure is often introduced in 3 parts, with each iteration being better than the
@@ -27,12 +27,12 @@ Querying for connectivity and updating usually tracked with an internal array.
 a balanced tree and hence complexity does not necessarily improve
    - Note, this is not implemented but details can be found under weighted union folder.
 
-3. **Weighted Union** - Same idea of using a tree, but constructed in a way that the tree is balanced, leading to improved
-complexities. Can be further augmented with path compression.
+3. **Weighted Union** - Same idea of using a tree, but constructed in a way that the tree is balanced, leading to 
+4. improved complexities. Can be further augmented with path compression.
 
 ## Applications
 Because of its efficiency and simplicity in implementing, Disjoint Set structures are widely used in practice:
-1. As mentioned, it is often sued as a helper structure for Kruskal's MST algorithm
+1. As mentioned, it is often used as a helper structure for Kruskal's MST algorithm
 2. It can be used in the context of network connectivity
    - Managing a network of computers 
    - Or even analyse social networks, finding communities and determining if two users are connected through a chain
@@ -42,4 +42,4 @@ Because of its efficiency and simplicity in implementing, Disjoint Set structure
 
 ## Notes
 Disjoint Set is a data structure designed to keep track of a set of elements partitioned into a number of 
-non-overlapping subsets. It is not suited for handling duplicates and so our implementation ignores duplicates.
+non-overlapping subsets. **It is not suited for handling duplicates** and so our implementation ignores duplicates.

src/main/java/dataStructures/disjointSet/weightedUnion/README.md

@@ -49,7 +49,8 @@ objects of the smaller tree becomes part of the larger tree (by setting the root
 
 Notice that trees will only increase in height when it's size is doubled. Working on this intuition, one can show 
 (by induction) that a tree of height h has at least 2^h elements. Consequently, 
-**a tree of size n is at most height of logn**.
+**a tree of size n is at most height of logn**. <br/>
+_Note: n = 2^(logn)_
 
 ### Implementation Details
 The concept introduces the idea of constructing trees and forests and certainly, one can similarly implement a 
@@ -72,9 +73,10 @@ assigning to its grandparent actually suffice and yield the same big-O upper-bou
 done in a single pass.). By doing so, we greatly reduce the height of the trees formed.
 
 The analysis with compression is a bit trickier here and talks about the inverse-Ackermann function. 
-Interested readers can find out more [here](https://dl.acm.org/doi/pdf/10.1145/321879.321884)
+Interested readers can find out more [here](https://dl.acm.org/doi/pdf/10.1145/321879.321884).
 
 **Time**: O(alpha)
+
 **Space**: O(n)
 
 ## Notes