dsa_visualizer 0.1.1 → 0.1.2

data/lib/dsa_visualizer/data_structures/heap.rb

@@ -3,14 +3,337 @@ module DSAVisualizer
     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"
+        
+        puts "\n📖 CONCEPT:"
+        puts "A Min Heap is a complete binary tree where:"
+        puts "• Parent is always smaller than its children"
+        puts "• Root contains the minimum element"
+        puts "• Implemented using array for efficiency"
+        puts "• Used in priority queues, heap sort, and graph algorithms"
+        
+        puts "\n⏱️  TIME COMPLEXITY:"
+        puts "• Insert: O(log n)"
+        puts "• Extract Min: O(log n)"
+        puts "• Get Min: O(1)"
+        puts "• Build Heap: O(n)"
+        
+        puts "\n💾 SPACE COMPLEXITY: O(n)"
+        
+        demonstrate_min_heap
+        demonstrate_operations
+        show_array_representation
+        show_ruby_vs_cpp
+        show_practice_problems
       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)"
+        
+        puts "\n📖 CONCEPT:"
+        puts "A Max Heap is a complete binary tree where:"
+        puts "• Parent is always larger than its children"
+        puts "• Root contains the maximum element"
+        puts "• Same structure as min heap, opposite ordering"
+        puts "• Used in heap sort and finding kth largest element"
+        
+        puts "\n⏱️  TIME COMPLEXITY:"
+        puts "• Insert: O(log n)"
+        puts "• Extract Max: O(log n)"
+        puts "• Get Max: O(1)"
+        puts "• Build Heap: O(n)"
+        
+        puts "\n💾 SPACE COMPLEXITY: O(n)"
+        
+        demonstrate_max_heap
+      end
+
+      def self.demonstrate_min_heap
+        puts "\n" + "="*60
+        puts "DEMONSTRATION: Min Heap Operations"
+        puts "="*60
+        
+        heap = MinHeapImplementation.new
+        values = [10, 20, 5, 30, 15, 3]
+        
+        puts "\nInserting: #{values.join(', ')}"
+        values.each do |val|
+          heap.insert(val)
+          puts "Inserted #{val}, Min: #{heap.peek}"
+        end
+        
+        puts "\n📊 Heap Structure:"
+        puts "        3"
+        puts "       / \\"
+        puts "      15  5"
+        puts "     / \\  /"
+        puts "    30 20 10"
+        
+        puts "\nArray representation: #{heap.to_a.inspect}"
+      end
+
+      def self.demonstrate_max_heap
+        puts "\n" + "="*60
+        puts "DEMONSTRATION: Max Heap Operations"
+        puts "="*60
+        
+        heap = MaxHeapImplementation.new
+        values = [10, 20, 5, 30, 15, 3]
+        
+        puts "\nInserting: #{values.join(', ')}"
+        values.each { |val| heap.insert(val) }
+        
+        puts "\n📊 Heap Structure:"
+        puts "        30"
+        puts "       /  \\"
+        puts "      20   10"
+        puts "     / \\   /"
+        puts "    15  5  3"
+        
+        puts "\nExtracting max elements:"
+        3.times { puts "Extracted: #{heap.extract_max}" }
+      end
+
+      def self.demonstrate_operations
+        puts "\n" + "="*60
+        puts "MIN HEAP OPERATIONS"
+        puts "="*60
+        
+        heap = MinHeapImplementation.new
+        [10, 20, 5, 30, 15].each { |v| heap.insert(v) }
+        
+        puts "\n1️⃣  PEEK (Get Min):"
+        puts "Minimum: #{heap.peek}"
+        
+        puts "\n2️⃣  EXTRACT MIN:"
+        puts "Extracted: #{heap.extract_min}"
+        puts "New minimum: #{heap.peek}"
+        
+        puts "\n3️⃣  HEAP SORT:"
+        sorted = []
+        sorted << heap.extract_min until heap.empty?
+        puts "Sorted: #{sorted.join(', ')}"
+      end
+
+      def self.show_array_representation
+        puts "\n" + "="*60
+        puts "ARRAY REPRESENTATION"
+        puts "="*60
+        
+        puts "\nFor node at index i:"
+        puts "• Left child: 2*i + 1"
+        puts "• Right child: 2*i + 2"
+        puts "• Parent: (i-1)/2"
+        
+        puts "\nExample: [3, 15, 5, 30, 20, 10]"
+        puts "Index:    0   1  2   3   4   5"
+        puts ""
+        puts "Node 3 (index 0): children at 1 and 2 → 15, 5"
+        puts "Node 15 (index 1): children at 3 and 4 → 30, 20"
+        puts "Node 30 (index 3): parent at (3-1)/2 = 1 → 15"
+      end
+
+      def self.show_ruby_vs_cpp
+        puts "\n" + "="*60
+        puts "RUBY vs C++ IMPLEMENTATION"
+        puts "="*60
+        
+        puts "\n🔴 RUBY:"
+        puts <<~RUBY
+          class MinHeap
+            def initialize
+              @heap = []
+            end
+            
+            def insert(val)
+              @heap << val
+              heapify_up(@heap.size - 1)
+            end
+            
+            def extract_min
+              return nil if @heap.empty?
+              min = @heap[0]
+              @heap[0] = @heap.pop
+              heapify_down(0) unless @heap.empty?
+              min
+            end
+            
+            def heapify_up(index)
+              parent = (index - 1) / 2
+              if parent >= 0 && @heap[index] < @heap[parent]
+                @heap[index], @heap[parent] = @heap[parent], @heap[index]
+                heapify_up(parent)
+              end
+            end
+          end
+        RUBY
+        
+        puts "\n🔵 C++:"
+        puts <<~CPP
+          #include <vector>
+          
+          class MinHeap {
+              std::vector<int> heap;
+          public:
+              void insert(int val) {
+                  heap.push_back(val);
+                  heapifyUp(heap.size() - 1);
+              }
+              
+              int extractMin() {
+                  int min = heap[0];
+                  heap[0] = heap.back();
+                  heap.pop_back();
+                  heapifyDown(0);
+                  return min;
+              }
+              
+              void heapifyUp(int index) {
+                  int parent = (index - 1) / 2;
+                  if (parent >= 0 && heap[index] < heap[parent]) {
+                      swap(heap[index], heap[parent]);
+                      heapifyUp(parent);
+                  }
+              }
+          };
+        CPP
+      end
+
+      def self.show_practice_problems
+        puts "\n" + "="*60
+        puts "PRACTICE PROBLEMS"
+        puts "="*60
+        
+        problems = [
+          "1. Kth largest element in array",
+          "2. Merge K sorted lists",
+          "3. Find median from data stream",
+          "4. Top K frequent elements",
+          "5. Sort nearly sorted array",
+          "6. Connect n ropes with minimum cost",
+          "7. K closest points to origin",
+          "8. Reorganize string (no adjacent duplicates)"
+        ]
+        
+        problems.each { |p| puts p }
+        
+        puts "\n💡 TIP: Use max heap for kth smallest, min heap for kth largest!"
+        puts "💡 TIP: Building heap from array is O(n), not O(n log n)!"
+      end
+
+      class MinHeapImplementation
+        def initialize
+          @heap = []
+        end
+        
+        def insert(val)
+          @heap << val
+          heapify_up(@heap.size - 1)
+        end
+        
+        def extract_min
+          return nil if @heap.empty?
+          
+          min = @heap[0]
+          @heap[0] = @heap.pop
+          heapify_down(0) unless @heap.empty?
+          min
+        end
+        
+        def peek
+          @heap[0]
+        end
+        
+        def empty?
+          @heap.empty?
+        end
+        
+        def size
+          @heap.size
+        end
+        
+        def to_a
+          @heap.dup
+        end
+        
+        private
+        
+        def heapify_up(index)
+          return if index == 0
+          
+          parent = (index - 1) / 2
+          if @heap[index] < @heap[parent]
+            @heap[index], @heap[parent] = @heap[parent], @heap[index]
+            heapify_up(parent)
+          end
+        end
+        
+        def heapify_down(index)
+          left = 2 * index + 1
+          right = 2 * index + 2
+          smallest = index
+          
+          smallest = left if left < @heap.size && @heap[left] < @heap[smallest]
+          smallest = right if right < @heap.size && @heap[right] < @heap[smallest]
+          
+          if smallest != index
+            @heap[index], @heap[smallest] = @heap[smallest], @heap[index]
+            heapify_down(smallest)
+          end
+        end
+      end
+
+      class MaxHeapImplementation
+        def initialize
+          @heap = []
+        end
+        
+        def insert(val)
+          @heap << val
+          heapify_up(@heap.size - 1)
+        end
+        
+        def extract_max
+          return nil if @heap.empty?
+          
+          max = @heap[0]
+          @heap[0] = @heap.pop
+          heapify_down(0) unless @heap.empty?
+          max
+        end
+        
+        def peek
+          @heap[0]
+        end
+        
+        def empty?
+          @heap.empty?
+        end
+        
+        private
+        
+        def heapify_up(index)
+          return if index == 0
+          
+          parent = (index - 1) / 2
+          if @heap[index] > @heap[parent]
+            @heap[index], @heap[parent] = @heap[parent], @heap[index]
+            heapify_up(parent)
+          end
+        end
+        
+        def heapify_down(index)
+          left = 2 * index + 1
+          right = 2 * index + 2
+          largest = index
+          
+          largest = left if left < @heap.size && @heap[left] > @heap[largest]
+          largest = right if right < @heap.size && @heap[right] > @heap[largest]
+          
+          if largest != index
+            @heap[index], @heap[largest] = @heap[largest], @heap[index]
+            heapify_down(largest)
+          end
+        end
       end
     end
   end

