Simplified the README

Alaz-Oz · web-flow · commit 6ae9036349b6 · 2024-01-15T21:06:21.000+05:30
- Improved visuals - Clear and concise descriptions - Better standards and naming conventions - Improved Hierarchy - Created template for DataStructure, Fixes #21
diff --git a/Algorithms/README.md b/Algorithms/README.md
@@ -1,50 +1,59 @@
 # Algorithms
-This directory holds pseudocode for all the algorithms that we come across. This could be used to develop better algorithms and to optmize different algorithms to suit better in certain scenarios.
+
+This directory contains pseudocode for various algorithms, aiding in the development of better algorithms and optimizing them for specific scenarios.
 
 ## Hierarchy
-This repository follows should follow strict hierarchy.
-
-Folders for different types of Algorithms
-
-1. **Search Algorithms**
-  * Linear Search
-  * Binary Search
-  * Polynomial Search
-2. **Sorting Algorithms**
-  * Bubble Sort
-  * Selection Sort
-  * Insertion Sort
-  * Quick Sort
-  * Merge Sort
-  * Heap Sort
-  * Shell Sort
-  * Radix Sort
-  * Bubble Sort
-3. **Path Finding Algorithms**
-  * Dijkstra's algorithm
-  * A<sup>*</sup> algorithm
-4. **Dynamic Programming Algorithms**
-5. **Greedy Algorithms**
-6. **Recursive Algorithms**
-7. **Machine Learning Algorithms**
-8. **Encryption/Decryption Algorithms**
-
-The sub-folders in this directory, named after the algorithm will contain the pseudocode in README.md file along with its general analysis. There could be optional implementation in C++/Java or in other languages, kept in tha same directory as the README.md file.
-
-
-## Sections in the Algorithms page
+
+The repository follows a strict hierarchy, with directories for different types of algorithms:
+
+```plaintext
+Algorithms
+    ├── Search
+    │   ├── LinearSearch
+    │   ├── BinarySearch
+    │   └── PolynomialSearch
+    │
+    ├── Sort
+    │   ├── BubbleSort
+    │   ├── SelectionSort
+    │   ├── InsertionSort
+    │   ├── QuickSort
+    │   ├── MergeSort
+    │   ├── HeapSort
+    │   ├── ShellSort
+    │   └── RadixSort
+    │
+    ├── PathFinding
+    │   ├── DijkstrasAlgorithm
+    │   └── AStarAlgorithm
+    │
+    ├── DynamicProgrammingAlgorithms
+    ├── GreedyAlgorithms
+    ├── RecursiveAlgorithms
+    ├── MachineLearningAlgorithms
+    └── EncryptionDecryptionAlgorithms
+```
+
+## Sections Template
+
+The `README.md` of algorithm will typically contain:
+
 - Introduction
-- Pseuodcode
+- Pseudocode
 - Time Complexity
-- Where to use
-- Tips
+- Space Complexity
+- Variants
+- Use Cases
+- Best Practices
+- References
 
-### Notations for the Time Complexity
+### Notations for `Time` & `Space` Complexity
 
-Use respective symbols for representing the time complexity.
-- `Ω` Big Omega for `Best Case`
-- `Θ` Big Theta for `Average Case`
-- `O` Big O for `Worst Case`
+| Symbol | Name       | Case         |
+|--------|------------|--------------|
+| Ω      | Big Omega  | Best Case    |
+| Θ      | Big Theta  | Average Case |
+| O      | Big O      | Worst Case   |
 
 > [!Note]
-> Use the specific order (best, avg, worst) for the time complexity.
+> Ensure the time complexity order follows: best, average, worst.
diff --git a/DataStructure/README.md b/DataStructure/README.md
@@ -1,2 +1,49 @@
-# Data Structure
-This folder contains all the data structures we come across.
+# Data Structures
+
+This directory contains implementations, explanations, and optimizations of various data structures, essential for developing efficient algorithms and solving specific problems.
+
+## Hierarchy
+
+The repository maintains a clear hierarchy, organizing different types of data structures into directories:
+
+```plaintext
+DataStructures
+    ├── Linear
+    │   ├── Arrays
+    │   ├── LinkedLists
+    │   ├── Stacks
+    │   └── Queues
+    │
+    ├── Trees
+    │   ├── BinaryTrees
+    │   ├── BinarySearchTrees
+    │   ├── AVLTrees
+    │   └── RedBlackTrees
+    │
+    ├── Graphs
+    │   ├── DirectedGraphs
+    │   └── WeightedGraphs
+    │
+    ├── HashBased
+    │   ├── HashTables
+    │   ├── HashMaps
+    │   └── HashSet
+    │
+    └── Specialized
+        ├── Heaps
+        ├── Trie
+        ├── BloomFilter
+        └── SkipLists
+```
+## Sections Template
+
+The `README.md` of each data structure will typically contain:
+
+- Introduction
+- Visualization
+- Operations
+- Variants
+- Use Cases
+- Best Practices
+- References
+
diff --git a/README.md b/README.md
@@ -2,86 +2,69 @@
 A repository to store different types of Data-Structure & Algorithms for educational and research purposes.
 
 This repository is divided into 2 parts:
