diff --git a/Arrays/Anagram_Check_manual_Sol.py b/Arrays/AnagramCheckManualSol.py
similarity index 100%
rename from Arrays/Anagram_Check_manual_Sol.py
rename to Arrays/AnagramCheckManualSol.py
diff --git a/Arrays/Anagram_Check_Sorted_Sol.py b/Arrays/AnagramCheckSortedSol.py
similarity index 100%
rename from Arrays/Anagram_Check_Sorted_Sol.py
rename to Arrays/AnagramCheckSortedSol.py
diff --git a/Arrays/ArrayFindTheMissingElement_brute_force_sol.py b/Arrays/ArrayFindTheMissingElementBruteForceSol.py
similarity index 100%
rename from Arrays/ArrayFindTheMissingElement_brute_force_sol.py
rename to Arrays/ArrayFindTheMissingElementBruteForceSol.py
diff --git a/Arrays/ArrayFindTheMissingElement_hash_table_sol.py b/Arrays/ArrayFindTheMissingElementHashTableSol.py
similarity index 100%
rename from Arrays/ArrayFindTheMissingElement_hash_table_sol.py
rename to Arrays/ArrayFindTheMissingElementHashTableSol.py
diff --git a/Arrays/ArrayFindTheMissingElement_takingSumandSubtract_sol.py b/Arrays/ArrayFindTheMissingElementSumSol.py
similarity index 100%
rename from Arrays/ArrayFindTheMissingElement_takingSumandSubtract_sol.py
rename to Arrays/ArrayFindTheMissingElementSumSol.py
diff --git a/Arrays/ArrayFindTheMissingElement_XOR_sol.py b/Arrays/ArrayFindTheMissingElementXORSol.py
similarity index 100%
rename from Arrays/ArrayFindTheMissingElement_XOR_sol.py
rename to Arrays/ArrayFindTheMissingElementXORSol.py
diff --git a/Arrays/README.md b/Arrays/README.md
index 707a82e..bc9b3d6 100644
--- a/Arrays/README.md
+++ b/Arrays/README.md
@@ -4,10 +4,10 @@ This directory contains Python implementations of common array-based algorithms
 
 ## Contents
 
-- [Anagram Check (Sorted Solution)](Anagram_Check_Sorted_Sol.py): Checks if two strings are anagrams by comparing their sorted versions.
-- [Anagram Check (Manual Solution)](Anagram_Check_manual_Sol.py): Checks if two strings are anagrams using a hash table (dictionary) to count character frequencies.
-- [Array Find Missing Element (XOR Solution)](ArrayFindTheMissingElement_XOR_sol.py): Efficiently finds a missing element in a shuffled array using bitwise XOR.
-- [Array Find Missing Element (Brute Force Solution)](ArrayFindTheMissingElement_brute_force_sol.py): Finds a missing element by sorting both arrays and comparing them.
-- [Array Find Missing Element (Hash Table Solution)](ArrayFindTheMissingElement_hash_table_sol.py): Finds a missing element using a hash table (dictionary) to track element counts.
-- [Array Find Missing Element (Sum/Subtract Solution)](ArrayFindTheMissingElement_takingSumandSubtract_sol.py): Finds a missing element by calculating the difference between the sums of the two arrays.
-- [Array Pair Sum Solution](ArrayPairSumSol.py): Finds all unique pairs in an array that sum up to a specific value $k$ using a set for $O(n)$ complexity.
+- [Anagram Check (Sorted Solution)](AnagramCheckSortedSol.py): Checks if two strings are anagrams by comparing their sorted versions. Time Complexity: $O(n \log n)$
+- [Anagram Check (Manual Solution)](AnagramCheckManualSol.py): Checks if two strings are anagrams using a hash table (dictionary) to count character frequencies. Time Complexity: $O(n)$
+- [Array Find Missing Element (XOR Solution)](ArrayFindTheMissingElementXORSol.py): Efficiently finds a missing element in a shuffled array using bitwise XOR. Time Complexity: $O(n)$
+- [Array Find Missing Element (Brute Force Solution)](ArrayFindTheMissingElementBruteForceSol.py): Finds a missing element by sorting both arrays and comparing them. Time Complexity: $O(n \log n)$
+- [Array Find Missing Element (Hash Table Solution)](ArrayFindTheMissingElementHashTableSol.py): Finds a missing element using a hash table (dictionary) to track element counts. Time Complexity: $O(n)$
+- [Array Find Missing Element (Sum Solution)](ArrayFindTheMissingElementSumSol.py): Finds a missing element by calculating the difference between the sums of the two arrays. Time Complexity: $O(n)$
+- [Array Pair Sum Solution](ArrayPairSumSol.py): Finds all unique pairs in an array that sum up to a specific value $k$ using a set. Time Complexity: $O(n)$
diff --git a/deque/DequeImple.py b/Deque/DequeImple.py
similarity index 100%
rename from deque/DequeImple.py
rename to Deque/DequeImple.py
diff --git a/deque/README.md b/Deque/README.md
similarity index 77%
rename from deque/README.md
rename to Deque/README.md
index 046a17f..82a2b19 100644
--- a/deque/README.md
+++ b/Deque/README.md
@@ -4,4 +4,4 @@ This directory contains Python implementations of the Deque (Double-Ended Queue)
 
 ## Contents
 