data/lib/dsa_visualizer/data_structures/priority_queue.rb

@@ -3,8 +3,220 @@ module DSAVisualizer
     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"
+        
+        puts "\n📖 CONCEPT:"
+        puts "A Priority Queue is an abstract data type where:"
+        puts "• Each element has a priority"
+        puts "• Higher priority elements are dequeued first"
+        puts "• Typically implemented using heaps"
+        puts "• Used in scheduling, graph algorithms (Dijkstra, Prim)"
+        
+        puts "\n⏱️  TIME COMPLEXITY:"
+        puts "• Insert: O(log n)"
+        puts "• Extract Max/Min: O(log n)"
+        puts "• Peek: O(1)"
+        puts "• Build: O(n)"
+        
+        puts "\n💾 SPACE COMPLEXITY: O(n)"
+        
+        demonstrate_priority_queue
+        demonstrate_applications
+        show_ruby_vs_cpp
+        show_practice_problems
+      end
+
+      def self.demonstrate_priority_queue
+        puts "\n" + "="*60
+        puts "DEMONSTRATION: Priority Queue Operations"
+        puts "="*60
+        
+        pq = PriorityQueueImplementation.new
+        
+        puts "\nInserting tasks with priorities:"
+        tasks = [
+          { task: "Email", priority: 2 },
+          { task: "Meeting", priority: 5 },
+          { task: "Coffee", priority: 1 },
+          { task: "Deadline", priority: 10 },
+          { task: "Lunch", priority: 3 }
+        ]
+        
+        tasks.each do |t|
+          pq.insert(t[:task], t[:priority])
+          puts "Added: #{t[:task]} (priority: #{t[:priority]})"
+        end
+        
+        puts "\n📊 Processing by priority (highest first):"
+        until pq.empty?
+          task, priority = pq.extract_max
+          puts "Processing: #{task} (priority: #{priority})"
+        end
+      end
+
+      def self.demonstrate_applications
+        puts "\n" + "="*60
+        puts "REAL-WORLD APPLICATIONS"
+        puts "="*60
+        
+        puts "\n1️⃣  CPU SCHEDULING:"
+        puts "Process with highest priority gets CPU time first"
+        
+        puts "\n2️⃣  DIJKSTRA'S ALGORITHM:"
+        puts "Always process vertex with minimum distance"
+        
+        puts "\n3️⃣  HUFFMAN CODING:"
+        puts "Build tree by merging nodes with lowest frequency"
+        
+        puts "\n4️⃣  EVENT-DRIVEN SIMULATION:"
+        puts "Process events in chronological order"
+        
+        puts "\n5️⃣  LOAD BALANCING:"
+        puts "Assign tasks to least loaded server"
+        
+        puts "\n6️⃣  A* PATHFINDING:"
+        puts "Explore nodes with best estimated cost first"
+      end
+
+      def self.show_ruby_vs_cpp
+        puts "\n" + "="*60
+        puts "RUBY vs C++ IMPLEMENTATION"
+        puts "="*60
+        
+        puts "\n🔴 RUBY:"
+        puts <<~RUBY
+          class PriorityQueue
+            def initialize
+              @heap = []
+            end
+            
+            def insert(item, priority)
+              @heap << [item, priority]
+              heapify_up(@heap.size - 1)
+            end
+            
+            def extract_max
+              return nil if @heap.empty?
+              max = @heap[0]
+              @heap[0] = @heap.pop
+              heapify_down(0) unless @heap.empty?
+              max
+            end
+            
+            def heapify_up(index)
+              parent = (index - 1) / 2
+              if parent >= 0 && @heap[index][1] > @heap[parent][1]
+                @heap[index], @heap[parent] = @heap[parent], @heap[index]
+                heapify_up(parent)
+              end
+            end
+          end
+        RUBY
+        
+        puts "\n🔵 C++:"
+        puts <<~CPP
+          #include <queue>
+          #include <vector>
+          
+          // Using STL priority_queue (max heap by default)
+          std::priority_queue<int> pq;
+          pq.push(10);
+          pq.push(30);
+          pq.push(20);
+          int max = pq.top();  // 30
+          pq.pop();
+          
+          // Min heap version
+          std::priority_queue<int, std::vector<int>, std::greater<int>> minPQ;
+          
+          // Custom comparator
+          struct Task {
+              string name;
+              int priority;
+          };
+          
+          auto cmp = [](Task a, Task b) { return a.priority < b.priority; };
+          std::priority_queue<Task, std::vector<Task>, decltype(cmp)> taskPQ(cmp);
+        CPP
+      end
+
+      def self.show_practice_problems
+        puts "\n" + "="*60
+        puts "PRACTICE PROBLEMS"
+        puts "="*60
+        
+        problems = [
+          "1. Kth largest element in stream",
+          "2. Merge K sorted arrays",
+          "3. Find median in data stream",
+          "4. Task scheduler with cooldown",
+          "5. Meeting rooms II (min rooms needed)",
+          "6. Top K frequent words",
+          "7. Reorganize string",
+          "8. Minimum cost to connect sticks"
+        ]
+        
+        problems.each { |p| puts p }
+        
+        puts "\n💡 TIP: Use min heap when you need smallest, max heap for largest!"
+        puts "💡 TIP: Priority queue is perfect for 'Kth largest/smallest' problems"
+      end
+
+      class PriorityQueueImplementation
+        def initialize
+          @heap = []  # Array of [item, priority] pairs
+        end
+        
+        def insert(item, priority)
+          @heap << [item, priority]
+          heapify_up(@heap.size - 1)
+        end
+        
+        def extract_max
+          return nil if @heap.empty?
+          
+          max = @heap[0]
+          @heap[0] = @heap.pop
+          heapify_down(0) unless @heap.empty?
+          max
+        end
+        
+        def peek
+          @heap[0]
+        end
+        
+        def empty?
+          @heap.empty?
+        end
+        
+        def size
+          @heap.size
+        end
+        
+        private
+        
+        def heapify_up(index)
+          return if index == 0
+          
+          parent = (index - 1) / 2
+          if @heap[index][1] > @heap[parent][1]
+            @heap[index], @heap[parent] = @heap[parent], @heap[index]
+            heapify_up(parent)
+          end
+        end
+        
+        def heapify_down(index)
+          left = 2 * index + 1
+          right = 2 * index + 2
+          largest = index
+          
+          largest = left if left < @heap.size && @heap[left][1] > @heap[largest][1]
+          largest = right if right < @heap.size && @heap[right][1] > @heap[largest][1]
+          
+          if largest != index
+            @heap[index], @heap[largest] = @heap[largest], @heap[index]
+            heapify_down(largest)
+          end
+        end
       end
     end
   end