dsa_visualizer 0.1.0

data/lib/dsa_visualizer/data_structures/binary_tree.rb

@@ -0,0 +1,104 @@
+module DSAVisualizer
+  module DataStructures
+    class TreeNode
+      attr_accessor :value, :left, :right
+      
+      def initialize(value)
+        @value = value
+        @left = nil
+        @right = nil
+      end
+    end
+
+    class BinaryTree
+      attr_reader :root
+
+      def initialize
+        @root = nil
+      end
+
+      def insert(value)
+        @root = insert_recursive(@root, value)
+      end
+
+      private
+
+      def insert_recursive(node, value)
+        return TreeNode.new(value) if node.nil?
+        
+        if value < node.value
+          node.left = insert_recursive(node.left, value)
+        else
+          node.right = insert_recursive(node.right, value)
+        end
+        node
+      end
+
+      public
+
+      def self.learn
+        demo
+      end
+      
+      def self.demo
+        Visualizer.print_header("BINARY SEARCH TREE - Core Level Visualization")
+        
+        Visualizer.print_section("1. BST Concept")
+        puts "\nBinary Search Tree properties:"
+        puts "  - Left subtree < node < right subtree"
+        puts "  - Enables O(log n) search in balanced tree"
+        puts "  - Can degrade to O(n) if unbalanced"
+        
+        Visualizer.print_section("2. Implementation Comparison")
+        
+        ruby_code = <<~RUBY
+          class TreeNode
+            attr_accessor :value, :left, :right
+            def initialize(value)
+              @value = value
+              @left = @right = nil
+            end
+          end
+          
+          # Ruby: object references for children
+          # GC handles memory
+        RUBY
+
+        cpp_code = <<~CPP
+          struct TreeNode {
+            int value;
+            TreeNode *left, *right;
+            TreeNode(int v) : value(v), 
+              left(nullptr), right(nullptr) {}
+          };
+          
+          // C++: explicit pointers
+          // Manual memory management
+        CPP
+
+        explanation = "Both use pointer-based structure. Ruby uses object references with GC, C++ uses raw pointers requiring manual deletion. Tree traversal is same in both."
+        
+        Visualizer.print_comparison(ruby_code, cpp_code, explanation)
+        
+        tree = BinaryTree.new
+        values = [50, 30, 70, 20, 40, 60, 80]
+        
+        Visualizer.print_step(1, "Inserting values: #{values.join(', ')}")
+        values.each { |v| tree.insert(v) }
+        
+        puts "\nTree structure:"
+        puts "        50"
+        puts "       /  \\"
+        puts "      30   70"
+        puts "     / \\   / \\"
+        puts "    20 40 60 80"
+        
+        puts "\n\n🎯 Key Takeaways:".colorize(:green).bold
+        puts "  1. BST enables efficient searching: O(log n) average"
+        puts "  2. Insertion/deletion: O(log n) average"
+        puts "  3. Worst case O(n) for unbalanced tree"
+        puts "  4. Self-balancing trees (AVL, Red-Black) maintain O(log n)"
+      end
+    end
+  end
+end

data/lib/dsa_visualizer/data_structures/bst.rb

@@ -0,0 +1,11 @@
+module DSAVisualizer
+  module DataStructures
+    class BST
+      def self.learn
+        Visualizer.print_header("BINARY SEARCH TREE - Ordered Binary Tree")
+        puts "\n📚 Coming soon: BST properties, search, insert, delete"
+        puts "Topics: In-order traversal, balancing, AVL trees"
+      end
+    end
+  end
+end

data/lib/dsa_visualizer/data_structures/deque.rb

@@ -0,0 +1,11 @@
+module DSAVisualizer
+  module DataStructures
+    class Deque
+      def self.learn
+        Visualizer.print_header("DEQUE - Double-Ended Queue")
+        puts "\n📚 Coming soon: Operations at both ends"
+        puts "Topics: Push/pop from front and back, circular buffer implementation"
+      end
+    end
+  end
+end

data/lib/dsa_visualizer/data_structures/doubly_linked_list.rb

@@ -0,0 +1,11 @@
+module DSAVisualizer
+  module DataStructures
+    class DoublyLinkedList
+      def self.learn
+        Visualizer.print_header("DOUBLY LINKED LIST - Bidirectional Navigation")
+        puts "\n📚 Coming soon: Two-way traversal, prev and next pointers"
+        puts "Topics: Insertion, deletion, reverse traversal"
+      end
+    end
+  end
+end

