dsa_visualizer 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b8e829a5b7374b3bb9f67688a3ef9a37d7f68a6ac8a4cb78fc946e0af595792c
-  data.tar.gz: e2496ae6992104e88c913baf7783b1be6c6a742d9f47d974fc4013c0532999a8
+  metadata.gz: 813e5d18b85fdd51dd758e48c77df855602225932446e34909a544c90e8609b4
+  data.tar.gz: ba55ef09dba874a9b77ee6dba7fc653da234f93c507c38bf8cf99991af476684
 SHA512:
-  metadata.gz: 62fe566b8c8ee50dbb33ce511d2e6a3aeaa06e41566975f6cdb081acd752b0e69b8fe69fe24a982715ab0694cbd141478b8cd3642e5a563f49804e0271657392
-  data.tar.gz: 7cc06f7b4ce4d8c05b909f2958d8e1e9acf219e780585fc1c379e3fe235f97b9561f8553792344af15a384f6107e264d5b2994c948ae931b6d1681a8b185167c
+  metadata.gz: 19f0790fe49b8c8166ed254e8fdfdaefee18a1c343f4d950597b3396d332950d730d7d073a493c46ebc7d0d8a9f90a19818d1b5db037e20e7fea1205784bcd31
+  data.tar.gz: d9621677e2ba21185eb87b7d3081504971ada5b413f0a3243f0a2744064ce219ec97732d0f4b279fb360fead131693273aa3f2f0943f12744cbdf07903372850

data/lib/dsa_visualizer/algorithms/graph_algorithms.rb

@@ -3,20 +3,336 @@ module DSAVisualizer
     class GraphAlgorithms
       def self.learn_bfs
         Visualizer.print_header("BREADTH-FIRST SEARCH (BFS)")
-        puts "\n📚 Coming soon: Level-order graph traversal"
-        puts "Topics: Queue-based, shortest path in unweighted graph"
+        
+        puts "\n📖 CONCEPT:"
+        puts "BFS explores graph level by level using a queue:"
+        puts "• Start from source vertex"
+        puts "• Visit all neighbors before going deeper"
+        puts "• Uses queue (FIFO) for traversal"
+        puts "• Finds shortest path in unweighted graphs"
+        
+        puts "\n⏱️  TIME COMPLEXITY: O(V + E)"
+        puts "💾 SPACE COMPLEXITY: O(V) - for queue and visited set"
+        
+        demonstrate_bfs
+        show_ruby_vs_cpp_bfs
       end
       
       def self.learn_dfs
         Visualizer.print_header("DEPTH-FIRST SEARCH (DFS)")
-        puts "\n📚 Coming soon: Deep exploration"
-        puts "Topics: Stack/recursion-based, cycle detection, topological sort"
+        
+        puts "\n📖 CONCEPT:"
+        puts "DFS explores as deep as possible before backtracking:"
+        puts "• Start from source vertex"
+        puts "• Go deep into one path before exploring others"
+        puts "• Uses stack (recursion or explicit)"
+        puts "• Used for cycle detection, topological sort"
+        
+        puts "\n⏱️  TIME COMPLEXITY: O(V + E)"
+        puts "💾 SPACE COMPLEXITY: O(V) - for recursion stack"
+        
+        demonstrate_dfs
+        show_ruby_vs_cpp_dfs
       end
       
       def self.learn_dijkstra
         Visualizer.print_header("DIJKSTRA'S ALGORITHM")
