dsa_visualizer 0.1.1 → 0.1.2

data/lib/dsa_visualizer/data_structures/trie.rb

@@ -1,10 +1,269 @@
 module DSAVisualizer
   module DataStructures
     class Trie
+      class TrieNode
+        attr_accessor :children, :is_end_of_word
+        
+        def initialize
+          @children = {}
+          @is_end_of_word = false
+        end
+      end
+
       def self.learn
         Visualizer.print_header("TRIE - Prefix Tree")
-        puts "\n📚 Coming soon: String storage and search"
-        puts "Topics: Insert, search, prefix matching, autocomplete"
+        
+        puts "\n📖 CONCEPT:"
+        puts "A Trie (Prefix Tree) is a tree-like data structure for storing strings:"
+        puts "• Each node represents a character"
+        puts "• Root represents empty string"
+        puts "• Path from root to node = prefix"
+        puts "• Efficient for prefix-based operations"
+        
+        puts "\n⏱️  TIME COMPLEXITY:"
+        puts "• Insert: O(m) where m = word length"
+        puts "• Search: O(m)"
+        puts "• Prefix search: O(m)"
+        puts "• Delete: O(m)"
+        
+        puts "\n💾 SPACE COMPLEXITY: O(ALPHABET_SIZE * N * M)"
+        
+        demonstrate_trie
+        demonstrate_operations
+        show_ruby_vs_cpp
+        show_practice_problems
+      end
+
+      def self.demonstrate_trie
+        puts "\n" + "="*60
+        puts "DEMONSTRATION: Building a Trie"
+        puts "="*60
+        
+        trie = TrieImplementation.new
+        words = ["cat", "car", "card", "care", "dog", "dodge"]
+        
+        puts "\nInserting words: #{words.join(', ')}"
+        words.each { |word| trie.insert(word) }
+        
+        puts "\n📊 Trie Structure:"
+        puts "        root"
+        puts "       /    \\"
+        puts "      c      d"
+        puts "      |      |"
+        puts "      a      o"
+        puts "     / \\     |"
+        puts "    t   r    g"
+        puts "        |\\   |"
+        puts "        d e  e"
+        puts "        |    |"
+        puts "        e    (dodge)"
+        
+        puts "\n🔍 Searching:"
+        ["cat", "can", "card"].each do |word|
+          result = trie.search(word)
+          puts "Search '#{word}': #{result ? '✓ Found' : '✗ Not found'}"
+        end
+      end
+
+      def self.demonstrate_operations
+        puts "\n" + "="*60
+        puts "TRIE OPERATIONS"
+        puts "="*60
+        
+        trie = TrieImplementation.new
+        ["apple", "app", "application", "apply"].each { |w| trie.insert(w) }
+        
+        puts "\n1️⃣  PREFIX SEARCH:"
+        prefix = "app"
+        words = trie.words_with_prefix(prefix)
+        puts "Words starting with '#{prefix}': #{words.join(', ')}"
+        
+        puts "\n2️⃣  AUTOCOMPLETE:"
+        puts "Type 'appl'..."
+        suggestions = trie.words_with_prefix("appl")
+        puts "Suggestions: #{suggestions.join(', ')}"
+        
+        puts "\n3️⃣  COUNT WORDS:"
+        puts "Total words: #{trie.count_words}"
+        
+        puts "\n4️⃣  LONGEST PREFIX:"
+        puts "Longest common prefix: '#{trie.longest_common_prefix}'"
+      end
+
+      def self.show_ruby_vs_cpp
+        puts "\n" + "="*60
+        puts "RUBY vs C++ IMPLEMENTATION"
+        puts "="*60
+        
+        puts "\n🔴 RUBY:"
+        puts <<~RUBY
+          class TrieNode
+            attr_accessor :children, :is_end_of_word
+            def initialize
+              @children = {}
+              @is_end_of_word = false
+            end
+          end
+          
+          class Trie
+            def initialize
+              @root = TrieNode.new
+            end
+            
+            def insert(word)
+              node = @root
+              word.each_char do |char|
+                node.children[char] ||= TrieNode.new
+                node = node.children[char]
+              end
+              node.is_end_of_word = true
+            end
+            
+            def search(word)
+              node = @root
+              word.each_char do |char|
+                return false unless node.children[char]
+                node = node.children[char]
+              end
+              node.is_end_of_word
+            end
+          end
+        RUBY
+        
+        puts "\n🔵 C++:"
+        puts <<~CPP
+          struct TrieNode {
+              unordered_map<char, TrieNode*> children;
+              bool isEndOfWord;
+              TrieNode() : isEndOfWord(false) {}
+          };
+          
+          class Trie {
+              TrieNode* root;
+          public:
+              Trie() { root = new TrieNode(); }
+              
+              void insert(string word) {
+                  TrieNode* node = root;
+                  for (char c : word) {
+                      if (!node->children[c])
+                          node->children[c] = new TrieNode();
+                      node = node->children[c];
+                  }
+                  node->isEndOfWord = true;
+              }
+              
+              bool search(string word) {
+                  TrieNode* node = root;
+                  for (char c : word) {
+                      if (!node->children[c]) return false;
+                      node = node->children[c];
+                  }
+                  return node->isEndOfWord;
+              }
+          };
+        CPP
+      end
+
+      def self.show_practice_problems
+        puts "\n" + "="*60
+        puts "PRACTICE PROBLEMS"
+        puts "="*60
+        
+        problems = [
+          "1. Implement autocomplete system",
+          "2. Word search in 2D grid",
+          "3. Design search autocomplete system",
+          "4. Replace words (dictionary)",
+          "5. Longest word in dictionary",
+          "6. Add and search word (with wildcards)",
+          "7. Word break problem",
+          "8. Maximum XOR of two numbers"
+        ]
+        
+        problems.each { |p| puts p }
+        
+        puts "\n💡 TIP: Trie is perfect for prefix-based searches!"
+        puts "💡 TIP: Space-time tradeoff: uses more space for faster search"
+      end
+
+      class TrieImplementation
+        def initialize
+          @root = TrieNode.new
+        end
+        
+        def insert(word)
+          node = @root
+          word.each_char do |char|
+            node.children[char] ||= TrieNode.new
+            node = node.children[char]
+          end
+          node.is_end_of_word = true
+        end
+        
+        def search(word)
+          node = find_node(word)
+          node && node.is_end_of_word
+        end
+        
+        def starts_with(prefix)
+          !find_node(prefix).nil?
+        end
+        
+        def words_with_prefix(prefix)
+          node = find_node(prefix)
+          return [] unless node
+          
+          words = []
+          collect_words(node, prefix, words)
+          words
+        end
+        
+        def count_words
+          count_words_recursive(@root)
+        end
+        
+        def longest_common_prefix
+          return "" if @root.children.empty?
+          
+          prefix = ""
+          node = @root
+          
+          while node.children.size == 1 && !node.is_end_of_word
+            char = node.children.keys.first
+            prefix += char
+            node = node.children[char]
+          end
+          
+          prefix
+        end
+        
+        private
+        
+        def find_node(word)
+          node = @root
+          word.each_char do |char|
+            return nil unless node.children[char]
+            node = node.children[char]
+          end
+          node
+        end
+        
+        def collect_words(node, prefix, words)
+          words << prefix if node.is_end_of_word
+          
+          node.children.each do |char, child_node|
+            collect_words(child_node, prefix + char, words)
+          end
+        end
+        
+        def count_words_recursive(node)
+          count = node.is_end_of_word ? 1 : 0
+          node.children.each_value do |child|
+            count += count_words_recursive(child)
+          end
+          count
+        end
       end
     end
   end