data/lib/dsa_visualizer/data_structures/graph.rb

@@ -0,0 +1,11 @@
+module DSAVisualizer
+  module DataStructures
+    class Graph
+      def self.learn
+        Visualizer.print_header("GRAPH - Vertices and Edges")
+        puts "\n📚 Coming soon: Graph representations"
+        puts "Topics: Adjacency matrix, adjacency list, directed vs undirected"
+      end
+    end
+  end
+end

data/lib/dsa_visualizer/data_structures/hash_table.rb

@@ -0,0 +1,61 @@
+module DSAVisualizer
+  module DataStructures
+    class HashTable
+      def self.learn
+        demo
+      end
+      
+      def self.demo
+        Visualizer.print_header("HASH TABLE - Core Level Visualization")
+        
+        Visualizer.print_section("1. Hash Table Concept")
+        puts "\nKey-Value storage with O(1) average access time"
+        puts "Uses hash function to map keys to array indices"
+        
+        Visualizer.print_section("2. Implementation Comparison")
+        
+        ruby_code = <<~RUBY
+          hash = { "name" => "Alice", "age" => 30 }
+          
+          # Ruby Hash internals:
+          # - Uses MurmurHash
+          # - Open addressing with linear probing
+          # - Maintains insertion order (since Ruby 1.9)
+          # - Automatic resizing at 75% capacity
+        RUBY
+
+        cpp_code = <<~CPP
+          #include <unordered_map>
+          std::unordered_map<std::string, int> map;
+          map["name"] = "Alice";
+          
+          // C++ unordered_map:
+          // - Uses hash function (std::hash)
+          // - Separate chaining (linked lists)
+          // - No order guarantee
+          // - Rehashing at load factor threshold
+        CPP
+
+        explanation = "Ruby Hash maintains insertion order and uses open addressing. C++ unordered_map uses separate chaining and doesn't maintain order. Both provide O(1) average case, O(n) worst case."
+        
+        Visualizer.print_comparison(ruby_code, cpp_code, explanation)
+        
+        Visualizer.print_section("3. Hash Function Demo")
+        
+        keys = ["apple", "banana", "cherry"]
+        puts "\nHash values for keys:"
+        keys.each do |key|
+          hash_val = key.hash
+          bucket = hash_val % 10
+          puts "  '#{key}' → hash: #{hash_val} → bucket: #{bucket}"
+        end
+        
+        puts "\n\n🎯 Key Takeaways:".colorize(:green).bold
+        puts "  1. Hash tables provide O(1) average lookup"
+        puts "  2. Collision handling: chaining vs open addressing"
+        puts "  3. Ruby maintains order, C++ doesn't"
+        puts "  4. Load factor triggers resizing"
+      end
+    end
+  end
+end

data/lib/dsa_visualizer/data_structures/heap.rb

@@ -0,0 +1,17 @@
+module DSAVisualizer
+  module DataStructures
+    class Heap
+      def self.learn_min
+        Visualizer.print_header("MIN HEAP - Complete Binary Tree")
+        puts "\n📚 Coming soon: Heap property, heapify, extract-min"
+        puts "Topics: Array representation, priority queue implementation"
+      end
+      
+      def self.learn_max
+        Visualizer.print_header("MAX HEAP - Complete Binary Tree")
+        puts "\n📚 Coming soon: Max heap operations"
+        puts "Topics: Heap sort, building heap in O(n)"
+      end
+    end
+  end
+end

data/lib/dsa_visualizer/data_structures/linked_list.rb

