dsa_visualizer 0.1.1 → 0.1.2

data/lib/dsa_visualizer/data_structures/doubly_linked_list.rb

@@ -1,10 +1,263 @@
 module DSAVisualizer
   module DataStructures
     class DoublyLinkedList
+      class Node
+        attr_accessor :data, :prev, :next
+        
+        def initialize(data)
+          @data = data
+          @prev = nil
+          @next = nil
+        end
+      end
+
       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"
+        
+        puts "\n📖 CONCEPT:"
+        puts "A Doubly Linked List has nodes with two pointers:"
+        puts "• next: Points to the next node"
+        puts "• prev: Points to the previous node"
+        puts "• Allows bidirectional traversal"
+        puts "• More memory overhead but more flexible than singly linked list"
+        
+        puts "\n⏱️  TIME COMPLEXITY:"
+        puts "• Access: O(n)"
+        puts "• Search: O(n)"
+        puts "• Insert at head/tail: O(1)"
+        puts "• Delete at head/tail: O(1)"
+        puts "• Insert/Delete at position: O(n)"
+        
+        puts "\n💾 SPACE COMPLEXITY: O(n) - extra pointer per node"
+        
+        demonstrate_dll
+        demonstrate_operations
+        show_ruby_vs_cpp
+        show_practice_problems
+      end
+
+      def self.demonstrate_dll
+        puts "\n" + "="*60
+        puts "DEMONSTRATION: Building a Doubly Linked List"
+        puts "="*60
+        
+        dll = DLLImplementation.new
+        
+        puts "\nInserting at tail: 10, 20, 30"
+        dll.insert_tail(10)
+        dll.insert_tail(20)
+        dll.insert_tail(30)
+        dll.display
+        
+        puts "\nInserting at head: 5"
+        dll.insert_head(5)
+        dll.display
+        
+        puts "\n📊 Structure:"
+        puts "nil ← [5] ⇄ [10] ⇄ [20] ⇄ [30] → nil"
+      end
+
+      def self.demonstrate_operations
+        puts "\n" + "="*60
+        puts "DOUBLY LINKED LIST OPERATIONS"
+        puts "="*60
+        
+        dll = DLLImplementation.new
+        [10, 20, 30, 40].each { |v| dll.insert_tail(v) }
+        
+        puts "\n1️⃣  FORWARD TRAVERSAL:"
+        dll.display
+        
+        puts "\n2️⃣  BACKWARD TRAVERSAL:"
+        dll.display_reverse
+        
+        puts "\n3️⃣  DELETE FROM HEAD:"
+        dll.delete_head
+        dll.display
+        
+        puts "\n4️⃣  DELETE FROM TAIL:"
+        dll.delete_tail
+        dll.display
+        
+        puts "\n5️⃣  SEARCH:"
+        puts "Search 30: #{dll.search(30) ? '✓ Found' : '✗ Not found'}"
+        puts "Search 99: #{dll.search(99) ? '✓ Found' : '✗ Not found'}"
+      end
+
+      def self.show_ruby_vs_cpp
+        puts "\n" + "="*60
+        puts "RUBY vs C++ IMPLEMENTATION"
+        puts "="*60
+        
+        puts "\n🔴 RUBY:"
+        puts <<~RUBY
+          class Node
+            attr_accessor :data, :prev, :next
+            def initialize(data)
+              @data = data
+              @prev = @next = nil
+            end
+          end
+          
+          class DoublyLinkedList
+            def insert_tail(data)
+              new_node = Node.new(data)
+              if @head.nil?
+                @head = @tail = new_node
+              else
+                @tail.next = new_node
+                new_node.prev = @tail
+                @tail = new_node
+              end
+            end
+            
+            def delete_head
+              return if @head.nil?
+              @head = @head.next
+              @head.prev = nil if @head
+            end
+          end
+        RUBY
+        
+        puts "\n🔵 C++:"
+        puts <<~CPP
+          struct Node {
+              int data;
+              Node* prev;
+              Node* next;
+              Node(int val) : data(val), prev(nullptr), next(nullptr) {}
+          };
+          
+          class DoublyLinkedList {
+              Node* head;
+              Node* tail;
+          public:
+              void insertTail(int data) {
+                  Node* newNode = new Node(data);
+                  if (head == nullptr) {
+                      head = tail = newNode;
+                  } else {
+                      tail->next = newNode;
+                      newNode->prev = tail;
+                      tail = newNode;
+                  }
+              }
+              
+              void deleteHead() {
+                  if (head == nullptr) return;
+                  head = head->next;
+                  if (head) head->prev = nullptr;
+              }
+          };
+        CPP
+      end
+
+      def self.show_practice_problems
+        puts "\n" + "="*60
+        puts "PRACTICE PROBLEMS"
+        puts "="*60
+        
+        problems = [
+          "1. Reverse a doubly linked list",
+          "2. Find pairs with given sum in sorted DLL",
+          "3. Remove duplicates from sorted DLL",
+          "4. Convert binary tree to DLL (in-order)",
+          "5. Clone a DLL with random pointers",
+          "6. Find triplets with given sum",
+          "7. Rotate DLL by N nodes",
+          "8. Implement LRU cache using DLL"
+        ]
+        
+        problems.each { |p| puts p }
+        
+        puts "\n💡 TIP: DLL allows O(1) deletion when node reference is given!"
+        puts "💡 TIP: Perfect for implementing LRU cache and browser history"
+      end
+
+      class DLLImplementation
+        attr_reader :head, :tail
+        
+        def initialize
+          @head = nil
+          @tail = nil
+        end
+        
+        def insert_head(data)
+          new_node = Node.new(data)
+          if @head.nil?
+            @head = @tail = new_node
+          else
+            new_node.next = @head
+            @head.prev = new_node
+            @head = new_node
+          end
+        end
+        
+        def insert_tail(data)
+          new_node = Node.new(data)
+          if @head.nil?
+            @head = @tail = new_node
+          else
+            @tail.next = new_node
+            new_node.prev = @tail
+            @tail = new_node
+          end
+        end
+        
+        def delete_head
+          return if @head.nil?
+          
+          if @head == @tail
+            @head = @tail = nil
+          else
+            @head = @head.next
+            @head.prev = nil
+          end
+        end
+        
+        def delete_tail
+          return if @tail.nil?
+          
+          if @head == @tail
+            @head = @tail = nil
+          else
+            @tail = @tail.prev
+            @tail.next = nil
+          end
+        end
+        
+        def search(data)
+          current = @head
+          while current
+            return true if current.data == data
+            current = current.next
+          end
+          false
+        end
+        
+        def display
+          return puts "List is empty" if @head.nil?
+          
+          current = @head
+          result = []
+          while current
+            result << current.data
+            current = current.next
+          end
+          puts "Forward: #{result.join(' ⇄ ')}"
+        end
+        
+        def display_reverse
+          return puts "List is empty" if @tail.nil?
+          
+          current = @tail
+          result = []
+          while current
+            result << current.data
+            current = current.prev
+          end
+          puts "Backward: #{result.join(' ⇄ ')}"
+        end
       end
     end
   end

