ppant · ppant · Jun 4, 2026
diff --git a/Arrays/Anagram_Check_manual_Sol.py → Arrays/AnagramCheckManualSol.py b/Arrays/Anagram_Check_manual_Sol.py → Arrays/AnagramCheckManualSol.py
diff --git a/Arrays/Anagram_Check_Sorted_Sol.py → Arrays/AnagramCheckSortedSol.py b/Arrays/Anagram_Check_Sorted_Sol.py → Arrays/AnagramCheckSortedSol.py
diff --git a/...yFindTheMissingElement_brute_force_sol.py → ...rrayFindTheMissingElementBruteForceSol.py b/...yFindTheMissingElement_brute_force_sol.py → ...rrayFindTheMissingElementBruteForceSol.py
diff --git a/...ayFindTheMissingElement_hash_table_sol.py → ...ArrayFindTheMissingElementHashTableSol.py b/...ayFindTheMissingElement_hash_table_sol.py → ...ArrayFindTheMissingElementHashTableSol.py
diff --git a/...issingElement_takingSumandSubtract_sol.py → Arrays/ArrayFindTheMissingElementSumSol.py b/...issingElement_takingSumandSubtract_sol.py → Arrays/ArrayFindTheMissingElementSumSol.py
diff --git a/Arrays/ArrayFindTheMissingElement_XOR_sol.py → Arrays/ArrayFindTheMissingElementXORSol.py b/Arrays/ArrayFindTheMissingElement_XOR_sol.py → Arrays/ArrayFindTheMissingElementXORSol.py
diff --git 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.
+- [Anagram Check (Sorted Solution)](AnagramCheckSortedSol.py): Checks if two strings are anagrams by comparing their sorted versions.
+- [Anagram Check (Manual Solution)](AnagramCheckManualSol.py): Checks if two strings are anagrams using a hash table (dictionary) to count character frequencies.
+- [Array Find Missing Element (XOR Solution)](ArrayFindTheMissingElementXORSol.py): Efficiently finds a missing element in a shuffled array using bitwise XOR.
+- [Array Find Missing Element (Brute Force Solution)](ArrayFindTheMissingElementBruteForceSol.py): Finds a missing element by sorting both arrays and comparing them.
+- [Array Find Missing Element (Hash Table Solution)](ArrayFindTheMissingElementHashTableSol.py): Finds a missing element using a hash table (dictionary) to track element counts.
+- [Array Find Missing Element (Sum/Subtract Solution)](ArrayFindTheMissingElementSumSol.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.
diff --git a/deque/DequeImple.py → Deque/DequeImple.py b/deque/DequeImple.py → Deque/DequeImple.py
diff --git a/Deque/README.md b/Deque/README.md
@@ -0,0 +1,18 @@
+# Double-Ended Queue (Deque)
+
+This directory contains an implementation of a Deque (Double-Ended Queue) data structure.
+
+## Contents
+
+- [Deque Implementation](DequeImple.py): A class-based implementation of a deque using a Python list. Supports adding and removing elements from both the front and rear.
+
+## Time Complexity
+
+| Operation | Complexity |
+|-----------|------------|
+| `addFront` | $O(1)$ |
+| `addRear` | $O(n)$ |
+| `removeFront` | $O(1)$ |
+| `removeRear` | $O(n)$ |
+| `isEmpty` | $O(1)$ |
+| `size` | $O(1)$ |
diff --git a/Error-debug/README.md b/Error-debug/README.md
diff --git a/Error-debug/ErrorExceptions.py → ErrorHandling/ErrorExceptions.py b/Error-debug/ErrorExceptions.py → ErrorHandling/ErrorExceptions.py
diff --git a/ErrorHandling/README.md b/ErrorHandling/README.md
@@ -0,0 +1,7 @@
+# Error Handling and Debugging
+
+This directory contains examples demonstrating error handling techniques in Python.
+
+## Contents
+
+- [Error and Exceptions](ErrorExceptions.py): An interactive script showing how to use `try`, `except`, `else`, and `finally` blocks to handle various runtime exceptions gracefully.
diff --git a/README.md b/README.md
@@ -67,7 +67,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
@@ -80,15 +80,15 @@ python3 Sorting/BubbleSortImple.py
 ```
 .
 ├── Arrays/              # 🔤 Array-based problems and algorithms
-├── Error-debug/         # ⚠️ Error handling and debugging examples
+├── 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)
 ├── Recursion/           # 🔀 Recursive problems and Dynamic Programming
 ├── 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
@@ -100,9 +100,9 @@ python3 Sorting/BubbleSortImple.py
 
 ### 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.
@@ -114,7 +114,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 +123,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 +133,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)
 
 ---
 
@@ -168,7 +168,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.
 
 ---
 

diff --git a/Stacks/BalanceParenthlessCheckImple.py → Stacks/BalanceParenthesesCheckImple.py b/Stacks/BalanceParenthlessCheckImple.py → Stacks/BalanceParenthesesCheckImple.py
diff --git a/Stacks/README.md b/Stacks/README.md
@@ -1,8 +1,20 @@
 # Stacks
 
-This directory contains Python implementations of the Stack data structure and its applications.
+This directory contains Python implementations of the Stack (LIFO) data structure and its applications.
 
 ## 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): A class-based implementation of a stack using a Python list.
+- [Balanced Parentheses Check](BalanceParenthesesCheckImple.py): An algorithm that uses a stack to verify if a string of parentheses (including square and curly brackets) is properly balanced.
+
+## Time Complexity
+
+For the Stack implementation:
+
+| Operation | Complexity |
+|-----------|------------|
+| `push` | $O(1)$ |
+| `pop` | $O(1)$ |
+| `peek` | $O(1)$ |
+| `isEmpty` | $O(1)$ |
+| `size` | $O(1)$ |
diff --git a/Trees/buildTreeTest.py → Trees/BuildTreeTest.py b/Trees/buildTreeTest.py → Trees/BuildTreeTest.py
diff --git a/Trees/README.md b/Trees/README.md
@@ -4,20 +4,21 @@ This directory contains Python implementations of various tree-based data struct
 
 ## 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]$.
+- [Binary Search Tree Implementation](BinarySearchTreesImple.py): A comprehensive implementation of a BST including insertion, search, and deletion.
+- [Binary Search (Iterative)](BinarySearchImple.py): Implementation of the binary search algorithm using a loop.
+- [Binary Search (Recursive)](BinarySearchRecursiveImple.py): Implementation of binary search using recursion.
+- [Binary Heap Implementation](BinaryHeapImple.py): A min-heap implementation for efficient priority queue operations.
+- [BST Check (Solution 1)](BinarySearchTreeCheckImpleSol1.py): Verifies if a binary tree is a valid BST using in-order traversal.
+- [BST Check (Solution 2)](BinarySearchTreeCheckImpleSol2.py): Verifies if a binary tree is a valid BST by tracking min/max allowed values for each node.
+- [Tree Level Order Print](TreeLevelOrderPrintImple.py): Prints nodes of a tree level-by-level (BFS).
+- [Trim a Binary Search Tree](TrimBinarySearchTreeImple.py): Removes nodes that are outside a given range $[L, R]$.
+- [Tree Representation (Nodes and References)](TreeRepresentationWithNodesReferences.py): Basic tree structure using node objects.
+- [Tree Representation (List of Lists)](BuildTreeTest.py): A simpler tree representation using nested Python lists.
 
-### 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.
+## Time Complexity
 
-### 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.
+| Algorithm/Operation | Average | Worst Case |
+|--------------------|---------|------------|
+| BST Search/Insert/Delete | $O(\log n)$ | $O(n)$ |
+| Binary Search | $O(\log n)$ | $O(\log n)$ |
+| Binary Heap Insert/Delete | $O(\log n)$ | $O(\log n)$ |
diff --git a/deque/README.md b/deque/README.md