-- [`DataStructure`](DataStructure): Contains the Data Structure
-- [`Algorithms`](Algorithms): Contains Alorithms.
+- [`/DataStructure`](DataStructure): Contains the Data Structure
+- [`/Algorithms`](Algorithms): Contains Alorithms.
 
 Each has its own hierarchy system. The hierarchy is _strict_, and must be followed.
 
 ## Hierarchy & Rules
 - Directory names should be in `PascalCase`.
 - There could be links to and from the Algorithms or DataStructure dir to link related things.
-- The heirarchy should follow
-  
-  |                     Location                                 |         Purpose                                                    |
-  |--------------------------------------------------------------|--------------------------------------------------------------------|
-  |`/Algorithms/AlgorithmCategory/AlgorithmName/`                | Store all about the algorithm (code, information, assets)          |
-  |`/Algorithms/AlgorithmCategory/AlgorithmName/README.md`       | Information, pseudocode and explaination of the Algorithm          |
-  |`/DataStructure/Category/SubCategory/../Name/`                | Store all about the data-structure (implementation, info, assets)  |
-  |`/DataStructure/Category/SubCategory/../Name/README.md`       | Information, diagram, and explanation of the Data-Structure        |
-
-- The data structure's heirarchy could be as follows
-    ```
-    DataStructure
-    │
-    ├── Linear Data Structures
-    │   ├── Arrays
-    │   ├── Linked Lists
-    │   ├── Stacks
-    │   └── Queues
-    │
-    ├── Non-Linear Data Structures
-    │   ├── Trees
-    │   │   ├── Binary Trees
-    │   │   ├── Binary Search Trees (BST)
-    │   │   ├── AVL Trees
-    │   │   └── Red-Black Trees
-    │   │
-    │   └── Graphs
-    │       ├── Directed Graphs (Digraphs)
-    │       └── Weighted Graphs
+
+## `/Algorithms`
+The `/Algorithms` directory is organized to accommodate various algorithm implementations, information, explanations, and supplementary details.
+
+Within `/Algorithms`, the following subdirectories represent different categories of algorithms:
+
+- **`/Sort`**: Contains algorithms for sorting data.
+- **`/Search`**: Includes algorithms for searching within a list.
+- **`/Utils`**: Houses algorithms that serve multiple purposes.
+
+Each category directory (`/Sort`, `/Search`, `/Utils`) further includes directories for specific algorithms.
+
+### Algorithm Directory Template
+
+```plaintext
+AlgorithmName/
     │
-    ├── Hash-Based Data Structures
-    │   ├── Hash Tables
-    │   ├── Hash Maps
-    │   └── Hash Sets
+    ├── README.md          // Containing Pseudocode 
     │
-    └── Specialized Data Structures
-    ├── Heaps
-    ├── Trie
-    ├── Bloom Filter
-    └── Skip Lists
-    
-    ```
-## Contributions
+    └── AlgorithmName.xxx  // (optional) Code implementation (.xxx is extention like java, cpp)
+```
+
+## `/DataStructure`
 
-We welcome contributions from everyone! Here are some ways you can contribute to our project:
+The `/DataStructure` directory is structured to house various data structure implementations, information, explanations, and supporting materials.
 
-### Issues
+Within `/DataStructure`, different categories represent various types of data structures:
 
-- Report bugs or suggest enhancements by creating GitHub issues.
-- Ensure the issue hasn't already been reported by checking the existing ones.
+- **`/Linear`**: Contains implementations of linear data structures.
+- **`/NonLinear`**: Encompasses implementations of non-linear data structures.
+- **`/HashBased`**: Stores implementations of hash-based data structures.
+- **`/Specialized`**: Includes specialized data structures.
 
-### Pull Requests (PRs)
+Each category directory (`/Linear`, `/NonLinear`, `/HashBased`, `/Specialized`) further contains subdirectories for subcategories of data structures or specific data structures.
 
-- Fork the repository, make changes, and submit Pull Requests for review.
-- Make sure your PRs are focused and address a single concern.
-- Adhere to the `code style` and `project conventions`.
+### DataStructure Directory Template
 
-### Code Reviews
+```plaintext
+DataStructureName/
+    │
+    ├── README.md             // Containing description & diagram or the structure
+    │
+    └── DataStrucureName.xxx  // (optional) Code implementation (.xxx is extention like java, cpp)
+```
 
-- Review Pull Requests from others.
-- Provide constructive feedback and help improve code quality.
+## Contributions
 
-### Documentation
+We welcome contributions! Here's how you can contribute to our project:
 
-- Help improve the project's documentation.
-- Add or update README, guides, or other documentation files.
+- **Report Issues:** Help by reporting bugs or suggesting enhancements. Check existing issues before creating a new one.
 
-### Spread the Word
+- **Pull Requests (PRs):** Submit focused PRs for review. Remember to follow the [_code style_](STANDARD.md).
 
-- Star the repository if you find it useful.
-- Share it on social media or with your networks to help others discover it.
+- **Code Reviews:** Review PRs from others. Offer constructive feedback to improve code quality.
 
 For more detailed guidelines, please refer to our [Contribution Guide](CONTRIBUTING.md).
 
-Thank you for considering contributing to our project! Every contribution is highly appreciated. 🎉
+Your contributions are highly appreciated! 🎉
