dsa_visualizer 0.1.0

data/lib/dsa_visualizer/fundamentals/memory.rb

@@ -0,0 +1,285 @@
+module DSAVisualizer
+  module Fundamentals
+    class Memory
+      def self.learn
+        Visualizer.print_header("MEMORY MANAGEMENT - How Data Lives in Computer Memory")
+        
+        # Introduction
+        puts "\n📖 UNDERSTANDING COMPUTER MEMORY".colorize(:cyan).bold
+        puts "─" * 80
+        puts "Memory is organized in a hierarchy:"
+        puts "  Registers (fastest, smallest) → Cache → RAM → Disk (slowest, largest)"
+        puts "\nWe primarily work with RAM (Random Access Memory)"
+        
+        # Memory Layout
+        Visualizer.print_section("1. Memory Layout of a Program")
+        puts "\n┌─────────────────────┐ High Address"
+        puts "│   Command Line Args │"
+        puts "├─────────────────────┤"
+        puts "│   Stack             │ ← Grows downward"
+        puts "│   (Local variables) │   Function calls"
+        puts "│   (Function calls)  │   Automatic cleanup"
+        puts "├─────────────────────┤"
+        puts "│         ↓           │"
+        puts "│                     │"
+        puts "│         ↑           │"
+        puts "├─────────────────────┤"
+        puts "│   Heap              │ ← Grows upward"
+        puts "│   (Dynamic memory)  │   Manual/GC managed"
+        puts "│   (Objects)         │   Flexible size"
+        puts "├─────────────────────┤"
+        puts "│   BSS (Uninitialized)│"
+        puts "├─────────────────────┤"
+        puts "│   Data (Initialized)│"
+        puts "├─────────────────────┤"
+        puts "│   Text (Code)       │"
+        puts "└─────────────────────┘ Low Address"
+        
+        # Stack vs Heap
+        Visualizer.print_section("2. Stack vs Heap Memory")
+        
+        puts "\n🔵 STACK MEMORY:".colorize(:blue).bold
+        puts "  • Fast allocation/deallocation (just move stack pointer)"
+        puts "  • Limited size (typically 1-8 MB)"
+        puts "  • Automatic cleanup (LIFO - Last In First Out)"
+        puts "  • Stores: local variables, function parameters, return addresses"
+        puts "  • Contiguous memory"
+        
+        puts "\n🟢 HEAP MEMORY:".colorize(:green).bold
+        puts "  • Slower allocation (must find free block)"
+        puts "  • Large size (limited by system RAM)"
+        puts "  • Manual management (C++) or Garbage Collection (Ruby)"
+        puts "  • Stores: dynamically allocated objects, large data structures"
+        puts "  • Fragmented memory possible"
+        
+        # Ruby vs C++ Memory Management
+        Visualizer.print_section("3. Ruby vs C++ Memory Management")
+        
+        ruby_code = <<~RUBY
+          # Ruby - Automatic Memory Management
+          def create_array
+            arr = [1, 2, 3, 4, 5]  # Heap allocated
+            # Ruby's GC will clean up automatically
+            arr
+          end
+          
+          result = create_array
+          # 'arr' in function is gone (stack)
+          # but array object still exists (heap)
+          # GC tracks references
+          
+          # When no references exist:
+          result = nil  # Array becomes eligible for GC
+        RUBY
+        
+        cpp_code = <<~CPP
+          // C++ - Manual Memory Management
+          int* createArray() {
+            int* arr = new int[5]{1,2,3,4,5};  // Heap
+            // Must manually delete!
+            return arr;
+          }
+          
+          int* result = createArray();
+          // Use the array...
+          
+          delete[] result;  // MUST free memory!
+          result = nullptr; // Good practice
+          
+          // Forgetting delete[] = memory leak!
+        CPP
+        
+        Visualizer.print_comparison(ruby_code, cpp_code,
+          "Ruby uses Garbage Collection (automatic). C++ requires manual memory management with new/delete.")
+        
+        # Stack Example
+        Visualizer.print_section("4. Stack Memory Example")
+        
+        ruby_code = <<~RUBY
+          def factorial(n)
+            return 1 if n <= 1
+            n * factorial(n - 1)
+          end
+          
+          factorial(4)
+          
+          # Call Stack:
+          # factorial(4) → calls factorial(3)
+          # factorial(3) → calls factorial(2)
+          # factorial(2) → calls factorial(1)
+          # factorial(1) → returns 1
+          # Then unwinds: 2*1, 3*2, 4*6 = 24
+        RUBY
+        
+        cpp_code = <<~CPP
+          int factorial(int n) {
+            if(n <= 1) return 1;
+            return n * factorial(n - 1);
+          }
+          
+          factorial(4);
+          
+          // Stack frames:
+          // [factorial(4)] ← top
+          // [factorial(3)]
+          // [factorial(2)]
+          // [factorial(1)] ← base
+          // Each frame stores: n, return address
+        CPP
+        
+        puts "\nStack Frame Visualization:"
+        puts "┌──────────────────┐"
+        puts "│ factorial(4)     │ ← Current"
+        puts "│ n=4, ret_addr    │"
+        puts "├──────────────────┤"
+        puts "│ factorial(3)     │"
+        puts "│ n=3, ret_addr    │"
+        puts "├──────────────────┤"
+        puts "│ factorial(2)     │"
+        puts "│ n=2, ret_addr    │"
+        puts "├──────────────────┤"
+        puts "│ factorial(1)     │"
+        puts "│ n=1, ret_addr    │"
+        puts "└──────────────────┘"
+        
+        Visualizer.print_comparison(ruby_code, cpp_code,
+          "Both use call stack for recursion. Deep recursion can cause stack overflow!")
+        
+        # Heap Example
+        Visualizer.print_section("5. Heap Memory Example")
+        
+        ruby_code = <<~RUBY
+          class Node
+            attr_accessor :data, :next
+            def initialize(data)
+              @data = data
+              @next = nil
+            end
+          end
+          
+          # Creating linked list
+          head = Node.new(10)      # Heap allocated
+          head.next = Node.new(20) # Heap allocated
+          head.next.next = Node.new(30)
+          
+          # All Node objects on heap
+          # GC tracks references
+          # When head = nil, all become eligible for GC
+        RUBY
+        
+        cpp_code = <<~CPP
+          struct Node {
+            int data;
+            Node* next;
+          };
+          
+          // Creating linked list
+          Node* head = new Node{10, nullptr};
+          head->next = new Node{20, nullptr};
+          head->next->next = new Node{30, nullptr};
+          
+          // Must manually free each node!
+          Node* temp;
+          while(head) {
+            temp = head;
+            head = head->next;
+            delete temp;  // Free each node
+          }
+        CPP
+        
+        Visualizer.print_comparison(ruby_code, cpp_code,
+          "Heap allows dynamic sizing. Ruby's GC vs C++'s manual delete. Memory leaks happen when you forget to free!")
+        
+        # Memory Leaks
+        Visualizer.print_section("6. Memory Leaks")
+        
+        puts "\n❌ Common Memory Leak in C++:"
+        puts "```cpp"
+        puts "void leak() {"
+        puts "  int* arr = new int[1000];"
+        puts "  // Forgot to delete[]!"
+        puts "  // Memory is lost forever (until program ends)"
+        puts "}"
+        puts "```"
+        
+        puts "\n✅ Proper Memory Management:"
+        puts "```cpp"
+        puts "void noLeak() {"
+        puts "  int* arr = new int[1000];"
+        puts "  // Use the array..."
+        puts "  delete[] arr;  // Clean up!"
+        puts "}"
+        puts "```"
+        
+        puts "\n✅ Modern C++ (RAII - Resource Acquisition Is Initialization):"
+        puts "```cpp"
+        puts "void modern() {"
+        puts "  std::vector<int> arr(1000);  // Automatic cleanup!"
+        puts "  std::unique_ptr<int[]> ptr(new int[1000]);"
+        puts "  // Automatically deleted when out of scope"
+        puts "}"
+        puts "```"
+        
+        # Cache Locality
+        Visualizer.print_section("7. Cache Locality & Performance")
+        
+        puts "\nCPU Cache is much faster than RAM:"
+        puts "  L1 Cache: ~1 ns"
+        puts "  L2 Cache: ~4 ns"
+        puts "  L3 Cache: ~10 ns"
+        puts "  RAM:      ~100 ns"
+        
+        puts "\n🚀 Good Cache Locality (Array):"
+        puts "  [1][2][3][4][5] ← Contiguous memory"
+        puts "  CPU loads chunk into cache"
+        puts "  Accessing next element is fast (already in cache)"
+        
+        puts "\n🐌 Poor Cache Locality (Linked List):"
+        puts "  [1]→...→[2]→...→[3]→...→[4] ← Scattered memory"
+        puts "  Each access might miss cache"
+        puts "  Must fetch from RAM (100× slower!)"
+        
+        # Important Notes
+        notes = [
+          "Stack: Fast, automatic, limited size, LIFO structure",
+          "Heap: Flexible, larger, requires management (manual or GC)",
+          "Ruby uses Garbage Collection - automatic but has overhead",
+          "C++ requires manual memory management - fast but error-prone",
+          "Modern C++ uses RAII and smart pointers for safety",
+          "Stack overflow happens with deep recursion or large local arrays",
+          "Memory leaks occur when heap memory isn't freed",
+          "Cache locality matters - contiguous memory is faster",
+          "Pointer size: 8 bytes on 64-bit systems, 4 bytes on 32-bit"
+        ]
+        NotesManager.print_notes("Memory Management", notes)
+        
+        # Key Points
+        key_points = [
+          "Stack is for local variables, Heap is for dynamic allocation",
+          "Ruby's GC trades performance for safety and convenience",
+          "C++ gives control but requires discipline (use smart pointers!)",
+          "Arrays have better cache locality than linked lists",
+          "Deep recursion uses stack memory - can cause overflow",
+          "Always free what you allocate in C++ (or use RAII)",
+          "Memory alignment affects performance (CPU reads in chunks)"
+        ]
+        NotesManager.print_key_points(key_points)
+        
+        # Common Mistakes
+        mistakes = [
+          "Forgetting to delete[] in C++ (memory leak)",
+          "Deleting same memory twice (double free - crash!)",
+          "Using memory after freeing it (dangling pointer)",
+          "Creating too deep recursion (stack overflow)",
+          "Allocating huge arrays on stack (use heap instead)",
+          "Not considering cache locality in performance-critical code"
+        ]
+        NotesManager.print_common_mistakes(mistakes)
+        
+        puts "\n💡 PRO TIP:".colorize(:yellow).bold
+        puts "In C++, prefer std::vector over raw arrays, and std::unique_ptr/shared_ptr"
+        puts "over raw pointers. They provide automatic memory management!"
+      end
+    end
+  end
+end

