improve clarity

Author: 4ndrelim

README.md

@@ -38,7 +38,6 @@ Gradle is used for development.
   - [Monotonic Queue](src/main/java/dataStructures/queue/monotonicQueue)
 - [Segment Tree](src/main/java/dataStructures/segmentTree)
 - [Stack](src/main/java/dataStructures/stack)
-- [Segment Tree](src/main/java/dataStructures/segmentTree)
 - [Trie](src/main/java/dataStructures/trie)
 
 ## Algorithms

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

@@ -1,13 +1,17 @@
 # AVL Trees
 
 ## Background
-Is the fastest way to search for data to store them in an array, sort them and perform binary search? No. This will
-incur minimally O(nlogn) sorting cost, and O(n) cost per insertion to maintain sorted order.
+Say you want to search of a data in an array. If the array were sorted, lucky you! You can do it with binary search in 
+`O(logn)` time. But if the array weren't sorted, you can't avoid that `O(n)` linear search loop. Now, one idea is to 
+first sort the array, and incur a 1-time cost of `O(n)` and subsequent search operations can enjoy that `O(logn)` query 
+cost. This is all gucci, but it assumes that there will be no additional data streaming in. If incoming data is not 
+infrequent, you'll have to incur `O(n)` insertion cost each time to maintain sorted order, and this can undermine 
+performance as a whole. If only there were some structure that allows us to enjoy `O(logn)` operations across..
 
 We have seen binary search trees (BSTs), which always maintains data in sorted order. This allows us to avoid the
 overhead of sorting before we search. However, we also learnt that unbalanced BSTs can be incredibly inefficient for
-insertion, deletion and search operations, which are O(h) in time complexity (in the case of degenerate trees,
-operations can go up to O(n)).
+insertion, deletion and search operations, which are O(height) in time complexity (in the case of degenerate trees, 
+think of a linked list, operations can go up to O(n)).
 
 Here we discuss a type of self-balancing BST, known as the AVL tree, that avoids the worst case O(n) performance 
 across the operations by ensuring careful updating of the tree's structure whenever there is a change 

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

@@ -28,7 +28,8 @@ 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 
-4. improved complexities. Can be further augmented with path compression.
+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:
@@ -38,6 +39,7 @@ Because of its efficiency and simplicity in implementing, Disjoint Set structure
    - Or even analyse social networks, finding communities and determining if two users are connected through a chain
 3. Can be part of clustering algorithms to group data points based on similarity - useful for ML
 4. It can be used to detect cycles in dependency graphs, e.g, software dependency management systems
+   1. Static analysis tools like `mypy` use this to identify circular dependencies!
 5. It can be used for image processing, in labelling different connected components of an image
 
 ## Notes

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

@@ -23,7 +23,9 @@ and check if they are equal. This is why this implementation is known as "Quick
 ## Complexity Analysis
 Let n be the number of elements in consideration.
 
-**Time**: O(n) for Union and O(1) for Find operations
+**Time**: 
+    - Union: O(n)
+    - Find: O(1)
 
 **Space**: O(n) auxiliary space for the component identifier