-        puts "\n📚 Coming soon: Shortest path in weighted graph"
-        puts "Topics: Priority queue, greedy approach, non-negative weights"
+        
+        puts "\n📖 CONCEPT:"
+        puts "Dijkstra finds shortest path in weighted graphs:"
+        puts "• Greedy algorithm"
+        puts "• Uses priority queue (min heap)"
+        puts "• Works only with non-negative weights"
+        puts "• Finds shortest path from source to all vertices"
+        
+        puts "\n⏱️  TIME COMPLEXITY: O((V + E) log V) with min heap"
+        puts "💾 SPACE COMPLEXITY: O(V)"
+        
+        demonstrate_dijkstra
+        show_ruby_vs_cpp_dijkstra
+      end
+
+      def self.demonstrate_bfs
+        puts "\n" + "="*60
+        puts "BFS DEMONSTRATION"
+        puts "="*60
+        
+        graph = {
+          'A' => ['B', 'C'],
+          'B' => ['D', 'E'],
+          'C' => ['F'],
+          'D' => [],
+          'E' => ['F'],
+          'F' => []
+        }
+        
+        puts "\nGraph:"
+        puts "    A"
+        puts "   / \\"
+        puts "  B   C"
+        puts " / \\   \\"
+        puts "D   E   F"
+        
+        puts "\nBFS Traversal from A:"
+        result = bfs(graph, 'A')
+        puts "Order: #{result.join(' → ')}"
+        
+        puts "\nLevel-by-level:"
+        puts "Level 0: A"
+        puts "Level 1: B, C"
+        puts "Level 2: D, E, F"
+      end
+
+      def self.demonstrate_dfs
+        puts "\n" + "="*60
+        puts "DFS DEMONSTRATION"
+        puts "="*60
+        
+        graph = {
+          'A' => ['B', 'C'],
+          'B' => ['D', 'E'],
+          'C' => ['F'],
+          'D' => [],
+          'E' => ['F'],
+          'F' => []
+        }
+        
+        puts "\nGraph:"
+        puts "    A"
+        puts "   / \\"
+        puts "  B   C"
+        puts " / \\   \\"
+        puts "D   E   F"
+        
+        puts "\nDFS Traversal from A:"
+        result = dfs(graph, 'A')
+        puts "Order: #{result.join(' → ')}"
+        
+        puts "\nPath exploration:"
+        puts "A → B → D (backtrack)"
+        puts "B → E → F (backtrack)"
+        puts "A → C → F (already visited)"
+      end
+
+      def self.demonstrate_dijkstra
+        puts "\n" + "="*60
+        puts "DIJKSTRA'S ALGORITHM DEMONSTRATION"
+        puts "="*60
+        
+        graph = {
+          'A' => [['B', 4], ['C', 2]],
+          'B' => [['D', 5]],
+          'C' => [['B', 1], ['D', 8]],
+          'D' => []
+        }
+        
+        puts "\nWeighted Graph:"
+        puts "    A"
+        puts "   /4\\2"
+        puts "  B   C"
+        puts "  |5 /8"
+        puts "   D"
+        
+        puts "\nFinding shortest paths from A:"
+        distances = dijkstra(graph, 'A')
+        distances.each do |vertex, dist|
+          puts "A → #{vertex}: #{dist}"
+        end
+      end
+
+      def self.bfs(graph, start)
+        visited = Set.new
+        queue = [start]
+        result = []
+        
+        until queue.empty?
+          vertex = queue.shift
+          next if visited.include?(vertex)
+          
+          visited.add(vertex)
+          result << vertex
+          
+          graph[vertex].each do |neighbor|
+            queue << neighbor unless visited.include?(neighbor)
+          end
+        end
+        
+        result
+      end
+
+      def self.dfs(graph, start, visited = Set.new, result = [])
+        return result if visited.include?(start)
+        
+        visited.add(start)
+        result << start
+        
+        graph[start].each do |neighbor|
+          dfs(graph, neighbor, visited, result)
+        end
+        
+        result
+      end
+
+      def self.dijkstra(graph, start)
+        distances = Hash.new(Float::INFINITY)
+        distances[start] = 0
+        pq = [[0, start]]
+        visited = Set.new
+        
+        until pq.empty?
+          dist, vertex = pq.min_by { |d, _| d }
+          pq.delete([dist, vertex])
+          
+          next if visited.include?(vertex)
+          visited.add(vertex)
+          
+          graph[vertex].each do |neighbor, weight|
+            new_dist = distances[vertex] + weight
+            if new_dist < distances[neighbor]
+              distances[neighbor] = new_dist
+              pq << [new_dist, neighbor]
+            end
+          end
+        end
+        
+        distances
+      end
+
+      def self.show_ruby_vs_cpp_bfs
+        puts "\n" + "="*60
+        puts "RUBY vs C++ - BFS"
+        puts "="*60
+        
+        puts "\n🔴 RUBY:"
+        puts <<~RUBY
+          def bfs(graph, start)
+            visited = Set.new
+            queue = [start]
+            
+            until queue.empty?
+              vertex = queue.shift
+              next if visited.include?(vertex)
+              
+              visited.add(vertex)
+              puts vertex
+              
+              graph[vertex].each do |neighbor|
+                queue << neighbor unless visited.include?(neighbor)
+              end
+            end
+          end
+        RUBY
+        
+        puts "\n🔵 C++:"
+        puts <<~CPP
+          void bfs(unordered_map<int, vector<int>>& graph, int start) {
+              unordered_set<int> visited;
+              queue<int> q;
+              q.push(start);
+              
+              while (!q.empty()) {
+                  int vertex = q.front();
+                  q.pop();
+                  
+                  if (visited.count(vertex)) continue;
+                  visited.insert(vertex);
+                  cout << vertex << endl;
+                  
+                  for (int neighbor : graph[vertex]) {
+                      if (!visited.count(neighbor))
+                          q.push(neighbor);
+                  }
+              }
+          }
+        CPP
+      end
+
+      def self.show_ruby_vs_cpp_dfs
+        puts "\n" + "="*60
+        puts "RUBY vs C++ - DFS"
+        puts "="*60
+        
+        puts "\n🔴 RUBY:"
+        puts <<~RUBY
+          def dfs(graph, vertex, visited = Set.new)
+            return if visited.include?(vertex)
+            
+            visited.add(vertex)
+            puts vertex
+            
+            graph[vertex].each do |neighbor|
+              dfs(graph, neighbor, visited)
+            end
+          end
+        RUBY
+        
+        puts "\n🔵 C++:"
+        puts <<~CPP
+          void dfs(unordered_map<int, vector<int>>& graph, 
+                   int vertex, unordered_set<int>& visited) {
+              if (visited.count(vertex)) return;
+              
+              visited.insert(vertex);
+              cout << vertex << endl;
+              
+              for (int neighbor : graph[vertex]) {
+                  dfs(graph, neighbor, visited);
+              }
+          }
+        CPP
+      end
+
+      def self.show_ruby_vs_cpp_dijkstra
+        puts "\n" + "="*60
+        puts "RUBY vs C++ - DIJKSTRA"
+        puts "="*60
+        
+        puts "\n🔴 RUBY:"
+        puts <<~RUBY
+          def dijkstra(graph, start)
+            distances = Hash.new(Float::INFINITY)
+            distances[start] = 0
+            pq = [[0, start]]
+            
+            until pq.empty?
+              dist, vertex = pq.min_by { |d, _| d }
+              pq.delete([dist, vertex])
+              
+              graph[vertex].each do |neighbor, weight|
+                new_dist = distances[vertex] + weight
+                if new_dist < distances[neighbor]
+                  distances[neighbor] = new_dist
+                  pq << [new_dist, neighbor]
+                end
+              end
+            end
+            distances
+          end
+        RUBY
+        
+        puts "\n🔵 C++:"
+        puts <<~CPP
+          map<int, int> dijkstra(map<int, vector<pair<int,int>>>& graph, int start) {
+              map<int, int> distances;
+              priority_queue<pair<int,int>, vector<pair<int,int>>, greater<>> pq;
+              pq.push({0, start});
+              distances[start] = 0;
+              
+              while (!pq.empty()) {
+                  auto [dist, vertex] = pq.top();
+                  pq.pop();
+                  
+                  for (auto [neighbor, weight] : graph[vertex]) {
+                      int newDist = distances[vertex] + weight;
+                      if (newDist < distances[neighbor]) {
+                          distances[neighbor] = newDist;
+                          pq.push({newDist, neighbor});
+                      }
+                  }
+              }
+              return distances;
+          }
+        CPP
       end
     end
   end