data/lib/dsa_visualizer/fundamentals/pointers.rb

@@ -0,0 +1,311 @@
+module DSAVisualizer
+  module Fundamentals
+    class Pointers
+      def self.learn
+        Visualizer.print_header("POINTERS & REFERENCES - The Foundation of Data Structures")
+        
+        puts "\n📖 WHAT ARE POINTERS?".colorize(:cyan).bold
+        puts "─" * 80
+        puts "A pointer is a variable that stores a memory address."
+        puts "It 'points to' another variable's location in memory."
+        
+        # Basic Concept
+        Visualizer.print_section("1. Pointer Basics")
+        
+        puts "\nMemory Visualization:"
+        puts "┌─────────┬──────────┬─────────┐"
+        puts "│ Address │   Name   │  Value  │"
+        puts "├─────────┼──────────┼─────────┤"
+        puts "│ 0x1000  │   x      │   42    │ ← Regular variable"
+        puts "│ 0x1004  │   ptr    │ 0x1000  │ ← Pointer (stores address of x)"
+        puts "└─────────┴──────────┴─────────┘"
+        
+        # Ruby vs C++
+        Visualizer.print_section("2. Ruby References vs C++ Pointers")
+        
+        ruby_code = <<~RUBY
+          # Ruby - No explicit pointers
+          # Everything is an object reference
+          
+          x = 42
+          y = x  # y references same object
+          
+          puts x.object_id  # Memory address
+          puts y.object_id  # Same address!
+          
+          # For immutable objects (numbers, symbols):
+          x = 43  # Creates NEW object
+          # y still references old object (42)
+          
+          # For mutable objects (arrays, hashes):
+          arr1 = [1, 2, 3]
+          arr2 = arr1  # Both reference same array
+          arr2 << 4    # Modifies shared array
+          puts arr1    # [1, 2, 3, 4]
+        RUBY
+        
+        cpp_code = <<~CPP
+          // C++ - Explicit pointers
+          
+          int x = 42;
+          int* ptr = &x;  // ptr stores address of x
+          
+          cout << x;      // 42 (value)
+          cout << &x;     // 0x1000 (address)
+          cout << ptr;    // 0x1000 (address stored in ptr)
+          cout << *ptr;   // 42 (dereference - get value)
+          
+          *ptr = 43;      // Modify x through pointer
+          cout << x;      // 43 (x changed!)
+          
+          // Pointer arithmetic
+          int arr[] = {1, 2, 3};
+          int* p = arr;   // Points to first element
+          p++;            // Now points to second element
+          cout << *p;     // 2
+        CPP
+        
+        Visualizer.print_comparison(ruby_code, cpp_code,
+          "Ruby uses implicit references (managed by GC). C++ uses explicit pointers (manual control).")
+        
+        # Pointer Operations
+        Visualizer.print_section("3. C++ Pointer Operations")
+        
+        puts "\n🔹 Declaration:"
+        puts "  int* ptr;        // Pointer to int"
+        puts "  int *ptr;        // Same thing (style choice)"
+        puts "  int* p1, p2;     // p1 is pointer, p2 is int! (confusing)"
+        puts "  int *p1, *p2;    // Both are pointers"
+        
+        puts "\n🔹 Address-of operator (&):"
+        puts "  int x = 10;"
+        puts "  int* ptr = &x;   // Get address of x"
+        
+        puts "\n🔹 Dereference operator (*):"
+        puts "  int value = *ptr; // Get value at address"
+        puts "  *ptr = 20;        // Set value at address"
+        
+        puts "\n🔹 Null pointer:"
+        puts "  int* ptr = nullptr;  // C++11 (preferred)"
+        puts "  int* ptr = NULL;     // Old style"
+        puts "  int* ptr = 0;        // Also works"
+        
+        # Pointer Arithmetic
+        Visualizer.print_section("4. Pointer Arithmetic")
+        
+        puts "\nArray in memory:"
+        puts "┌────┬────┬────┬────┬────┐"
+        puts "│ 10 │ 20 │ 30 │ 40 │ 50 │"
+        puts "└────┴────┴────┴────┴────┘"
+        puts "0x100 0x104 0x108 0x10C 0x110  (each int = 4 bytes)"
+        
+        cpp_code = <<~CPP
+          int arr[] = {10, 20, 30, 40, 50};
+          int* ptr = arr;  // Points to arr[0]
+          
+          cout << *ptr;      // 10
+          cout << *(ptr+1);  // 20 (moves 4 bytes, not 1!)
+          cout << *(ptr+2);  // 30
+          
+          ptr++;             // Now points to arr[1]
+          cout << *ptr;      // 20
+          
+          // Array indexing is pointer arithmetic!
+          arr[2] == *(arr + 2)  // TRUE!
+        CPP
+        
+        puts "\n#{cpp_code}"
+        puts "\n💡 Key Insight: ptr+1 doesn't add 1 byte, it adds sizeof(int) bytes!"
+        puts "   The compiler knows the type and adjusts automatically."
+        
+        # Pointers and Arrays
+        Visualizer.print_section("5. Pointers and Arrays")
+        
+        cpp_code = <<~CPP
+          int arr[5] = {1, 2, 3, 4, 5};
+          int* ptr = arr;  // Array name is pointer to first element
+          
+          // These are equivalent:
+          arr[0]  ==  *arr      ==  *(arr + 0)
+          arr[1]  ==  *(arr+1)  ==  ptr[1]
+          arr[2]  ==  *(ptr+2)  ==  ptr[2]
+          
+          // Passing array to function:
+          void process(int* arr, int size) {
+            // arr is just a pointer!
+            // Size information is lost
+          }
+        CPP
+        
+        puts "\n#{cpp_code}"
+        
+        # Pointers in Data Structures
+        Visualizer.print_section("6. Pointers in Data Structures")
+        
+        puts "\n🔗 Linked List Node:"
+        cpp_code = <<~CPP
+          struct Node {
+            int data;
+            Node* next;  // Pointer to next node
+          };
+          
+          Node* head = new Node{10, nullptr};
+          head->next = new Node{20, nullptr};
+          head->next->next = new Node{30, nullptr};
+          
+          // Traversal:
+          Node* current = head;
+          while(current != nullptr) {
+            cout << current->data;
+            current = current->next;  // Move to next node
+          }
+        CPP
+        puts cpp_code
+        
+        puts "\n🌳 Binary Tree Node:"
+        cpp_code = <<~CPP
+          struct TreeNode {
+            int data;
+            TreeNode* left;   // Pointer to left child
+            TreeNode* right;  // Pointer to right child
+          };
+          
+          TreeNode* root = new TreeNode{50, nullptr, nullptr};
+          root->left = new TreeNode{30, nullptr, nullptr};
+          root->right = new TreeNode{70, nullptr, nullptr};
+        CPP
+        puts cpp_code
+        
+        # Ruby Equivalent
+        Visualizer.print_section("7. Ruby's Object References")
+        
+        ruby_code = <<~RUBY
+          # Ruby doesn't have pointers, but references work similarly
+          
+          class Node
+            attr_accessor :data, :next
+            def initialize(data)
+              @data = data
+              @next = nil  # Reference to next node
+            end
+          end
+          
+          head = Node.new(10)
+          head.next = Node.new(20)
+          head.next.next = Node.new(30)
+          
+          # Traversal:
+          current = head
+          while current
+            puts current.data
+            current = current.next  # Follow reference
+          end
+          
+          # Key difference: No manual memory management!
+          # GC handles cleanup automatically
+        RUBY
+        
+        puts ruby_code
+        
+        # Common Pointer Errors
+        Visualizer.print_section("8. Common Pointer Errors (C++)")
+        
+        puts "\n❌ 1. Dangling Pointer:"
+        puts "```cpp"
+        puts "int* ptr = new int(42);"
+        puts "delete ptr;"
+        puts "cout << *ptr;  // ERROR! Memory freed, pointer still points there"
+        puts "ptr = nullptr; // Good practice after delete"
+        puts "```"
+        
+        puts "\n❌ 2. Memory Leak:"
+        puts "```cpp"
+        puts "int* ptr = new int(42);"
+        puts "ptr = new int(100);  // Lost reference to first allocation!"
+        puts "// First allocation leaked - can't free it now"
+        puts "```"
+        
+        puts "\n❌ 3. Null Pointer Dereference:"
+        puts "```cpp"
+        puts "int* ptr = nullptr;"
+        puts "cout << *ptr;  // CRASH! Can't dereference null"
+        puts "// Always check: if(ptr != nullptr) { *ptr = 10; }"
+        puts "```"
+        
+        puts "\n❌ 4. Wild Pointer:"
+        puts "```cpp"
+        puts "int* ptr;  // Uninitialized! Contains garbage"
+        puts "*ptr = 42; // CRASH! Writing to random memory"
+        puts "// Always initialize: int* ptr = nullptr;"
+        puts "```"
+        
+        # Smart Pointers
+        Visualizer.print_section("9. Modern C++ Smart Pointers")
+        
+        puts "\n✅ Smart pointers provide automatic memory management:"
+        
+        cpp_code = <<~CPP
+          #include <memory>
+          
+          // unique_ptr - Single ownership
+          std::unique_ptr<int> ptr1(new int(42));
+          // or better:
+          auto ptr1 = std::make_unique<int>(42);
+          // Automatically deleted when out of scope!
+          
+          // shared_ptr - Shared ownership (reference counting)
+          std::shared_ptr<int> ptr2 = std::make_shared<int>(42);
+          std::shared_ptr<int> ptr3 = ptr2;  // Both own it
+          // Deleted when last shared_ptr goes out of scope
+          
+          // weak_ptr - Non-owning reference (breaks cycles)
+          std::weak_ptr<int> ptr4 = ptr2;
+          // Doesn't prevent deletion
+        CPP
+        
+        puts cpp_code
+        
+        # Notes
+        notes = [
+          "Pointer stores memory address, not the value itself",
+          "& (address-of) gets address, * (dereference) gets value",
+          "Ruby uses implicit references, C++ uses explicit pointers",
+          "Array name is pointer to first element in C++",
+          "Pointer arithmetic: ptr+1 moves by sizeof(type) bytes",
+          "Always initialize pointers (nullptr in C++)",
+          "Check for nullptr before dereferencing",
+          "Use smart pointers in modern C++ (unique_ptr, shared_ptr)",
+          "Ruby's GC eliminates pointer management complexity"
+        ]
+        NotesManager.print_notes("Pointers & References", notes)
+        
+        # Key Points
+        key_points = [
+          "Pointers enable dynamic data structures (linked lists, trees, graphs)",
+          "Ruby abstracts pointers as object references with automatic GC",
+          "C++ pointers give control but require careful management",
+          "Null pointer dereference is a common crash cause",
+          "Memory leaks happen when you lose pointer to allocated memory",
+          "Smart pointers (C++11+) provide safety with RAII",
+          "Understanding pointers is crucial for DSA implementation"
+        ]
+        NotesManager.print_key_points(key_points)
+        
+        # Common Mistakes
+        mistakes = [
+          "Dereferencing null or uninitialized pointer (crash!)",
+          "Using pointer after freeing memory (dangling pointer)",
+          "Forgetting to free allocated memory (memory leak)",
+          "Confusing pointer and value (missing * or &)",
+          "Array out of bounds with pointer arithmetic",
+          "Double-freeing same memory (crash!)"
+        ]
+        NotesManager.print_common_mistakes(mistakes)
+        
+        puts "\n💡 PRO TIP:".colorize(:yellow).bold
+        puts "In C++, prefer references (&) for function parameters when you don't need"
+        puts "pointer arithmetic or reassignment. Use smart pointers for ownership."
+      end
+    end
+  end
+end