-- [Deque Implementation](DequeImple.py): Basic implementation of a Deque using a Python list. Includes operations like `addFront`, `addRear`, `removeFront`, `removeRear`, `isEmpty`, and `size`.
+- [Deque Implementation](DequeImple.py): Basic implementation of a Deque using a Python list. Includes operations like `addFront`, `addRear`, `removeFront`, `removeRear`, `isEmpty`, and `size`. Time Complexity: `addFront`, `removeFront` are $O(1)$; `addRear`, `removeRear` are $O(n)$.
diff --git a/Error-debug/README.md b/Error-debug/README.md
deleted file mode 100644
index c8bc4d4..0000000
--- a/Error-debug/README.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# Error and Debugging
-
-This directory contains examples of error handling and debugging techniques in Python.
-
-## Contents
-
-- [Error and Exceptions](ErrorExceptions.py): Demonstrates the use of `try`, `except`, `else`, and `finally` blocks for robust error handling, specifically validating integer user input.
diff --git a/Error-debug/ErrorExceptions.py b/ErrorHandling/ErrorExceptions.py
similarity index 100%
rename from Error-debug/ErrorExceptions.py
rename to ErrorHandling/ErrorExceptions.py
diff --git a/ErrorHandling/README.md b/ErrorHandling/README.md
new file mode 100644
index 0000000..4155aad
--- /dev/null
+++ b/ErrorHandling/README.md
@@ -0,0 +1,7 @@
+# Error Handling
+
+This directory contains examples of error handling and debugging in Python.
+
+## Contents
+
+- [Error and Exceptions](ErrorExceptions.py): Demonstrates `try`, `except`, `else`, and `finally` blocks for robust error handling.
diff --git a/GraphAlgorithms/README.md b/GraphAlgorithms/README.md
index f0330f8..4ed34ce 100644
--- a/GraphAlgorithms/README.md
+++ b/GraphAlgorithms/README.md
@@ -1,12 +1,12 @@
 # Graph Algorithms
 
-This directory contains Python implementations of common graph-based algorithms and data structures.
+This directory contains Python implementations of graph-based algorithms.
 
 ## Contents
 