data/lib/dsa_visualizer/algorithms/sorting.rb

@@ -6,11 +6,115 @@ module DSAVisualizer
       end
       
       def self.learn_merge
-        puts "\n📚 Coming soon: Merge Sort - Divide and Conquer"
+        Visualizer.print_header("MERGE SORT - Divide and Conquer")
+        
+        puts "\n📖 CONCEPT:"
+        puts "Merge Sort divides array into halves, sorts them, and merges:"
+        puts "• Divide: Split array into two halves"
+        puts "• Conquer: Recursively sort both halves"
+        puts "• Combine: Merge sorted halves"
+        puts "• Stable sort, predictable performance"
+        
+        puts "\n⏱️  TIME COMPLEXITY: O(n log n) - all cases"
+        puts "💾 SPACE COMPLEXITY: O(n) - needs auxiliary array"
+        
+        demonstrate_merge_sort
       end
       
       def self.learn_quick
-        puts "\n📚 Coming soon: Quick Sort - Partition-based"
+        Visualizer.print_header("QUICK SORT - Partition-based")
+        
+        puts "\n📖 CONCEPT:"
+        puts "Quick Sort picks a pivot and partitions around it:"
+        puts "• Choose pivot element"
+        puts "• Partition: elements < pivot on left, > pivot on right"
+        puts "• Recursively sort left and right partitions"
+        puts "• In-place sorting, cache-friendly"
+        
+        puts "\n⏱️  TIME COMPLEXITY:"
+        puts "• Average: O(n log n)"
+        puts "• Worst: O(n²) - when pivot is always min/max"
+        puts "💾 SPACE COMPLEXITY: O(log n) - recursion stack"
+        
+        demonstrate_quick_sort
+      end
+      
+      def self.demonstrate_merge_sort
+        puts "\n" + "="*60
+        puts "MERGE SORT DEMONSTRATION"
+        puts "="*60
+        
+        arr = [38, 27, 43, 3, 9, 82, 10]
+        puts "\nOriginal: #{arr.inspect}"
+        
+        puts "\nDivide phase:"
+        puts "[38, 27, 43, 3, 9, 82, 10]"
+        puts "[38, 27, 43, 3] | [9, 82, 10]"
+        puts "[38, 27] [43, 3] | [9, 82] [10]"
+        puts "[38] [27] [43] [3] | [9] [82] [10]"
+        
+        puts "\nMerge phase:"
+        puts "[27, 38] [3, 43] | [9, 82] [10]"
+        puts "[3, 27, 38, 43] | [9, 10, 82]"
+        puts "[3, 9, 10, 27, 38, 43, 82]"
+        
+        sorted = merge_sort(arr.dup)
+        puts "\nSorted: #{sorted.inspect}"
+      end
+      
+      def self.demonstrate_quick_sort
+        puts "\n" + "="*60
+        puts "QUICK SORT DEMONSTRATION"
+        puts "="*60
+        
+        arr = [10, 7, 8, 9, 1, 5]
+        puts "\nOriginal: #{arr.inspect}"
+        puts "Pivot: #{arr.last} (choosing last element)"
+        
+        puts "\nPartitioning:"
+        puts "Elements < 5: [1]"
+        puts "Pivot: [5]"
+        puts "Elements > 5: [10, 7, 8, 9]"
+        
+        sorted = quick_sort(arr.dup)
+        puts "\nSorted: #{sorted.inspect}"
+      end
+      
+      def self.merge_sort(arr)
+        return arr if arr.length <= 1
+        
+        mid = arr.length / 2
+        left = merge_sort(arr[0...mid])
+        right = merge_sort(arr[mid..-1])
+        
+        merge(left, right)
+      end
+      
+      def self.merge(left, right)
+        result = []
+        i = j = 0
+        
+        while i < left.length && j < right.length
+          if left[i] <= right[j]
+            result << left[i]
+            i += 1
+          else
+            result << right[j]
+            j += 1
+          end
+        end
+        
+        result + left[i..-1] + right[j..-1]
+      end
+      
+      def self.quick_sort(arr)
+        return arr if arr.length <= 1
+        
+        pivot = arr.pop
+        left = arr.select { |x| x <= pivot }
+        right = arr.select { |x| x > pivot }
+        
+        quick_sort(left) + [pivot] + quick_sort(right)
       end
       
       def self.demo