data/lib/dsa_visualizer/data_structures/graph.rb

@@ -3,8 +3,197 @@ module DSAVisualizer
     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"
+        
+        puts "\n📖 CONCEPT:"
+        puts "A Graph is a collection of vertices (nodes) connected by edges:"
+        puts "• Directed: Edges have direction (A → B)"
+        puts "• Undirected: Edges are bidirectional (A ↔ B)"
+        puts "• Weighted: Edges have associated costs"
+        puts "• Unweighted: All edges have equal weight"
+        
+        puts "\n⏱️  TIME COMPLEXITY (Adjacency List):"
+        puts "• Add vertex: O(1)"
+        puts "• Add edge: O(1)"
+        puts "• Remove vertex: O(V + E)"
+        puts "• Remove edge: O(E)"
+        puts "• Check if edge exists: O(V)"
+        
+        puts "\n💾 SPACE COMPLEXITY:"
+        puts "• Adjacency List: O(V + E)"
+        puts "• Adjacency Matrix: O(V²)"
+        
+        demonstrate_graph
+        demonstrate_representations
+        show_ruby_vs_cpp
+        show_practice_problems
+      end
+
+      def self.demonstrate_graph
+        puts "\n" + "="*60
+        puts "DEMONSTRATION: Building a Graph"
+        puts "="*60
+        
+        graph = GraphImplementation.new
+        
+        puts "\nAdding vertices: A, B, C, D, E"
+        ['A', 'B', 'C', 'D', 'E'].each { |v| graph.add_vertex(v) }
+        
+        puts "\nAdding edges:"
+        edges = [['A', 'B'], ['A', 'C'], ['B', 'D'], ['C', 'D'], ['D', 'E']]
+        edges.each do |from, to|
+          graph.add_edge(from, to)
+          puts "#{from} → #{to}"
+        end
+        
+        puts "\n📊 Graph Structure:"
+        puts "    A"
+        puts "   / \\"
+        puts "  B   C"
+        puts "   \\ /"
+        puts "    D"
+        puts "    |"
+        puts "    E"
+        
+        graph.display
+      end
+
+      def self.demonstrate_representations
+        puts "\n" + "="*60
+        puts "GRAPH REPRESENTATIONS"
+        puts "="*60
+        
+        puts "\n1️⃣  ADJACENCY LIST:"
+        puts "Space efficient for sparse graphs"
+        puts "A: [B, C]"
+        puts "B: [D]"
+        puts "C: [D]"
+        puts "D: [E]"
+        puts "E: []"
+        
+        puts "\n2️⃣  ADJACENCY MATRIX:"
+        puts "Fast edge lookup, more space"
+        puts "    A B C D E"
+        puts "A [[0,1,1,0,0],"
+        puts "B  [0,0,0,1,0],"
+        puts "C  [0,0,0,1,0],"
+        puts "D  [0,0,0,0,1],"
+        puts "E  [0,0,0,0,0]]"
+        
+        puts "\n3️⃣  EDGE LIST:"
+        puts "Simple but less efficient"
+        puts "[(A,B), (A,C), (B,D), (C,D), (D,E)]"
+      end
+
+      def self.show_ruby_vs_cpp
+        puts "\n" + "="*60
+        puts "RUBY vs C++ IMPLEMENTATION"
+        puts "="*60
+        
+        puts "\n🔴 RUBY (Adjacency List):"
+        puts <<~RUBY
+          class Graph
+            def initialize
+              @adj_list = Hash.new { |h, k| h[k] = [] }
+            end
+            
+            def add_vertex(vertex)
+              @adj_list[vertex] ||= []
+            end
+            
+            def add_edge(from, to, directed = true)
+              @adj_list[from] << to
+              @adj_list[to] << from unless directed
+            end
+            
+            def neighbors(vertex)
+              @adj_list[vertex]
+            end
+          end
+        RUBY
+        
+        puts "\n🔵 C++ (Adjacency List):"
+        puts <<~CPP
+          class Graph {
+              unordered_map<int, vector<int>> adjList;
+          public:
+              void addVertex(int vertex) {
+                  if (adjList.find(vertex) == adjList.end())
+                      adjList[vertex] = vector<int>();
+              }
+              
+              void addEdge(int from, int to, bool directed = true) {
+                  adjList[from].push_back(to);
+                  if (!directed)
+                      adjList[to].push_back(from);
+              }
+              
+              vector<int> neighbors(int vertex) {
+                  return adjList[vertex];
+              }
+          };
+        CPP
+      end
+
+      def self.show_practice_problems
+        puts "\n" + "="*60
+        puts "PRACTICE PROBLEMS"
+        puts "="*60
+        
+        problems = [
+          "1. Clone a graph",
+          "2. Number of islands",
+          "3. Course schedule (cycle detection)",
+          "4. Word ladder",
+          "5. Network delay time",
+          "6. Minimum spanning tree",
+          "7. Shortest path in binary matrix",
+          "8. Critical connections in network"
+        ]
+        
+        problems.each { |p| puts p }
+        
+        puts "\n💡 TIP: Use adjacency list for sparse graphs!"
+        puts "💡 TIP: Use adjacency matrix when you need O(1) edge lookup"
+      end
+
+      class GraphImplementation
+        def initialize(directed = true)
+          @adj_list = Hash.new { |h, k| h[k] = [] }
+          @directed = directed
+        end
+        
+        def add_vertex(vertex)
+          @adj_list[vertex] ||= []
+        end
+        
+        def add_edge(from, to)
+          @adj_list[from] << to
+          @adj_list[to] << from unless @directed
+        end
+        
+        def remove_edge(from, to)
+          @adj_list[from].delete(to)
+          @adj_list[to].delete(from) unless @directed
+        end
+        
+        def neighbors(vertex)
+          @adj_list[vertex]
+        end
+        
+        def has_edge?(from, to)
+          @adj_list[from].include?(to)
+        end
+        
+        def vertices
+          @adj_list.keys
+        end
+        
+        def display
+          puts "\nAdjacency List:"
+          @adj_list.each do |vertex, neighbors|
+            puts "#{vertex}: #{neighbors.join(', ')}"
+          end
+        end
       end
     end
   end