@@ -0,0 +1,197 @@
+module DSAVisualizer
+  module DataStructures
+    class Node
+      attr_accessor :data, :next
+      
+      def initialize(data)
+        @data = data
+        @next = nil
+      end
+    end
+
+    class LinkedList
+      attr_reader :head
+
+      def initialize
+        @head = nil
+      end
+
+      def append(data)
+        new_node = Node.new(data)
+        
+        if @head.nil?
+          @head = new_node
+          return
+        end
+
+        current = @head
+        current = current.next while current.next
+        current.next = new_node
+      end
+
+      def visualize
+        return "Empty list" if @head.nil?
+        
+        result = ""
+        current = @head
+        while current
+          result += "[#{current.data}|•]"
+          result += " -> " if current.next
+          current = current.next
+        end
+        result += " -> nil"
+        result
+      end
+
+      def self.learn
+        demo
+      end
+      
+      def self.demo
+        Visualizer.print_header("LINKED LIST - Core Level Visualization")
+        
+        # Memory Model
+        Visualizer.print_section("1. Memory Model Comparison")
+        
+        ruby_code = <<~RUBY
+          class Node
+            attr_accessor :data, :next
+            def initialize(data)
+              @data = data
+              @next = nil
+            end
+          end
+          # Each node is a Ruby object
+          # @next stores reference to next node
+        RUBY
+
+        cpp_code = <<~CPP
+          struct Node {
+            int data;
+            Node* next;
+            Node(int d) : data(d), next(nullptr) {}
+          };
+          // Each node allocated on heap
+          // next is explicit pointer
+        CPP
+
+        explanation = "Ruby uses object references (implicit pointers), C++ uses explicit pointers. Both achieve same structure but Ruby adds GC overhead while C++ requires manual memory management."
+        
+        Visualizer.print_comparison(ruby_code, cpp_code, explanation)
+        
+        # Creation
+        Visualizer.print_section("2. Creating Linked List")
+        tracker = MemoryTracker.new
+        list = LinkedList.new
+        
+        Visualizer.print_step(1, "Adding nodes: 10, 20, 30")
+        
+        [10, 20, 30].each do |value|
+          list.append(value)
+          tracker.track_operation("Append", "Added node with value #{value}")
+        end
+        
+        puts "\n" + list.visualize
+        
+        puts "\n📦 Memory Layout:"
+        current = list.head
+        index = 0
+        while current
+          puts "  Node #{index}:"
+          puts "    Address: 0x#{current.object_id.to_s(16)}"
+          puts "    Data: #{current.data}"
+          puts "    Next: #{current.next ? "0x#{current.next.object_id.to_s(16)}" : "nil"}"
+          current = current.next
+          index += 1
+        end
+        
+        puts "\n🔍 Ruby Internals:"
+        puts "  - Each Node is a Ruby object (heap allocated)"
+        puts "  - @next is object reference (managed by GC)"
+        puts "  - No manual memory management needed"
+        puts "  - Overhead: object header + reference tracking"
+        
+        puts "\n🔍 C++ Internals:"
+        puts "  - Each Node allocated with 'new'"
+        puts "  - next is raw pointer (8 bytes on 64-bit)"
+        puts "  - Must manually delete nodes"
+        puts "  - No overhead beyond struct size"
+        
+        # Traversal
+        Visualizer.print_section("3. Traversal")
+        Visualizer.print_step(2, "Traversing to find value 20")
+        
+        puts "\nProcess:"
+        current = list.head
+        position = 0
+        while current
+          if current.data == 20
+            puts "  Position #{position}: [#{current.data}] ← FOUND!".colorize(:green)
+          else
+            puts "  Position #{position}: [#{current.data}]"
+          end
+          current = current.next
+          position += 1
+        end
+        
+        Comparator.compare_complexity(
+          "Linked List Traversal",
+          "O(n) - must follow references",
+          "O(n) - must follow pointers",
+          "Both require sequential access. No random access like arrays. Cache performance worse due to non-contiguous memory."
+        )
+        
+        # Insertion
+        Visualizer.print_section("4. Insertion at Beginning")
+        Visualizer.print_step(3, "Inserting 5 at head")
+        
+        puts "\nBefore: " + list.visualize
+        
+        new_node = Node.new(5)
+        new_node.next = list.head
+        list.instance_variable_set(:@head, new_node)
+        tracker.track_operation("Insert", "Inserted 5 at head")
+        
+        puts "After:  " + list.visualize
+        
+        puts "\n🔄 Ruby Process:"
+        puts "  1. Create new Node object (GC manages)"
+        puts "  2. Set new_node.next = current head"
+        puts "  3. Update head reference"
+        puts "  4. O(1) operation"
+        
+        puts "\n🔄 C++ Process:"
+        puts "  1. Allocate: Node* new_node = new Node(5)"
+        puts "  2. Set: new_node->next = head"
+        puts "  3. Update: head = new_node"
+        puts "  4. O(1) operation"
+        
+        # Memory comparison
+        Visualizer.print_section("5. Memory Comparison")
+        
+        puts "\n📊 Array vs Linked List:"
+        puts "\nArray:"
+        puts "  ✓ Contiguous memory (better cache)"
+        puts "  ✓ O(1) random access"
+        puts "  ✗ O(n) insertion/deletion (middle)"
+        puts "  ✗ Fixed size (or expensive resize)"
+        
+        puts "\nLinked List:"
+        puts "  ✓ O(1) insertion/deletion (at known position)"
+        puts "  ✓ Dynamic size (no resize needed)"
+        puts "  ✗ O(n) random access"
+        puts "  ✗ Poor cache locality"
+        puts "  ✗ Extra memory for pointers/references"
+        
+        tracker.print_summary
+        
+        puts "\n\n🎯 Key Takeaways:".colorize(:green).bold
+        puts "  1. Linked lists trade random access for efficient insertion/deletion"
+        puts "  2. Ruby's GC simplifies memory management vs C++ manual management"
+        puts "  3. Non-contiguous memory means poor cache performance"
+        puts "  4. Each node has pointer/reference overhead"
+        puts "  5. Best for frequent insertions/deletions, not random access"
+      end
+    end
+  end
+end