data/lib/dsa_visualizer/fundamentals/recursion.rb

@@ -0,0 +1,63 @@
+module DSAVisualizer
+  module Fundamentals
+    class Recursion
+      def self.learn
+        Visualizer.print_header("RECURSION - Function Calling Itself")
+        
+        puts "\n📖 WHAT IS RECURSION?".colorize(:cyan).bold
+        puts "─" * 80
+        puts "Recursion is when a function calls itself to solve a problem"
+        puts "by breaking it down into smaller subproblems."
+        
+        Visualizer.print_section("1. Basic Recursion Example")
+        
+        ruby_code = <<~RUBY
+          def factorial(n)
+            return 1 if n <= 1  # Base case
+            n * factorial(n - 1)  # Recursive case
+          end
+          
+          factorial(5)
+          # 5 * factorial(4)
+          # 5 * 4 * factorial(3)
+          # 5 * 4 * 3 * factorial(2)
+          # 5 * 4 * 3 * 2 * factorial(1)
+          # 5 * 4 * 3 * 2 * 1 = 120
+        RUBY
+        
+        cpp_code = <<~CPP
+          int factorial(int n) {
+            if(n <= 1) return 1;  // Base case
+            return n * factorial(n - 1);  // Recursive
+          }
+          
+          factorial(5);
+          // Call stack grows then unwinds
+          // Space: O(n) due to call stack
+        CPP
+        
+        Visualizer.print_comparison(ruby_code, cpp_code,
+          "Both use call stack. Each recursive call adds a stack frame. Must have base case to stop!")
+        
+        notes = [
+          "Every recursion needs a base case (stopping condition)",
+          "Recursive case must progress toward base case",
+          "Space complexity: O(n) for call stack depth n",
+          "Can cause stack overflow if too deep",
+          "Some recursions can be optimized with tail call optimization",
+          "Iterative solutions often more efficient (no stack overhead)"
+        ]
+        NotesManager.print_notes("Recursion", notes)
+        
+        key_points = [
+          "Recursion = function calling itself",
+          "Base case prevents infinite recursion",
+          "Call stack stores each recursive call",
+          "Useful for tree/graph traversal, divide-and-conquer",
+          "Trade-off: elegant code vs stack space"
+        ]
+        NotesManager.print_key_points(key_points)
+      end
+    end
+  end
+end