-- [Adjacency List Implementation](AdjacencyListGraphImple.py): Implements the Graph Abstract Data Type (ADT) using an adjacency list (dictionaries in Python). Includes `Vertex` and `Graph` classes.
-- [Breadth First Search (BFS)](BFS.py): Implements BFS to solve the Word Ladder problem, finding the shortest transformation path between words.
-- [General Depth First Search (DFS)](DFSGeneral.py): Provides a general implementation of DFS, including discovery and finish times for vertices.
-- [DFS - Knight's Tour Problem](DFSImpleTheKnightsTourProblem.py): Another implementation of DFS specifically tailored to the Knight's Tour puzzle.
-- [The Knight's Tour Problem](TheKnightsTourProblem.py): Focuses on generating the knight's move graph and solving the tour using DFS and backtracking.
-- [Word Ladder Problem](WordLadderProblem.py): Specifically focuses on building the word ladder graph where edges connect words that differ by only one letter.
+- [Adjacency List Graph Implementation](AdjacencyListGraphImple.py): Implementation of a Graph ADT using an adjacency list.
+- [Breadth First Search (BFS)](BFS.py): Implementation of BFS for solving the Word Ladder problem. Time Complexity: $O(V+E)$
+- [Depth First Search (DFS) General](DFSGeneral.py): General implementation of DFS. Time Complexity: $O(V+E)$
+- [The Knight's Tour Problem (Graph Generation)](TheKnightsTourProblem.py): Building a graph to represent the Knight's Tour problem.
+- [DFS Implementation for Knight's Tour](DFSImpleTheKnightsTourProblem.py): Using DFS to solve the Knight's Tour problem. Time Complexity: $O(k^N)$ where $N$ is the number of squares.
+- [Word Ladder Problem](WordLadderProblem.py): Building the word ladder graph.
diff --git a/LinkedLists/README.md b/LinkedLists/README.md
index bead21d..a9c9bc6 100644
--- a/LinkedLists/README.md
+++ b/LinkedLists/README.md
@@ -4,8 +4,8 @@ This directory contains Python implementations of various types of linked lists
 
 ## Contents
 
-- [Singly Linked List Implementation](SingleLinkedListImple.py): Basic implementation of a singly linked list node and basic linkage.
+- [Singly Linked List Implementation](SinglyLinkedListImple.py): Basic implementation of a singly linked list node and basic linkage.
 - [Doubly Linked List Implementation](DoublyLinkedListImple.py): Basic implementation of a doubly linked list node with `prev` and `next` pointers.
-- [Singly Linked List Cycle Check](SinglyLinkedListCycleCheckImple.py): Implements Floyd's Cycle-Finding Algorithm (two pointers) to detect cycles in a linked list.
-- [Linked List Reversal](LinkedListReversal.py): Reverses a singly linked list in-place in $O(n)$ time.
-- [Nth to Last Node](LinkedListNthToLastNode.py): Finds the $n$-th to last node in a singly linked list using two pointers.
+- [Singly Linked List Cycle Check](SinglyLinkedListCycleCheckImple.py): Implements Floyd's Cycle-Finding Algorithm to detect cycles. Time Complexity: $O(n)$
+- [Linked List Reversal](LinkedListReversal.py): Reverses a singly linked list in-place. Time Complexity: $O(n)$
+- [Nth to Last Node](LinkedListNthToLastNode.py): Finds the $n$-th to last node in a singly linked list. Time Complexity: $O(n)$
diff --git a/LinkedLists/SinglyLinkedListCycleCheckImple.py b/LinkedLists/SinglyLinkedListCycleCheckImple.py
index 71a1b5c..08c598a 100644
--- a/LinkedLists/SinglyLinkedListCycleCheckImple.py
+++ b/LinkedLists/SinglyLinkedListCycleCheckImple.py
@@ -19,10 +19,10 @@ def __init__(self, value):
         self.value = value
         self.nextnode = None
         
-    def cycle_check(node):
+    def cycle_check(self):
         # Set two pointers initialize to passed node
-        pt1 = node
-        pt2 = node
+        pt1 = self
+        pt2 = self
         # loop through end of the list
         while pt2 != None and pt2.nextnode != None:
             pt1 = pt1.nextnode
@@ -31,6 +31,7 @@ def cycle_check(node):
             if pt2 == pt1:
                 return True
         return False
+
 # Test
 # Create a Linked List 
 a = LinkedListNode(1)
@@ -46,12 +47,6 @@ def cycle_check(node):
 print (b.value)
 print (c.value)
 
-# Since cycle_check is a method but it doesn't use self and is defined inside class
-# it should be called on an instance or changed to static method.
-# In its current definition it behaves like a regular method but is missing 'self'.
-# Actually it is defined as def cycle_check(node): which means it takes one arg.
-# If called as LinkedListNode.cycle_check(a) it should work if it was just a function.
-
 print(a.cycle_check())
 
 
diff --git a/LinkedLists/SingleLinkedListImple.py b/LinkedLists/SinglyLinkedListImple.py
similarity index 100%
rename from LinkedLists/SingleLinkedListImple.py
rename to LinkedLists/SinglyLinkedListImple.py
diff --git a/Queues/README.md b/Queues/README.md
index a1c90d0..5f55e8f 100644
--- a/Queues/README.md
+++ b/Queues/README.md
@@ -4,5 +4,5 @@ This directory contains Python implementations of the Queue data structure.
 
 ## Contents
 
-- [Queue Implementation](QueueImple.py): Basic implementation of a FIFO (First-In-First-Out) queue using a Python list. Includes `enqueue`, `dequeue`, `isEmpty`, and `size` methods.
-- [Queue with Two Stacks](QueueWith2StacksImple.py): Implements a queue using two stacks (represented by Python lists) to achieve FIFO behavior.
+- [Queue Implementation](QueueImple.py): Basic implementation of a FIFO queue using a Python list. Time Complexity: `enqueue` is $O(n)$, `dequeue` is $O(1)$.
+- [Queue with Two Stacks](QueueWith2StacksImple.py): Implements a queue using two stacks. Time Complexity: Amortized $O(1)$ for both `enqueue` and `dequeue`.
diff --git a/README.md b/README.md
index b8de7d5..b13dcc1 100644
--- a/README.md
+++ b/README.md
@@ -5,7 +5,6 @@
 [![Python Version](https://img.shields.io/badge/python-3.6%2B-blue)](https://www.python.org/downloads/)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 [![Contributions Welcome](https://img.shields.io/badge/contributions-welcome-brightgreen.svg)](CONTRIBUTING.md)
-[![GitHub Stars](https://img.shields.io/github/stars/ppant/DS-Algos-Python.svg?style=social)](https://github.com/ppant/DS-Algos-Python)
 
 ---
 
@@ -13,23 +12,11 @@
 
 This repository was started in **2017** with a simple goal: to create a comprehensive, well-documented collection of Data Structures and Algorithms implementations in Python. Whether you're preparing for technical interviews, learning CS fundamentals, or just brushing up on your algo skills, this repo serves as a practical reference.
 
-### Why This Repository?
-- 📖 **Educational**: Each implementation is well-commented and easy to understand
-- 🔄 **Multiple Solutions**: Different approaches to the same problem (brute force, optimized, etc.)
-- 🎓 **Interview Ready**: Solutions for common technical interview questions
-- 🚀 **Practical**: Standalone scripts that can be run and modified
-
 ---
 
 ## 🤝 Contributing
 
-This is an open-source learning project! We welcome contributions from everyone:
-- Found a bug? Open an issue
-- Have a better solution? Submit a pull request
-- Want to add new algorithms? Contributions are always appreciated!
-- Have learning notes? Share them with the community
-
-See [CONTRIBUTING.md](CONTRIBUTING.md) for more details.
+This is an open-source learning project! We welcome contributions from everyone. See [CONTRIBUTING.md](CONTRIBUTING.md) for more details.
 
 ---
 
@@ -38,19 +25,18 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for more details.
 - [Getting Started](#getting-started)
 - [Project Structure](#project-structure)
 - [Data Structures](#data-structures)
-  - [Arrays](#arrays)
-  - [Linked Lists](#linked-lists)
-  - [Stacks](#stacks)
-  - [Queues](#queues)
-  - [Deque](#deque)
-  - [Trees](#trees)
+  - [Arrays 🔢](#arrays)
+  - [Linked Lists 🔗](#linked-lists)
+  - [Stacks 📚](#stacks)
+  - [Queues 📦](#queues)
+  - [Deque 🔄](#deque)
+  - [Trees 🌳](#trees)
 - [Algorithms](#algorithms)
-  - [Sorting](#sorting)
-  - [Recursion & Dynamic Programming](#recursion--dynamic-programming)
-  - [Graph Algorithms](#graph-algorithms)
-- [Error Handling & Debugging](#error-handling--debugging)
+  - [Sorting 📊](#sorting)
+  - [Recursion & Dynamic Programming 🔀](#recursion--dynamic-programming)
+  - [Graph Algorithms 🗺️](#graph-algorithms)
+- [Error Handling & Debugging ⚠️](#error-handling--debugging)
 - [Usage](#usage)
-- [Quick Reference](#quick-reference)
 - [License](#license)
 
 ---
@@ -59,7 +45,6 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for more details.
 
 ### Prerequisites
 - Python 3.6 or higher
-- Basic understanding of Python syntax
 
 ### Running Examples
 
@@ -67,7 +52,7 @@ Most scripts in this repository are standalone and can be executed directly:
 
 ```bash
 # Run any Python script
-python3 Arrays/Anagram_Check_Sorted_Sol.py
+python3 Arrays/AnagramCheckSortedSol.py
 
 # Or run from the repo root
 python3 Sorting/BubbleSortImple.py
@@ -79,8 +64,9 @@ python3 Sorting/BubbleSortImple.py
 
 ```
 .
-├── Arrays/              # 🔤 Array-based problems and algorithms
-├── Error-debug/         # ⚠️ Error handling and debugging examples
+├── Arrays/              # 🔢 Array-based problems and algorithms
+├── Deque/               # 🔄 Double-ended queue
+├── ErrorHandling/       # ⚠️ Error handling and debugging examples
 ├── GraphAlgorithms/     # 🗺️ Graph traversal (BFS, DFS) and pathfinding
 ├── LinkedLists/         # 🔗 Singly and Doubly Linked Lists
 ├── Queues/              # 📦 Queue implementations (FIFO)
@@ -88,7 +74,6 @@ python3 Sorting/BubbleSortImple.py
 ├── Sorting/             # 📊 Common sorting algorithms
 ├── Stacks/              # 📚 Stack implementations and applications
 ├── Trees/               # 🌳 Binary Trees, BSTs, Heaps, and Traversals
-├── deque/               # 🔄 Double-ended queue
 ├── CONTRIBUTING.md      # 🤝 Contribution guidelines
 ├── LICENSE              # 📄 MIT License
 └── README.md            # 📖 This file
@@ -98,15 +83,15 @@ python3 Sorting/BubbleSortImple.py
 
 ## 📊 Data Structures
 
-### Arrays 🔤
+### Arrays 🔢
 Common array-based algorithms and manipulations.
-- [Anagram Check](Arrays/): [Sorted](Arrays/Anagram_Check_Sorted_Sol.py) & [Manual](Arrays/Anagram_Check_manual_Sol.py) solutions
+- [Anagram Check](Arrays/): [Sorted](Arrays/AnagramCheckSortedSol.py) & [Manual](Arrays/AnagramCheckManualSol.py) solutions
 - [Array Pair Sum](Arrays/ArrayPairSumSol.py): Find pairs that sum to $k$
-- [Find Missing Element](Arrays/): [XOR](Arrays/ArrayFindTheMissingElement_XOR_sol.py), [Brute Force](Arrays/ArrayFindTheMissingElement_brute_force_sol.py), [Hash Table](Arrays/ArrayFindTheMissingElement_hash_table_sol.py), & [Sum](Arrays/ArrayFindTheMissingElement_takingSumandSubtract_sol.py) approaches
+- [Find Missing Element](Arrays/): [XOR](Arrays/ArrayFindTheMissingElementXORSol.py), [Brute Force](Arrays/ArrayFindTheMissingElementBruteForceSol.py), [Hash Table](Arrays/ArrayFindTheMissingElementHashTableSol.py), & [Sum](Arrays/ArrayFindTheMissingElementSumSol.py) approaches
 
 ### Linked Lists 🔗
 Implementations and problems involving linked structures.
-- [Singly Linked List](LinkedLists/SingleLinkedListImple.py) & [Doubly Linked List](LinkedLists/DoublyLinkedListImple.py)
+- [Singly Linked List](LinkedLists/SinglyLinkedListImple.py) & [Doubly Linked List](LinkedLists/DoublyLinkedListImple.py)
 - [Cycle Detection](LinkedLists/SinglyLinkedListCycleCheckImple.py): Detect cycles using two pointers (Floyd's algorithm)
 - [Reverse Linked List](LinkedLists/LinkedListReversal.py): In-place reversal
 - [Nth to Last Node](LinkedLists/LinkedListNthToLastNode.py): Find the $n$-th node from the end
@@ -114,7 +99,7 @@ Implementations and problems involving linked structures.
 ### Stacks 📚
 LIFO (Last-In-First-Out) data structures.
 - [Stack Implementation](Stacks/StackImple.py): Basic operations (push, pop, peek)
-- [Balanced Parentheses](Stacks/BalanceParenthlessCheckImple.py): Check for balanced brackets using a stack
+- [Balanced Parentheses](Stacks/BalanceParenthesesCheckImple.py): Check for balanced brackets using a stack
 
 ### Queues 📦
 FIFO (First-In-First-Out) data structures.
@@ -123,7 +108,7 @@ FIFO (First-In-First-Out) data structures.
 
 ### Deque 🔄
 Double-ended queue operations.
-- [Deque Implementation](deque/DequeImple.py): Operations at both ends
+- [Deque Implementation](Deque/DequeImple.py): Operations at both ends
 
 ### Trees 🌳
 Hierarchical data structures.
@@ -133,7 +118,7 @@ Hierarchical data structures.
 - [Binary Heap](Trees/BinaryHeapImple.py): Min-heap implementation
 - [Tree Traversals](Trees/TreeLevelOrderPrintImple.py): Level order (BFS) printing
 - [Trim BST](Trees/TrimBinarySearchTreeImple.py): Keep nodes within a range
-- [Tree Representations](Trees/): [Nodes & References](Trees/TreeRepresentationWithNodesReferences.py) & [List of Lists](Trees/buildTreeTest.py)
+- [Tree Representations](Trees/): [Nodes & References](Trees/TreeRepresentationWithNodesReferences.py) & [List of Lists](Trees/BuildTreeTest.py)
 
 ---
 
@@ -144,7 +129,7 @@ Algorithms for arranging elements in order.
 - [Bubble Sort](Sorting/BubbleSortImple.py) - $O(n^2)$
 - [Selection Sort](Sorting/SelectionSortImple.py) - $O(n^2)$
 - [Insertion Sort](Sorting/InsertionSortImple.py) - $O(n^2)$
-- [Shell Sort](Sorting/ShellSortImple.py) - $O(n \log n)$
+- [Shell Sort](Sorting/ShellSortImple.py) - $O(n^2)$
 - [Merge Sort](Sorting/MergeSortImple.py) - $O(n \log n)$
 - [Quick Sort](Sorting/QuickSortImple.py) - $O(n \log n)$ average
 
@@ -168,7 +153,7 @@ Algorithms for graph traversal and pathfinding.
 
 ## ⚠️ Error Handling & Debugging
 
-- [Error and Exceptions](Error-debug/ErrorExceptions.py): Demonstrates `try`, `except`, `else`, and `finally` blocks for robust error handling.
+- [Error and Exceptions](ErrorHandling/ErrorExceptions.py): Demonstrates `try`, `except`, `else`, and `finally` blocks for robust error handling.
 
 ---
 
@@ -180,47 +165,6 @@ Most scripts in this repository are standalone. You can run them using the Pytho
 python3 path/to/script.py
 ```
 
-Example:
-```bash
-python3 Sorting/BubbleSortImple.py
-```
-
----
-
-## 📊 Quick Reference
-
-| Topic | Easy | Medium | Hard |
-|-------|------|--------|------|
-| Arrays | Anagram Check | Array Pair Sum | Find Missing Element |
-| Linked Lists | Singly LL | Cycle Detection | Reverse LL |
-| Trees | Binary Search | BST Validation | Trim BST |
-| Sorting | Bubble Sort | Merge Sort | Quick Sort |
-| DP | Fibonacci | Coin Change | Word Split |
-
----
-
-## 🎓 Learning Path
-
-New to DSA? Follow this recommended order:
-1. Start with **Arrays** - Fundamental data structure
-2. Learn **Sorting** - Essential for interviews
-3. Study **Linked Lists** - Understanding pointers/references
-4. Master **Stacks & Queues** - Core data structures
-5. Explore **Trees** - Most interview questions
-6. Dive into **Recursion & DP** - Advanced problem solving
-7. Finish with **Graphs** - Complex algorithms
-
----
-
-## 🔮 Roadmap
-
-- [ ] Add more graph algorithms (Dijkstra, Bellman-Ford)
-- [ ] Include complexity analysis for each solution
-- [ ] Add interactive examples/visualizations
-- [ ] Create a difficulty level classification
-- [ ] Add more test cases
-- [ ] Create beginner-friendly guides
-
 ---
 
 ## 📄 License
@@ -233,22 +177,4 @@ Copyright (c) 2017 - 2026 Pradeep K. Pant
 
 ---
 
-## 👨‍💻 Author
-
-**Pradeep K. Pant**
-- Started: 2017
-- Python enthusiast | Algorithm lover | Open source advocate
-
----
-
-## ⭐ Show Your Support
-
-If this repository helped you learn or prepare for interviews, please consider:
-- ⭐ Starring the repository
-- 🤝 Contributing improvements
-- 📢 Sharing with others learning DSA
-- 💬 Giving feedback
-
----
-
 *Happy Learning! 🚀*
diff --git a/Recursion/FibonacciSeqDynamic.py b/Recursion/FibonacciSeqDynamic.py
index b16783e..a7527aa 100644
--- a/Recursion/FibonacciSeqDynamic.py
+++ b/Recursion/FibonacciSeqDynamic.py
@@ -2,12 +2,11 @@
 # memoization + recursion = dynamic programming
 # Author: Pradeep K. Pant, ppant@cpan.org
 
-# Instantiate Cache information
-n = 10
-cache = [None] * (n + 1)
-
 # Implement fibonacci_dynamic
-def fibonacci_dynamic(n):
+def fibonacci_dynamic(n, cache=None):
+    if cache is None:
+        cache = [None] * (n + 1)
+
     # Base Case
     if n == 0 or n == 1:
         return n
@@ -17,7 +16,7 @@ def fibonacci_dynamic(n):
         return cache[n]
 
     # Recursive call to and keep setting cache
-    cache[n] = fibonacci_dynamic(n - 1) + fibonacci_dynamic(n - 2)
+    cache[n] = fibonacci_dynamic(n - 1, cache) + fibonacci_dynamic(n - 2, cache)
     return cache[n]
 
 # Test
diff --git a/Recursion/README.md b/Recursion/README.md
index 7265340..c024d7e 100644
--- a/Recursion/README.md
+++ b/Recursion/README.md
@@ -1,21 +1,16 @@
 # Recursion
 
-This directory contains Python implementations of problems solved using recursion and dynamic programming.
+This directory contains recursive algorithms and dynamic programming solutions.
 
 ## Contents
 
-### Fibonacci Sequence
-- [Fibonacci (Iterative)](FibonacciSeqIterative.py): Iterative implementation of the Fibonacci sequence.
-- [Fibonacci (Recursive)](FibonacciSeqRecursion.py): Simple recursive implementation of the Fibonacci sequence.
-- [Fibonacci (Dynamic Programming)](FibonacciSeqDynamic.py): Optimized Fibonacci sequence using memoization.
-
-### Coin Change Problem
-- [Coin Change (Recursive)](CoinChangeProblemRecursion.py): Basic recursive solution to find the minimum number of coins for change.
-- [Coin Change (Dynamic Programming)](CoinChangeProblemDynamic.py): Optimized solution to the coin change problem using dynamic programming.
-
-### Other Recursive Problems
-- [Cumulative Sum](RecursionCumulativeSum.py): Computes the cumulative sum from 0 to $n$ recursively.
-- [Reverse a String](RecursionReverseStr.py): Reverses a string using recursive calls.
-- [String Permutations](RecursionStrPermutation.py): Generates all possible permutations of a given string.
-- [Sum of Digits](RecursionSumOfDigits.py): Calculates the sum of all individual digits in an integer recursively.
-- [Word Split](RecursionWordSplit.py): Determines if a string can be split into words from a given list.
+- [Coin Change Problem (Recursive)](CoinChangeProblemRecursion.py): Recursive solution to the coin change problem.
+- [Coin Change Problem (Dynamic)](CoinChangeProblemDynamic.py): Dynamic programming solution to the coin change problem. Time Complexity: $O(n \cdot m)$
+- [Fibonacci Sequence (Iterative)](FibonacciSeqIterative.py): Iterative implementation of Fibonacci. Time Complexity: $O(n)$
+- [Fibonacci Sequence (Recursive)](FibonacciSeqRecursion.py): Simple recursive implementation of Fibonacci. Time Complexity: $O(2^n)$
+- [Fibonacci Sequence (Dynamic)](FibonacciSeqDynamic.py): Dynamic programming (memoized) implementation of Fibonacci. Time Complexity: $O(n)$
+- [Recursion Cumulative Sum](RecursionCumulativeSum.py): Cumulative sum using recursion. Time Complexity: $O(n)$
+- [Recursion Reverse String](RecursionReverseStr.py): Reversing a string using recursion. Time Complexity: $O(n)$
+- [Recursion String Permutation](RecursionStrPermutation.py): Finding all permutations of a string. Time Complexity: $O(n!)$
+- [Recursion Sum of Digits](RecursionSumOfDigits.py): Sum of digits of a number using recursion. Time Complexity: $O(\log_{10} n)$
+- [Recursion Word Split](RecursionWordSplit.py): Dynamic programming solution for word splitting.
diff --git a/Sorting/README.md b/Sorting/README.md
index 0b76399..4b0a58c 100644
--- a/Sorting/README.md
+++ b/Sorting/README.md
@@ -1,12 +1,12 @@
 # Sorting Algorithms
 
-This directory contains Python implementations of various sorting algorithms with explanations of their complexities.
+This directory contains Python implementations of various sorting algorithms.
 
 ## Contents
 
-- [Bubble Sort](BubbleSortImple.py): Implementation of Bubble Sort with $O(n^2)$ complexity.
-- [Selection Sort](SelectionSortImple.py): Implementation of Selection Sort, improving on Bubble Sort by making only one exchange per pass.
-- [Insertion Sort](InsertionSortImple.py): Implementation of Insertion Sort, maintaining a sorted sublist.
-- [Shell Sort](ShellSortImple.py): Implementation of Shell Sort (diminishing increment sort), improving on Insertion Sort.
-- [Merge Sort](MergeSortImple.py): A recursive "divide and conquer" algorithm with $O(n \log n)$ complexity.
-- [Quick Sort](QuickSortImple.py): Implementation of Quick Sort (partition exchange sort), using divide and conquer in-place.
+- [Bubble Sort](BubbleSortImple.py): Implementation of Bubble Sort. Time Complexity: $O(n^2)$
+- [Selection Sort](SelectionSortImple.py): Implementation of Selection Sort. Time Complexity: $O(n^2)$
+- [Insertion Sort](InsertionSortImple.py): Implementation of Insertion Sort. Time Complexity: $O(n^2)$
+- [Shell Sort](ShellSortImple.py): Implementation of Shell Sort. Time Complexity: $O(n^2)$ (worst case)
+- [Merge Sort](MergeSortImple.py): A recursive divide and conquer algorithm. Time Complexity: $O(n \log n)$
+- [Quick Sort](QuickSortImple.py): Implementation of Quick Sort. Time Complexity: $O(n \log n)$ (average case)
diff --git a/Stacks/BalanceParenthlessCheckImple.py b/Stacks/BalanceParenthesesCheckImple.py
similarity index 100%
rename from Stacks/BalanceParenthlessCheckImple.py
rename to Stacks/BalanceParenthesesCheckImple.py
diff --git a/Stacks/README.md b/Stacks/README.md
index e799a74..6399854 100644
--- a/Stacks/README.md
+++ b/Stacks/README.md
@@ -1,8 +1,8 @@
 # Stacks
 
-This directory contains Python implementations of the Stack data structure and its applications.
+This directory contains Python implementations of the Stack data structure.
 
 ## Contents
 
-- [Stack Implementation](StackImple.py): Basic implementation of a LIFO (Last-In-First-Out) stack using a Python list. Includes `push`, `pop`, `peek`, `isEmpty`, and `size` methods.
-- [Balanced Parentheses Check](BalanceParenthlessCheckImple.py): Uses a stack to check if a string of opening and closing parentheses (round, square, and curly) is balanced.
+- [Stack Implementation](StackImple.py): Basic operations (push, pop, peek). Time Complexity: All operations are $O(1)$.
+- [Balanced Parentheses Check](BalanceParenthesesCheckImple.py): Check for balanced brackets using a stack. Time Complexity: $O(n)$
diff --git a/Trees/buildTreeTest.py b/Trees/BuildTreeTest.py
similarity index 100%
rename from Trees/buildTreeTest.py
rename to Trees/BuildTreeTest.py
diff --git a/Trees/README.md b/Trees/README.md
index 2047225..ee37388 100644
--- a/Trees/README.md
+++ b/Trees/README.md
@@ -1,23 +1,16 @@
 # Trees
 
-This directory contains Python implementations of various tree-based data structures and algorithms.
+This directory contains Python implementations of tree-based data structures and algorithms.
 
 ## Contents
 
-### Binary Search Trees (BST)
-- [Binary Search Tree Implementation](BinarySearchTreesImple.py): A comprehensive implementation of a BST with `TreeNode` and `BinarySearchTree` classes, including insertion, deletion, and search.
-- [Validate BST (Solution 1)](BinarySearchTreeCheckImpleSol1.py): Validates a BST by performing an in-order traversal and checking if the resulting values are sorted.
-- [Validate BST (Solution 2)](BinarySearchTreeCheckImpleSol2.py): Validates a BST by keeping track of the minimum and maximum allowable values for each node.
-- [Trim a BST](TrimBinarySearchTreeImple.py): Trims a BST so that all node values fall within a specified range $[min, max]$.
-
-### Search Algorithms
-- [Binary Search (Iterative)](BinarySearchImple.py): Iterative implementation of the binary search algorithm on a sorted list.
-- [Binary Search (Recursive)](BinarySearchRecursiveImple.py): Recursive implementation of the binary search algorithm.
-
-### Heaps
-- [Binary Heap Implementation](BinaryHeapImple.py): Implements a min-heap using a recursive approach, including `insert`, `delMin`, and `buildHeap`.
-
-### Tree Representations & Traversals
-- [Nodes and References Representation](TreeRepresentationWithNodesReferences.py): A simple implementation of a binary tree using a class-based nodes and references approach.
-- [List of Lists Representation](buildTreeTest.py): Demonstrates building and manipulating a tree using a "list of lists" approach.
-- [Tree Level Order Print](TreeLevelOrderPrintImple.py): Prints a binary tree in level order (breadth-first) using a queue, with each level on a new line.
+- [Binary Search Implementation](BinarySearchImple.py): Iterative binary search. Time Complexity: $O(\log n)$
+- [Binary Search Recursive Implementation](BinarySearchRecursiveImple.py): Recursive binary search. Time Complexity: $O(\log n)$
+- [Binary Search Tree Implementation](BinarySearchTreesImple.py): Complete BST implementation. Time Complexity: $O(\log n)$ (average), $O(n)$ (worst)
+- [BST Validation (Solution 1)](BinarySearchTreeCheckImpleSol1.py): In-order traversal validation.
+- [BST Validation (Solution 2)](BinarySearchTreeCheckImpleSol2.py): Range-based validation.
+- [Binary Heap Implementation](BinaryHeapImple.py): Min-heap implementation. Time Complexity: $O(\log n)$ for insert/delete.
+- [Build Tree Test](BuildTreeTest.py): Implementation using list of lists.
+- [Tree Level Order Print](TreeLevelOrderPrintImple.py): BFS-based tree traversal. Time Complexity: $O(n)$
+- [Tree Representation (Nodes & References)](TreeRepresentationWithNodesReferences.py): Standard node-based tree representation.
+- [Trim Binary Search Tree](TrimBinarySearchTreeImple.py): Keeping nodes within a specific range. Time Complexity: $O(n)$