data/lib/dsa_visualizer/data_structures/priority_queue.rb

@@ -0,0 +1,11 @@
+module DSAVisualizer
+  module DataStructures
+    class PriorityQueue
+      def self.learn
+        Visualizer.print_header("PRIORITY QUEUE - Heap-Based Queue")
+        puts "\n📚 Coming soon: Priority-based dequeue"
+        puts "Topics: Min/max heap implementation, applications in scheduling"
+      end
+    end
+  end
+end

data/lib/dsa_visualizer/data_structures/queue.rb

@@ -0,0 +1,110 @@
+module DSAVisualizer
+  module DataStructures
+    class Queue
+      def initialize
+        @items = []
+      end
+
+      def enqueue(item)
+        @items.push(item)
+      end
+
+      def dequeue
+        @items.shift
+      end
+
+      def front
+        @items.first
+      end
+
+      def empty?
+        @items.empty?
+      end
+
+      def size
+        @items.size
+      end
+
+      def visualize
+        return "Empty queue" if @items.empty?
+        
+        result = "\nFRONT → "
+        @items.each_with_index do |item, idx|
+          result += "[ #{item} ]"
+          result += " → " unless idx == @items.size - 1
+        end
+        result += " ← REAR"
+        result
+      end
+
+      def self.learn
+        demo
+      end
+      
+      def self.demo
+        Visualizer.print_header("QUEUE - Core Level Visualization")
+        
+        Visualizer.print_section("1. Queue Concept (FIFO)")
+        puts "\nFirst In, First Out - like a line at a store"
+        puts "Operations: enqueue (add at rear), dequeue (remove from front)"
+        
+        Visualizer.print_section("2. Implementation Comparison")
+        
+        ruby_code = <<~RUBY
+          class Queue
+            def initialize
+              @items = []
+            end
+            
+            def enqueue(item)
+              @items.push(item)  # O(1)
+            end
+            
+            def dequeue
+              @items.shift  # O(n) - shifts all elements!
+            end
+          end
+        RUBY
+
+        cpp_code = <<~CPP
+          #include <queue>
+          std::queue<int> q;
+          
+          q.push(10);   // O(1)
+          q.pop();      // O(1)
+          
+          // Internally uses deque (double-ended queue)
+          // Efficient operations at both ends
+        CPP
+
+        explanation = "Ruby's Array.shift is O(n) because it shifts all elements. C++'s std::queue uses deque internally for O(1) operations at both ends. For better Ruby performance, use a circular buffer or linked list."
+        
+        Visualizer.print_comparison(ruby_code, cpp_code, explanation)
+        
+        tracker = MemoryTracker.new
+        queue = Queue.new
+        
+        Visualizer.print_step(1, "Enqueuing: 10, 20, 30")
+        [10, 20, 30].each do |val|
+          queue.enqueue(val)
+          tracker.track_operation("Enqueue", "Added #{val}")
+          puts queue.visualize
+        end
+        
+        Visualizer.print_step(2, "Dequeuing")
+        dequeued = queue.dequeue
+        tracker.track_operation("Dequeue", "Removed #{dequeued}")
+        puts "\nRemoved: #{dequeued}".colorize(:red)
+        puts queue.visualize
+        
+        tracker.print_summary
+        
+        puts "\n\n🎯 Key Takeaways:".colorize(:green).bold
+        puts "  1. Queue is FIFO - First In, First Out"
+        puts "  2. Ruby Array.shift is O(n) - inefficient for large queues"
+        puts "  3. C++ std::queue uses deque for O(1) operations"
+        puts "  4. Use cases: task scheduling, BFS, buffering"
+      end
+    end
+  end
+end