data/lib/dsa_visualizer/data_structures/union_find.rb

@@ -3,8 +3,213 @@ module DSAVisualizer
     class UnionFind
       def self.learn
         Visualizer.print_header("UNION-FIND (Disjoint Set)")
-        puts "\n📚 Coming soon: Connected components"
-        puts "Topics: Union by rank, path compression, applications in graphs"
+        
+        puts "\n📖 CONCEPT:"
+        puts "Union-Find (Disjoint Set Union) tracks connected components:"
+        puts "• Find: Determine which set an element belongs to"
+        puts "• Union: Merge two sets together"
+        puts "• Path compression: Flatten tree during find"
+        puts "• Union by rank: Attach smaller tree to larger"
+        
+        puts "\n⏱️  TIME COMPLEXITY:"
+        puts "• Find: O(α(n)) ≈ O(1) amortized"
+        puts "• Union: O(α(n)) ≈ O(1) amortized"
+        puts "• α(n) is inverse Ackermann function (very slow growing)"
+        
+        puts "\n💾 SPACE COMPLEXITY: O(n)"
+        
+        demonstrate_union_find
+        demonstrate_operations
+        show_ruby_vs_cpp
+        show_practice_problems
+      end
+
+      def self.demonstrate_union_find
+        puts "\n" + "="*60
+        puts "DEMONSTRATION: Union-Find Operations"
+        puts "="*60
+        
+        uf = UnionFindImplementation.new(10)
+        
+        puts "\nInitial state: Each element is its own set"
+        puts "Sets: {0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}"
+        
+        puts "\nPerforming unions:"
+        unions = [[0, 1], [2, 3], [4, 5], [6, 7], [0, 2], [4, 6]]
+        unions.each do |a, b|
+          uf.union(a, b)
+          puts "Union(#{a}, #{b})"
+        end
+        
+        puts "\n📊 Current sets:"
+        puts "Set 1: {0, 1, 2, 3}"
+        puts "Set 2: {4, 5, 6, 7}"
+        puts "Set 3: {8}"
+        puts "Set 4: {9}"
+        
+        puts "\nNumber of components: #{uf.count}"
+      end
+
+      def self.demonstrate_operations
+        puts "\n" + "="*60
+        puts "UNION-FIND OPERATIONS"
+        puts "="*60
+        
+        uf = UnionFindImplementation.new(6)
+        
+        puts "\n1️⃣  FIND OPERATION:"
+        puts "Find(0): #{uf.find(0)}"
+        puts "Find(3): #{uf.find(3)}"
+        
+        puts "\n2️⃣  UNION OPERATION:"
+        uf.union(0, 1)
+        uf.union(2, 3)
+        puts "After Union(0,1) and Union(2,3)"
+        puts "Connected(0, 1): #{uf.connected?(0, 1)}"
+        puts "Connected(0, 2): #{uf.connected?(0, 2)}"
+        
+        puts "\n3️⃣  CHECK CONNECTIVITY:"
+        uf.union(1, 2)
+        puts "After Union(1,2)"
+        puts "Connected(0, 3): #{uf.connected?(0, 3)}"
+        
+        puts "\n4️⃣  COUNT COMPONENTS:"
+        puts "Number of disjoint sets: #{uf.count}"
+      end
+
+      def self.show_ruby_vs_cpp
+        puts "\n" + "="*60
+        puts "RUBY vs C++ IMPLEMENTATION"
+        puts "="*60
+        
+        puts "\n🔴 RUBY:"
+        puts <<~RUBY
+          class UnionFind
+            def initialize(n)
+              @parent = (0...n).to_a
+              @rank = Array.new(n, 0)
+            end
+            
+            def find(x)
+              if @parent[x] != x
+                @parent[x] = find(@parent[x])  # Path compression
+              end
+              @parent[x]
+            end
+            
+            def union(x, y)
+              root_x = find(x)
+              root_y = find(y)
+              return if root_x == root_y
+              
+              # Union by rank
+              if @rank[root_x] < @rank[root_y]
+                @parent[root_x] = root_y
+              elsif @rank[root_x] > @rank[root_y]
+                @parent[root_y] = root_x
+              else
+                @parent[root_y] = root_x
+                @rank[root_x] += 1
+              end
+            end
+          end
+        RUBY
+        
+        puts "\n🔵 C++:"
+        puts <<~CPP
+          class UnionFind {
+              vector<int> parent, rank;
+          public:
+              UnionFind(int n) : parent(n), rank(n, 0) {
+                  iota(parent.begin(), parent.end(), 0);
+              }
+              
+              int find(int x) {
+                  if (parent[x] != x)
+                      parent[x] = find(parent[x]);  // Path compression
+                  return parent[x];
+              }
+              
+              void unite(int x, int y) {
+                  int rootX = find(x);
+                  int rootY = find(y);
+                  if (rootX == rootY) return;
+                  
+                  // Union by rank
+                  if (rank[rootX] < rank[rootY]) {
+                      parent[rootX] = rootY;
+                  } else if (rank[rootX] > rank[rootY]) {
+                      parent[rootY] = rootX;
+                  } else {
+                      parent[rootY] = rootX;
+                      rank[rootX]++;
+                  }
+              }
+          };
+        CPP
+      end
+
+      def self.show_practice_problems
+        puts "\n" + "="*60
+        puts "PRACTICE PROBLEMS"
+        puts "="*60
+        
+        problems = [
+          "1. Number of connected components in graph",
+          "2. Detect cycle in undirected graph",
+          "3. Friend circles / Number of provinces",
+          "4. Redundant connection",
+          "5. Accounts merge",
+          "6. Most stones removed",
+          "7. Satisfiability of equality equations",
+          "8. Smallest string with swaps"
+        ]
+        
+        problems.each { |p| puts p }
+        
+        puts "\n💡 TIP: Union-Find is perfect for dynamic connectivity problems!"
+        puts "💡 TIP: Use for Kruskal's MST algorithm"
+      end
+
+      class UnionFindImplementation
+        def initialize(n)
+          @parent = (0...n).to_a
+          @rank = Array.new(n, 0)
+          @count = n
+        end
+        
+        def find(x)
+          if @parent[x] != x
+            @parent[x] = find(@parent[x])  # Path compression
+          end
+          @parent[x]
+        end
+        
+        def union(x, y)
+          root_x = find(x)
+          root_y = find(y)
+          return if root_x == root_y
+          
+          # Union by rank
+          if @rank[root_x] < @rank[root_y]
+            @parent[root_x] = root_y
+          elsif @rank[root_x] > @rank[root_y]
+            @parent[root_y] = root_x
+          else
+            @parent[root_y] = root_x
+            @rank[root_x] += 1
+          end
+          
+          @count -= 1
+        end
+        
+        def connected?(x, y)
+          find(x) == find(y)
+        end
+        
+        def count
+          @count
+        end
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dsa_visualizer
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - DSA Learning Team
@@ -131,10 +131,10 @@ homepage: https://github.com/Avinashkrmehta/dsa_visualizer
 licenses:
 - MIT
 metadata:
-  bug_tracker_uri: https://github.com/yourusername/dsa_visualizer/issues
-  changelog_uri: https://github.com/yourusername/dsa_visualizer/blob/main/CHANGELOG.md
-  documentation_uri: https://github.com/yourusername/dsa_visualizer/blob/main/README.md
-  source_code_uri: https://github.com/yourusername/dsa_visualizer
+  bug_tracker_uri: https://github.com/Avinashkrmehta/dsa_visualizer/issues
+  changelog_uri: https://github.com/Avinashkrmehta/dsa_visualizer/blob/main/CHANGELOG.md
+  documentation_uri: https://github.com/Avinashkrmehta/dsa_visualizer/blob/main/README.md
+  source_code_uri: https://github.com/Avinashkrmehta/dsa_visualizer
 post_install_message:
 rdoc_options: []
 require_paths: