dsa_visualizer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5280e73e1e1cfd6f1a2f896d689044085977ec5d73f1a2f2d0def717509d1763
+  data.tar.gz: 7f4eeb0841cbe5e5710cb51908e3ca1e371167413bde705d052aff5f3afc1f71
+SHA512:
+  metadata.gz: 20538083c06fef9dc44c37278f2a3942fca9b2b71aaccfe2e5144d71ef57d088ea27e445db37255f7bf1d1065dd547c126bd0e0d796b4c08d62a515d82d20a32
+  data.tar.gz: f5815ec1183948b93e616e9067c01de2e6574b06c470cab19a7ad66919ae82d337ee3bb9f2e81113434b2549203533a2405dfe537ad1e2404f41feeec4104a25

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DSA Visualizer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,323 @@
+# DSA Visualizer - Zero to Hero
+
+A comprehensive Ruby gem for learning Data Structures and Algorithms from scratch by visualizing concepts at the core level, comparing Ruby and C++ implementations with step-by-step execution details, detailed notes, and practice problems.
+
+## 🎯 Features
+
+- 📚 **Complete DSA Curriculum**: 12 sections covering fundamentals to advanced topics
+- 🎨 **Visual Representations**: ASCII art visualizations of data structures
+- 🔄 **Ruby vs C++ Comparisons**: Side-by-side implementation comparisons
+- 🧠 **Core Level Explanations**: Deep dive into memory layout and internal workings
+- 📊 **Memory Tracking**: Track allocations and operations
+- ⏱️ **Complexity Analysis**: Time and space complexity for every operation
+- 📝 **Detailed Notes**: Important points, common mistakes, best practices
+- 🎯 **Real-World Examples**: Practical use cases for each concept
+- 💪 **Practice Problems**: Curated problems for each topic
+- 📈 **Progress Tracking**: Track your learning journey
+- 🖥️ **Interactive CLI**: Command-based navigation through topics
+
+## 📚 Complete Curriculum
+
+### 1. Fundamentals
+- Time & Space Complexity (Big O Notation)
+- Memory Management (Stack vs Heap)
+- Pointers & References
+- Recursion Basics
+
+### 2. Basic Data Structures
+- Arrays
+- Strings
+- Linked Lists (Singly, Doubly, Circular)
+
+### 3. Stack & Queue
+- Stack (Array-based & Linked List-based)
+- Queue (Array-based & Linked List-based)
+- Circular Queue
+- Deque
+- Priority Queue
+
+### 4. Hashing
+- Hash Functions
+- Hash Tables
+- Collision Handling (Chaining, Open Addressing)
+- Hash Maps & Sets
+
+### 5. Trees
+- Binary Trees
+- Binary Search Trees (BST)
+- Tree Traversals (Inorder, Preorder, Postorder, Level-order)
+- AVL Trees
+- Red-Black Trees
+- B-Trees
+- Segment Trees
+- Fenwick Trees (Binary Indexed Tree)
+- Trie (Prefix Tree)
+
+### 6. Heaps
+- Min Heap & Max Heap
+- Heap Operations (Insert, Extract, Heapify)
+- Heap Sort
+
+### 7. Graphs
+- Graph Representations (Adjacency Matrix, Adjacency List)
+- BFS (Breadth-First Search)
+- DFS (Depth-First Search)
+- Topological Sort
+- Shortest Path Algorithms (Dijkstra, Bellman-Ford)
+- Minimum Spanning Tree (Kruskal, Prim)
+- Floyd-Warshall Algorithm
+
+### 8. Sorting Algorithms
+- Bubble Sort, Selection Sort, Insertion Sort
+- Merge Sort, Quick Sort, Heap Sort
+- Counting Sort, Radix Sort, Bucket Sort
+
+### 9. Searching Algorithms
+- Linear Search, Binary Search
+- Ternary Search, Jump Search
+- Interpolation Search
+
+### 10. Advanced Algorithms
+- Dynamic Programming (Fibonacci, Knapsack, LCS, Matrix Chain)
+- Greedy Algorithms
+- Backtracking
+- Divide and Conquer
+
+### 11. String Algorithms
+- Pattern Matching (Naive, KMP, Rabin-Karp)
+- Z Algorithm
+
+### 12. Advanced Data Structures
+- Disjoint Set (Union-Find)
+- Suffix Array & Suffix Tree
+- Skip List
+
+## 🚀 Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'dsa_visualizer'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install dsa_visualizer
+```
+
+## 💻 Usage
+
+### Interactive CLI (Recommended)
+
+Start the interactive learning interface:
+
+```bash
+ruby -Ilib bin/dsa_visualizer
+```
+
+Or in your Ruby code:
+
+```ruby
+require 'dsa_visualizer'
+
+DSAVisualizer.start_cli
+```
+
+This launches an interactive menu where you can:
+- Navigate through 12 sections of DSA topics
+- Select specific topics by number (e.g., "2.1" for Arrays)
+- Track your learning progress
+- View saved notes
+
+### Direct Topic Access
+
+Learn specific topics programmatically:
+
+```ruby
+require 'dsa_visualizer'
+
+# Fundamentals
+DSAVisualizer.learn(:complexity_basics)
+DSAVisualizer.learn(:memory_basics)
+DSAVisualizer.learn(:pointers_basics)
+DSAVisualizer.learn(:recursion_basics)
+
+# Data Structures
+DSAVisualizer.learn(:array)
+DSAVisualizer.learn(:linked_list)
+DSAVisualizer.learn(:stack)
+DSAVisualizer.learn(:queue)
+DSAVisualizer.learn(:hash_table)
+DSAVisualizer.learn(:binary_tree)
+DSAVisualizer.learn(:bst)
+
+# Algorithms
+DSAVisualizer.learn(:bubble_sort)
+DSAVisualizer.learn(:binary_search)
+DSAVisualizer.learn(:bfs)
+DSAVisualizer.learn(:dfs)
+DSAVisualizer.learn(:dijkstra)
+```
+
+## 📖 Example Output
+
+When you run `DSAVisualizer.learn(:complexity_basics)`:
+
+```
+================================================================================
+          TIME & SPACE COMPLEXITY - Foundation of Algorithm Analysis
+================================================================================
+
+📖 WHAT IS COMPLEXITY ANALYSIS?
+────────────────────────────────────────────────────────────────────────────────
+Complexity analysis helps us understand how an algorithm's performance
+scales with input size. We measure two things:
+  1. Time Complexity - How execution time grows
+  2. Space Complexity - How memory usage grows
+
+1. Big O Notation
+────────────────────────────────────────────────────────────────────────────────
+
+Big O describes the upper bound (worst case) of algorithm growth.
+
+Common Time Complexities (from best to worst):
+  O(1)         Constant        → Array access, hash lookup
+  O(log n)     Logarithmic     → Binary search, balanced tree ops
+  O(n)         Linear          → Array traversal, linear search
+  O(n log n)   Linearithmic    → Merge sort, quick sort (avg)
+  O(n²)        Quadratic       → Bubble sort, nested loops
+  ...
+
+[Detailed examples with Ruby and C++ code comparisons follow]
+```
+
+## 🎓 Learning Path
+
+### For Beginners (Start Here!)
+1. Start with **Fundamentals** (Section 1)
+   - Understand complexity analysis first
+   - Learn memory management basics
+   - Master pointers/references concept
+   - Practice recursion
+
+2. Move to **Basic Data Structures** (Section 2)
+   - Arrays and Strings
+   - Linked Lists
+
+3. Learn **Stack & Queue** (Section 3)
+
+### Intermediate Level
+4. **Hashing** (Section 4)
+5. **Trees** (Section 5)
+6. **Heaps** (Section 6)
+7. **Sorting & Searching** (Sections 8-9)
+
+### Advanced Level
+8. **Graphs** (Section 7)
+9. **Advanced Algorithms** (Section 10)
+10. **String Algorithms** (Section 11)
+11. **Advanced Data Structures** (Section 12)
+
+## 🎯 What Makes This Gem Special?
+
+1. **Zero to Hero Approach**: Complete curriculum from basics to advanced
+2. **Core Level Understanding**: Shows what happens in memory, not just theory
+3. **Language Comparison**: Learn by comparing Ruby's abstractions with C++'s control
+4. **Visual Learning**: ASCII visualizations make abstract concepts concrete
+5. **Step-by-Step**: Track each operation with detailed explanations
+6. **Comprehensive Notes**: Important points, common mistakes, best practices
+7. **Practice Problems**: Curated problems for each topic
+8. **Progress Tracking**: See your learning journey
+9. **Real-World Context**: Understand when and why to use each structure
+10. **Interactive CLI**: Easy navigation through topics
+
+## 📝 Each Topic Includes
+
+- ✅ Concept explanation
+- ✅ Ruby implementation with code
+- ✅ C++ implementation with code
+- ✅ Side-by-side comparison
+- ✅ Memory layout visualization
+- ✅ Time complexity analysis
+- ✅ Space complexity analysis
+- ✅ Step-by-step operation walkthrough
+- ✅ Important notes and key points
+- ✅ When to use / when not to use
+- ✅ Real-world applications
+- ✅ Common mistakes to avoid
+- ✅ Practice problems
+
+## 🛠️ Requirements
+
+- Ruby >= 2.7.0
+- colorize gem (for colored output)
+- tty-box gem (for visual boxes)
+- tty-table gem (for tables)
+
+## 🔧 Development
+
+After checking out the repo, run:
+
+```bash
+bundle install
+```
+
+To run the interactive CLI:
+
+```bash
+ruby -Ilib bin/dsa_visualizer
+```
+
+To run a specific topic:
+
+```bash
+ruby -Ilib -r dsa_visualizer -e "DSAVisualizer.learn(:array)"
+```
+
+## 🤝 Contributing
+
+Bug reports and pull requests are welcome on GitHub. This project is intended to be a safe, welcoming space for collaboration.
+
+## 📄 License
+
+The gem is available as open source under the terms of the MIT License.
+
+## 🗺️ Roadmap
+
+- [x] Core fundamentals (Complexity, Memory, Pointers, Recursion)
+- [x] Basic data structures (Array, Linked List, Stack, Queue)
+- [x] Interactive CLI with progress tracking
+- [ ] Complete all tree implementations
+- [ ] Complete all graph algorithms
+- [ ] Complete all sorting algorithms
+- [ ] Add dynamic programming examples
+- [ ] Add more practice problems
+- [ ] Add quiz mode
+- [ ] Export notes to PDF
+- [ ] Web interface
+- [ ] Video tutorials integration
+
+## 💡 Tips for Learning
+
+1. **Follow the order**: Start with fundamentals, don't skip ahead
+2. **Practice coding**: Don't just read, implement the structures yourself
+3. **Understand, don't memorize**: Focus on why, not just how
+4. **Compare languages**: See how Ruby and C++ approach the same problem
+5. **Solve practice problems**: Apply what you learn
+6. **Track progress**: Use the built-in progress tracker
+7. **Review notes**: Revisit important points regularly
+
+## 🙏 Credits
+
+Created for developers who want to truly understand data structures and algorithms at a fundamental level, with practical comparisons between high-level (Ruby) and low-level (C++) implementations.
+
+---
+
+**Happy Learning! 🚀 Master DSA one topic at a time!**

data/USAGE.md

@@ -0,0 +1,359 @@
+# DSA Visualizer - Complete Usage Guide
+
+## Table of Contents
+1. [Getting Started](#getting-started)
+2. [Interactive CLI](#interactive-cli)
+3. [Topic Navigation](#topic-navigation)
+4. [Understanding Output](#understanding-output)
+5. [Progress Tracking](#progress-tracking)
+6. [Learning Tips](#learning-tips)
+
+## Getting Started
+
+### Installation
+
+```bash
+gem install dsa_visualizer
+```
+
+Or add to your Gemfile:
+
+```ruby
+gem 'dsa_visualizer'
+bundle install
+```
+
+### First Run
+
+Start the interactive CLI:
+
+```bash
+ruby -Ilib bin/dsa_visualizer
+```
+
+You'll see the main menu with all 12 sections of the curriculum.
+
+## Interactive CLI
+
+### Main Menu
+
+```
+╔══════════════════════════════════════════════════════════════════════════════╗
+║                    DSA VISUALIZER - Zero to Hero                             ║
+║              Ruby vs C++ Implementation Comparison                           ║
+╚══════════════════════════════════════════════════════════════════════════════╝
+
+📚 CURRICULUM
+────────────────────────────────────────────────────────────────────────────────
+
+1. Fundamentals
+   1.1. Time & Space Complexity
+   1.2. Memory Management
+   1.3. Pointers & References
+   1.4. Recursion Basics
+
+2. Basic Data Structures
+   2.1. Arrays
+   2.2. Strings
+   2.3. Linked Lists
+   ...
+
+Commands:
+  • Enter topic number (e.g., 2.1 for Arrays)
+  • Type 'progress' to see your learning progress
+  • Type 'notes' to view saved notes
+  • Type '0' to exit
+────────────────────────────────────────────────────────────────────────────────
+
+➤ Enter your choice:
+```
+
+### Navigation Commands
+
+- **Topic Number** (e.g., `1.1`, `2.1`): Learn specific topic
+- **`progress`**: View your learning progress
+- **`notes`**: View saved notes (coming soon)
+- **`0`**: Exit the program
+
+## Topic Navigation
+
+### Recommended Learning Path
+
+#### Beginners (Week 1-2)
+```
+1.1 → 1.2 → 1.3 → 1.4  (Fundamentals)
+2.1 → 2.2 → 2.3        (Basic Data Structures)
+3.1 → 3.3              (Stack & Queue basics)
+```
+
+#### Intermediate (Week 3-4)
+```
+4.1 → 4.2 → 4.3        (Hashing)
+5.1 → 5.2 → 5.3        (Trees basics)
+8.1 → 8.4 → 8.5        (Sorting)
+9.1 → 9.2              (Searching)
+```
+
+#### Advanced (Week 5-8)
+```
+6.1 → 6.2              (Heaps)
+7.1 → 7.2 → 7.3 → 7.5  (Graphs)
+10.1 → 10.2 → 10.3     (Dynamic Programming)
+```
+
+### Direct Topic Access (Programmatic)
+
+```ruby
+require 'dsa_visualizer'
+
+# Learn fundamentals
+DSAVisualizer.learn(:complexity_basics)
+DSAVisualizer.learn(:memory_basics)
+DSAVisualizer.learn(:pointers_basics)
+DSAVisualizer.learn(:recursion_basics)
+
+# Learn data structures
+DSAVisualizer.learn(:array)
+DSAVisualizer.learn(:linked_list)
+DSAVisualizer.learn(:stack)
+DSAVisualizer.learn(:queue)
+DSAVisualizer.learn(:hash_table)
+DSAVisualizer.learn(:binary_tree)
+
+# Learn algorithms
+DSAVisualizer.learn(:bubble_sort)
+DSAVisualizer.learn(:binary_search)
+DSAVisualizer.learn(:bfs)
+DSAVisualizer.learn(:dfs)
+```
+
+## Understanding Output
+
+Each topic provides comprehensive information in this structure:
+
+### 1. Header
+```
+================================================================================
+                    TOPIC NAME - Description
+================================================================================
+```
+
+### 2. Introduction
+- What is this concept?
+- Why is it important?
+- Where is it used?
+
+### 3. Code Comparisons
+```
+┌─ Ruby Implementation ─────────────────────────────────────────────────────┐
+│ Ruby code here                                                             │
+└────────────────────────────────────────────────────────────────────────────┘
+
+┌─ C++ Implementation ──────────────────────────────────────────────────────┐
+│ C++ code here                                                              │
+└────────────────────────────────────────────────────────────────────────────┘
+
+💡 Core Difference:
+   Explanation of key differences
+```
+
+### 4. Visual Representations
+- ASCII art diagrams
+- Memory layouts
+- Step-by-step operations
+
+### 5. Complexity Analysis
+```
+⏱️  TIME COMPLEXITY SUMMARY
+────────────────────────────────────────────────────────────────────────────────
+  Operation                      → Complexity
+  Access                         → O(1)
+  Search                         → O(n)
+  Insertion                      → O(n)
+  Deletion                       → O(n)
+```
+
+### 6. Important Notes
+```
+📝 IMPORTANT NOTES - Topic Name
+════════════════════════════════════════════════════════════════════════════════
+1. First important point
+2. Second important point
+...
+```
+
+### 7. Key Points
+```
+🎯 KEY POINTS TO REMEMBER
+────────────────────────────────────────────────────────────────────────────────
+  ✓ Key point 1
+  ✓ Key point 2
+  ...
+```
+
+### 8. When to Use
+```
+✅ WHEN TO USE
+────────────────────────────────────────────────────────────────────────────────
+  ✓ Use case 1
+  ✓ Use case 2
+  ...
+```
+
+### 9. Common Mistakes
+```
+⚠️  COMMON MISTAKES TO AVOID
+────────────────────────────────────────────────────────────────────────────────
+  ⚠  Mistake 1
+  ⚠  Mistake 2
+  ...
+```
+
+### 10. Practice Problems
+```
+💪 PRACTICE PROBLEMS
+────────────────────────────────────────────────────────────────────────────────
+  1. Problem Title [Difficulty]
+     Description
+  ...
+```
+
+## Progress Tracking
+
+### View Progress
+
+Type `progress` in the CLI to see:
+
+```
+📊 YOUR LEARNING PROGRESS
+────────────────────────────────────────────────────────────────────────────────
+
+Completed: 5/50 topics
+Progress: ██████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 10%
+
+✅ Completed Topics:
+   • 1.1 - Time & Space Complexity
+   • 1.2 - Memory Management
+   • 2.1 - Arrays
+   • 2.3 - Linked Lists
+   • 3.1 - Stack
+```
+
+Progress is automatically saved to `~/.dsa_visualizer_progress`
+
+## Learning Tips
+
+### 1. Start with Fundamentals
+Don't skip section 1! Understanding complexity, memory, and pointers is crucial.
+
+### 2. Code Along
+Don't just read - implement the structures yourself:
+
+```ruby
+# After learning linked lists, implement it:
+class Node
+  attr_accessor :data, :next
+  def initialize(data)
+    @data = data
+    @next = nil
+  end
+end
+
+# Test your implementation
+head = Node.new(10)
+head.next = Node.new(20)
+```
+
+### 3. Compare Languages
+Pay attention to Ruby vs C++ differences:
+- Ruby: High-level, automatic memory management
+- C++: Low-level, manual control, better performance
+
+### 4. Visualize
+Draw the structures on paper as you learn:
+```
+Array:  [1][2][3][4][5]  ← Contiguous
+
+Linked List:  [1]→[2]→[3]→[4]→nil  ← Scattered
+```
+
+### 5. Practice Problems
+After each topic, solve the practice problems provided.
+
+### 6. Review Notes
+Revisit "Important Notes" and "Key Points" sections regularly.
+
+### 7. Understand Trade-offs
+Every data structure has pros and cons. Learn when to use what.
+
+### 8. Track Progress
+Use the progress tracker to stay motivated and see your journey.
+
+## Advanced Usage
+
+### Custom Learning Path
+
+Create your own learning script:
+
+```ruby
+require 'dsa_visualizer'
+
+# Focus on trees
+topics = [:binary_tree, :bst, :heap]
+topics.each do |topic|
+  DSAVisualizer.learn(topic)
+  puts "\n\nPress Enter to continue..."
+  gets
+end
+```
+
+### Integration with Your Code
+
+```ruby
+require 'dsa_visualizer'
+
+# Learn before implementing
+DSAVisualizer.learn(:hash_table)
+
+# Then implement your own
+class MyHashTable
+  # Your implementation
+end
+```
+
+## Troubleshooting
+
+### Colors Not Showing
+Install colorize gem:
+```bash
+gem install colorize
+```
+
+### CLI Not Starting
+Make sure you're in the gem directory:
+```bash
+cd path/to/dsa_visualizer
+ruby -Ilib bin/dsa_visualizer
+```
+
+### Topic Not Found
+Check the topic key in the main menu. Use exact format (e.g., `2.1` not `2-1`).
+
+## Next Steps
+
+1. Complete all fundamentals (Section 1)
+2. Master basic data structures (Sections 2-3)
+3. Learn hashing and trees (Sections 4-5)
+4. Study algorithms (Sections 8-9)
+5. Tackle advanced topics (Sections 10-12)
+
+## Support
+
+For issues or questions:
+- Check the README.md
+- Review this USAGE.md
+- Open an issue on GitHub
+
+---
+
+**Happy Learning! Master DSA one topic at a time! 🚀**

data/bin/dsa_visualizer

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/dsa_visualizer'
+
+DSAVisualizer.start_cli