docs: fix typos

Author: kaitinghh

README.md

@@ -79,7 +79,7 @@ Gradle is used for development.
     * [Radix Sort](src/main/java/algorithms/sorting/radixSort) (found in tutorial)
 4. Trees
     * [Binary search tree](src/main/java/dataStructures/binarySearchTree)
-    * AVL-tree
+    * [AVL-tree](src/main/java/dataStructures/avlTree)
     * Orthogonal Range Searching
     * [Trie](src/main/java/dataStructures/trie)
     * [B-Tree](src/main/java/dataStructures/bTree)

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

@@ -6,7 +6,7 @@ Counting sort is a non-comparison-based sorting algorithm and isn't bounded by t
 of most sorting algorithms. <br>
 It first obtains the frequency map of all elements (i.e. 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.
-It is updated after each insertion to reflection the new position to insert the next time the same element is
+It is updated after each insertion to reflect the new position to insert the next time the same element is
 encountered. <br>
 
 ![counting sort img](../../../../../../docs/assets/images/CountingSort.png)
@@ -41,5 +41,7 @@ Counting sort is NOT AN IN-PLACE algorithm. For one, it requires additional spac
 
 ## Notes
 
-1. Counting sort (stable version) is often used as a sub-routine for radix sort.
-2. Supplementary: Here is a [video](https://www.youtube.com/watch?v=OKd534EWcdk) if you are still having troubles.
+1. Our counting sort implementation works only on non-negative integers. However, to adapt it to work for arrays with
+negative integers, we can add an offset of +m, where m is the smallest integer in the array. 
+2. Counting sort (stable version) is often used as a sub-routine for radix sort.
+3. Supplementary: Here is a [video](https://www.youtube.com/watch?v=OKd534EWcdk) if you are still having troubles.

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

@@ -31,9 +31,9 @@ In practice, numbers are often interpreted in their binary representation, with
 bit chunk of a specified size (usually 8 bits/1 byte, though this number could vary for optimization).
 
 For our implementation, we utilize the binary representation of elements, partitioning them into 8-bit segments. 
-Given that an integer is typically represented in 32 bits, this results in four segments per integer. 
+Given that an integer is typically represented in 32 bits, this results in four segments. 
 By applying the sorting subroutine to each segment across all integers, we can efficiently sort the array. 
-This method requires sorting the array four times in total, once for each 8-bit segment,
+This method requires sorting the array four times in total, once for each 8-bit segment.
 
 ### Implementation Invariant
 At the end of the *ith* iteration, the elements are sorted based on their numeric value up till the *ith* segment.