dsa-ruby 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6d48c162c54e6f3b5a72e0ec6c5bfb01ea194db9aa01edd8b3acf22ec8e65d2a
+  data.tar.gz: 90dec8d0903d522bd53c1928f1b4bfe4e3183c51ac0cd6c6c2089864eeaf31ed
+SHA512:
+  metadata.gz: ffc6d6ee8215956588a61c477fbf92c8a441d43ded58525f758086c07433389616c9f538bac40d2de30f113d184beec0cfb155d236cc7ddb08da815b9d1aa75f
+  data.tar.gz: 700cbc183e14b7fe0884c52b43a49c686530e6276deea50a3eaf6b7df9e65dfd23b51ccc21c38d5af38bed62496f59e1314c43c59a20d0587344d495606406c3

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,245 @@
+# dsa-ruby
+
+Data structures for coding interviews in Ruby. Provides the missing structures
+that Ruby's stdlib doesn't include but are essential for technical interviews.
+
+## Installation
+
+```ruby
+gem "dsa-ruby"
+```
+
+Or install directly:
+
+```sh
+gem install dsa-ruby
+```
+
+## Usage
+
+```ruby
+require "dsa-ruby"
+```
+
+### MinHeap / MaxHeap
+
+```ruby
+heap = DSA::MinHeap.new
+heap.push(5, 3, 7, 1)
+heap.pop   # => 1
+heap.peek  # => 3
+
+max_heap = DSA::MaxHeap.new([5, 3, 7, 1])
+max_heap.pop  # => 7
+```
+
+### PriorityQueue
+
+```ruby
+pq = DSA::PriorityQueue.new(type: :min)
+pq.push("task_a", 3)
+pq.push("task_b", 1)
+pq.push("task_c", 2)
+
+pq.pop  # => "task_b" (lowest priority first)
+
+pq = DSA::PriorityQueue.new(type: :max)
+pq.push("task_a", 3)
+pq.push("task_b", 1)
+pq.pop  # => "task_a" (highest priority first)
+```
+
+### Deque
+
+```ruby
+dq = DSA::Deque.new
+dq.push_front(1).push_back(2)
+dq.pop_front   # => 1
+dq.pop_back    # => 2
+
+# Enumerable support
+dq.push_back(1, 2, 3)
+dq.map { |x| x * 2 }  # => [2, 4, 6]
+```
+
+### Trie
+
+```ruby
+trie = DSA::Trie.new
+trie.insert("apple")
+trie.search("apple")     # => true
+trie.search("app")       # => false
+trie.starts_with("app")  # => true
+trie.delete("apple")
+```
+
+### UnionFind
+
+```ruby
+uf = DSA::UnionFind.new(10)
+uf.union(1, 2)
+uf.union(2, 3)
+uf.connected?(1, 3)  # => true
+uf.count              # => 8 (started with 10, merged 2 pairs)
+```
+
+### LinkedList
+
+```ruby
+# Singly Linked List
+list = DSA::LinkedList::Singly.new
+list.push(1).push(2).push(3)
+list.pop        # => 3
+list.to_a       # => [2, 1]
+list.reverse!
+list.to_a       # => [1, 2]
+
+# Doubly Linked List
+dll = DSA::LinkedList::Doubly.new
+dll.push_back(1).push_back(2).push_back(3)
+dll.pop_front   # => 1
+dll.pop_back    # => 3
+dll.to_a        # => [2]
+```
+
+### Stack
+
+```ruby
+stack = DSA::Stack.new
+stack.push(1).push(2).push(3)
+stack.pop    # => 3
+stack.peek   # => 2
+```
+
+### Queue
+
+```ruby
+queue = DSA::Queue.new
+queue.enqueue("a").enqueue("b").enqueue("c")
+queue.dequeue  # => "a"
+queue.peek     # => "b"
+```
+
+### BinarySearchTree
+
+```ruby
+bst = DSA::BinarySearchTree.new
+bst.insert(5).insert(3).insert(7).insert(1).insert(4)
+bst.search(3)       # => true
+bst.min             # => 1
+bst.max             # => 7
+bst.inorder         # => [1, 3, 4, 5, 7]
+bst.preorder        # => [5, 3, 1, 4, 7]
+bst.postorder       # => [1, 4, 3, 7, 5]
+bst.delete(3)
+```
+
+## API Reference
+
+### Stack
+
+- `#push(val)` — add to top (O(1))
+- `#pop` — remove and return top (O(1))
+- `#peek` — return top without removing (O(1))
+
+### Queue
+
+- `#enqueue(val)` — add to back
+- `#dequeue` — remove and return front
+- `#peek` — return front without removing
+
+### BinarySearchTree
+
+- `#insert(val)` — insert value (O(log n) avg)
+- `#search(val)` — check if value exists (boolean)
+- `#delete(val)` — remove value, returns true if deleted
+- `#min` / `#max` — return minimum/maximum value
+- `#inorder` / `#preorder` / `#postorder` — traversal arrays
+
+### Common Methods
+
+All structures support:
+
+- `#size` — number of elements
+- `#empty?` — whether the structure is empty
+- `#to_a` — returns a defensive copy as an array
+
+### Heap (`MinHeap`, `MaxHeap`)
+
+- `#push(val)` — insert element (O(log n))
+- `#pop` — remove and return extremum (O(log n))
+- `#peek` — return extremum without removing (O(1))
+
+### PriorityQueue
+
+- `#push(item, priority)` — insert with priority
+- `#pop` — remove and return highest/lowest priority item
+- `#peek` — return top item without removing
+- `#priority_peek` — return top item's priority value
+
+### Deque
+
+- `#push_front(val)` / `#push_back(val)` — insert at either end
+- `#pop_front` / `#pop_back` — remove from either end
+- `#front` / `#back` — peek at either end
+- Includes `Enumerable`
+
+### Trie
+
+- `#insert(word)` — insert a word
+- `#search(word)` — exact word lookup
+- `#starts_with(prefix)` — prefix lookup
+- `#delete(word)` — remove a word
+
+### UnionFind
+
+- `#find(x)` — find root with path compression
+- `#union(x, y)` — merge sets, returns true if merged
+- `#connected?(x, y)` — check if in same set
+- `#count` — number of disjoint sets
+
+### LinkedList (Singly / Doubly)
+
+- `#push(val)` / `#push_front(val)` / `#push_back(val)` — insert
+- `#pop` / `#pop_front` / `#pop_back` — remove
+- `#delete(val)` — remove by value
+- `#find(val)` — find node by value
+- `#peek` / `#front` / `#back` — peek
+- `#reverse!` — reverse in-place (Singly only)
+- Includes `Enumerable`
+
+## Development
+
+```sh
+bundle install
+bundle exec rspec
+```
+
+## Release
+
+### Using the release script (recommended)
+
+Bump version, build gem, push to RubyGems, and create GitHub Release:
+
+```sh
+./release.sh patch   # 0.1.0 -> 0.1.1
+./release.sh minor   # 0.1.0 -> 0.2.0
+./release.sh major   # 0.1.0 -> 1.0.0
+```
+
+Requires: `gh` CLI authenticated, `GEM_HOST_API_KEY` environment variable set.
+
+### Using Makefile
+
+```sh
+make build      # Build the gem
+make test       # Run tests
+make install    # Build and install locally
+make publish    # Build and push to rubygems.org
+make release    # Full release workflow
+make help       # Show all commands
+```
+
+## License
+
+MIT

data/lib/dsa-ruby/binary_search_tree.rb

@@ -0,0 +1,154 @@
+module DSA
+  class BinarySearchTree
+    Node = Struct.new(:val, :left, :right, keyword_init: true)
+
+    def initialize
+      @root = nil
+      @size = 0
+    end
+
+    def insert(val)
+      @root, added = insert_recursive(@root, val)
+      @size += 1 if added
+      self
+    end
+
+    def search(val)
+      !!find_node(@root, val)
+    end
+
+    def delete(val)
+      @root, deleted = delete_recursive(@root, val)
+      @size -= 1 if deleted
+      deleted
+    end
+
+    def min
+      raise IndexError, "tree is empty" if empty?
+      find_min(@root).val
+    end
+
+    def max
+      raise IndexError, "tree is empty" if empty?
+      find_max(@root).val
+    end
+
+    def inorder
+      return [] if empty?
+      result = []
+      traverse_inorder(@root, result)
+      result
+    end
+
+    def preorder
+      return [] if empty?
+      result = []
+      traverse_preorder(@root, result)
+      result
+    end
+
+    def postorder
+      return [] if empty?
+      result = []
+      traverse_postorder(@root, result)
+      result
+    end
+
+    def size
+      @size
+    end
+
+    def empty?
+      @size == 0
+    end
+
+    def to_a
+      inorder
+    end
+
+    private
+
+    def insert_recursive(node, val)
+      if node.nil?
+        return [Node.new(val: val, left: nil, right: nil), true]
+      end
+
+      if val < node.val
+        node.left, added = insert_recursive(node.left, val)
+      elsif val > node.val
+        node.right, added = insert_recursive(node.right, val)
+      else
+        added = false
+      end
+
+      [node, added]
+    end
+
+    def find_node(node, val)
+      return nil unless node
+      return node if node.val == val
+
+      if val < node.val
+        find_node(node.left, val)
+      else
+        find_node(node.right, val)
+      end
+    end
+
+    def delete_recursive(node, val)
+      return [nil, false] unless node
+
+      if val < node.val
+        node.left, deleted = delete_recursive(node.left, val)
+      elsif val > node.val
+        node.right, deleted = delete_recursive(node.right, val)
+      else
+        deleted = true
+        return [delete_node(node), true]
+      end
+
+      [node, deleted]
+    end
+
+    def delete_node(node)
+      return node.right unless node.left
+      return node.left unless node.right
+
+      successor = find_min(node.right)
+      node.val = successor.val
+      node.right, _ = delete_recursive(node.right, successor.val)
+      node
+    end
+
+    def find_min(node)
+      node = node.left while node.left
+      node
+    end
+
+    def find_max(node)
+      node = node.right while node.right
+      node
+    end
+
+    def traverse_inorder(node, result)
+      return unless node
+      traverse_inorder(node.left, result)
+      result << node.val
+      traverse_inorder(node.right, result)
+    end
+
+    def traverse_preorder(node, result)
+      return unless node
+      result << node.val
+      traverse_preorder(node.left, result)
+      traverse_preorder(node.right, result)
+    end
+
+    def traverse_postorder(node, result)
+      return unless node
+      traverse_postorder(node.left, result)
+      traverse_postorder(node.right, result)
+      result << node.val
+    end
+  end
+end

data/lib/dsa-ruby/deque.rb

@@ -0,0 +1,57 @@
+module DSA
+  class Deque
+    def initialize
+      @deque = []
+      @head = 0
+    end
+
+    def push_front(val)
+      @deque.unshift(val)
+      self
+    end
+
+    def push_back(val)
+      @deque.push(val)
+      self
+    end
+
+    def pop_front
+      raise IndexError, "deque is empty" if empty?
+      @deque.shift
+    end
+
+    def pop_back
+      raise IndexError, "deque is empty" if empty?
+      @deque.pop
+    end
+
+    def front
+      raise IndexError, "deque is empty" if empty?
+      @deque.first
+    end
+
+    def back
+      raise IndexError, "deque is empty" if empty?
+      @deque.last
+    end
+
+    def size
+      @deque.size
+    end
+
+    def empty?
+      @deque.empty?
+    end
+
+    def to_a
+      @deque.dup
+    end
+
+    include Enumerable
+
+    def each(&block)
+      return enum_for(:each) unless block_given?
+      @deque.each(&block)
+    end
+  end
+end

data/lib/dsa-ruby/heap.rb

@@ -0,0 +1,145 @@
+module DSA
+  class MinHeap
+    def initialize(elements = [])
+      @elements = []
+      elements.each { |e| push(e) }
+    end
+
+    def push(val)
+      @elements << val
+      sift_up(@elements.size - 1)
+      self
+    end
+
+    def pop
+      raise IndexError, "heap is empty" if empty?
+
+      swap(0, @elements.size - 1)
+      min = @elements.pop
+      sift_down(0)
+      min
+    end
+
+    def peek
+      raise IndexError, "heap is empty" if empty?
+      @elements[0]
+    end
+
+    def size
+      @elements.size
+    end
+
+    def empty?
+      @elements.empty?
+    end
+
+    def to_a
+      @elements.dup
+    end
+
+    private
+
+    def sift_up(i)
+      while i > 0
+        parent = (i - 1) / 2
+        break if (@elements[parent] <=> @elements[i]) <= 0
+
+        swap(parent, i)
+        i = parent
+      end
+    end
+
+    def sift_down(i)
+      n = @elements.size
+      loop do
+        smallest = i
+        left = 2 * i + 1
+        right = 2 * i + 2
+
+        smallest = left if left < n && (@elements[left] <=> @elements[smallest]) < 0
+        smallest = right if right < n && (@elements[right] <=> @elements[smallest]) < 0
+
+        break if smallest == i
+
+        swap(i, smallest)
+        i = smallest
+      end
+    end
+
+    def swap(i, j)
+      @elements[i], @elements[j] = @elements[j], @elements[i]
+    end
+  end
+
+  class MaxHeap
+    def initialize(elements = [])
+      @elements = []
+      elements.each { |e| push(e) }
+    end
+
+    def push(val)
+      @elements << val
+      sift_up(@elements.size - 1)
+      self
+    end
+
+    def pop
+      raise IndexError, "heap is empty" if empty?
+
+      swap(0, @elements.size - 1)
+      max = @elements.pop
+      sift_down(0)
+      max
+    end
+
+    def peek
+      raise IndexError, "heap is empty" if empty?
+      @elements[0]
+    end
+
+    def size
+      @elements.size
+    end
+
+    def empty?
+      @elements.empty?
+    end
+
+    def to_a
+      @elements.dup
+    end
+
+    private
+
+    def sift_up(i)
+      while i > 0
+        parent = (i - 1) / 2
+        break if (@elements[parent] <=> @elements[i]) >= 0
+
+        swap(parent, i)
+        i = parent
+      end
+    end
+
+    def sift_down(i)
+      n = @elements.size
+      loop do
+        largest = i
+        left = 2 * i + 1
+        right = 2 * i + 2
+
+        largest = left if left < n && (@elements[left] <=> @elements[largest]) > 0
+        largest = right if right < n && (@elements[right] <=> @elements[largest]) > 0
+
+        break if largest == i
+
+        swap(i, largest)
+        i = largest
+      end
+    end
+
+    def swap(i, j)
+      @elements[i], @elements[j] = @elements[j], @elements[i]
+    end
+  end
+end

data/lib/dsa-ruby/linked_list.rb

@@ -0,0 +1,249 @@
+module DSA
+  module LinkedList
+    class Node
+      attr_accessor :val, :next
+
+      def initialize(val = 0, nxt = nil)
+        @val = val
+        @next = nxt
+      end
+    end
+
+    class DoublyNode
+      attr_accessor :val, :next, :prev
+
+      def initialize(val = 0, nxt = nil, prev = nil)
+        @val = val
+        @next = nxt
+        @prev = prev
+      end
+    end
+
+    class Singly
+      def initialize
+        @head = nil
+        @size = 0
+      end
+
+      def push(val)
+        @head = Node.new(val, @head)
+        @size += 1
+        self
+      end
+
+      def append(val)
+        new_node = Node.new(val)
+        if @head.nil?
+          @head = new_node
+        else
+          node = @head
+          node = node.next while node.next
+          node.next = new_node
+        end
+        @size += 1
+        self
+      end
+
+      def pop
+        raise IndexError, "list is empty" unless @head
+
+        val = @head.val
+        @head = @head.next
+        @size -= 1
+        val
+      end
+
+      def peek
+        raise IndexError, "list is empty" unless @head
+        @head.val
+      end
+
+      def delete(val)
+        return false unless @head
+
+        if @head.val == val
+          @head = @head.next
+          @size -= 1
+          return true
+        end
+
+        node = @head
+        while node.next
+          if node.next.val == val
+            node.next = node.next.next
+            @size -= 1
+            return true
+          end
+          node = node.next
+        end
+
+        false
+      end
+
+      def find(val)
+        node = @head
+        while node
+          return node if node.val == val
+          node = node.next
+        end
+        nil
+      end
+
+      def reverse!
+        return self unless @head
+
+        prev = nil
+        curr = @head
+        while curr
+          nxt = curr.next
+          curr.next = prev
+          prev = curr
+          curr = nxt
+        end
+        @head = prev
+        self
+      end
+
+      def size
+        @size
+      end
+
+      def empty?
+        @size == 0
+      end
+
+      def to_a
+        result = []
+        node = @head
+        while node
+          result << node.val
+          node = node.next
+        end
+        result
+      end
+
+      include Enumerable
+
+      def each(&block)
+        return enum_for(:each) unless block_given?
+        node = @head
+        while node
+          yield node.val
+          node = node.next
+        end
+      end
+    end
+
+    class Doubly
+      def initialize
+        @head = nil
+        @tail = nil
+        @size = 0
+      end
+
+      def push_front(val)
+        node = DoublyNode.new(val, @head, nil)
+        @head.prev = node if @head
+        @head = node
+        @tail ||= node
+        @size += 1
+        self
+      end
+
+      def push_back(val)
+        node = DoublyNode.new(val, nil, @tail)
+        @tail.next = node if @tail
+        @tail = node
+        @head ||= node
+        @size += 1
+        self
+      end
+
+      def pop_front
+        raise IndexError, "list is empty" unless @head
+
+        val = @head.val
+        @head = @head.next
+        @head.prev = nil if @head
+        @tail = nil unless @head
+        @size -= 1
+        val
+      end
+
+      def pop_back
+        raise IndexError, "list is empty" unless @tail
+
+        val = @tail.val
+        @tail = @tail.prev
+        @tail.next = nil if @tail
+        @head = nil unless @tail
+        @size -= 1
+        val
+      end
+
+      def front
+        raise IndexError, "list is empty" unless @head
+        @head.val
+      end
+
+      def back
+        raise IndexError, "list is empty" unless @tail
+        @tail.val
+      end
+
+      def delete(val)
+        node = @head
+        while node
+          if node.val == val
+            node.prev.next = node.next if node.prev
+            node.next.prev = node.prev if node.next
+            @head = node.next if node == @head
+            @tail = node.prev if node == @tail
+            @size -= 1
+            return true
+          end
+          node = node.next
+        end
+        false
+      end
+
+      def find(val)
+        node = @head
+        while node
+          return node if node.val == val
+          node = node.next
+        end
+        nil
+      end
+
+      def size
+        @size
+      end
+
+      def empty?
+        @size == 0
+      end
+
+      def to_a
+        result = []
+        node = @head
+        while node
+          result << node.val
+          node = node.next
+        end
+        result
+      end
+
+      include Enumerable
+
+      def each(&block)
+        return enum_for(:each) unless block_given?
+        node = @head
+        while node
+          yield node.val
+          node = node.next
+        end
+      end
+    end
+  end
+end

data/lib/dsa-ruby/priority_queue.rb

@@ -0,0 +1,43 @@
+module DSA
+  class PriorityQueue
+    def initialize(type: :min)
+      @heap = type == :min ? MinHeap.new : MaxHeap.new
+    end
+
+    def push(item, priority)
+      @counter ||= 0
+      @heap.push([priority, @counter, item])
+      @counter += 1
+      self
+    end
+
+    def pop
+      raise IndexError, "priority queue is empty" if empty?
+      _, _, item = @heap.pop
+      item
+    end
+
+    def peek
+      raise IndexError, "priority queue is empty" if empty?
+      _, _, item = @heap.peek
+      item
+    end
+
+    def priority_peek
+      raise IndexError, "priority queue is empty" if empty?
+      @heap.peek[0]
+    end
+
+    def size
+      @heap.size
+    end
+
+    def empty?
+      @heap.empty?
+    end
+
+    private
+
+    attr_reader :heap
+  end
+end

data/lib/dsa-ruby/queue.rb

@@ -0,0 +1,34 @@
+module DSA
+  class Queue
+    def initialize
+      @elements = []
+    end
+
+    def enqueue(val)
+      @elements.push(val)
+      self
+    end
+
+    def dequeue
+      raise IndexError, "queue is empty" if empty?
+      @elements.shift
+    end
+
+    def peek
+      raise IndexError, "queue is empty" if empty?
+      @elements.first
+    end
+
+    def size
+      @elements.size
+    end
+
+    def empty?
+      @elements.empty?
+    end
+
+    def to_a
+      @elements.dup
+    end
+  end
+end

data/lib/dsa-ruby/stack.rb

@@ -0,0 +1,34 @@
+module DSA
+  class Stack
+    def initialize
+      @elements = []
+    end
+
+    def push(val)
+      @elements.push(val)
+      self
+    end
+
+    def pop
+      raise IndexError, "stack is empty" if empty?
+      @elements.pop
+    end
+
+    def peek
+      raise IndexError, "stack is empty" if empty?
+      @elements.last
+    end
+
+    def size
+      @elements.size
+    end
+
+    def empty?
+      @elements.empty?
+    end
+
+    def to_a
+      @elements.dup
+    end
+  end
+end

data/lib/dsa-ruby/trie.rb

@@ -0,0 +1,70 @@
+module DSA
+  class Trie
+    Node = Struct.new(:children, :word_end, keyword_init: true) do
+      def initialize
+        super(children: {}, word_end: false)
+      end
+    end
+
+    def initialize
+      @root = Node.new
+    end
+
+    def insert(word)
+      node = @root
+      word.each_char do |char|
+        node.children[char] ||= Node.new
+        node = node.children[char]
+      end
+      node.word_end = true
+      self
+    end
+
+    def search(word)
+      node = find_node(word)
+      !!(node && node.word_end)
+    end
+
+    def starts_with(prefix)
+      !!find_node(prefix)
+    end
+
+    def delete(word)
+      delete_recursive(@root, word, 0)
+    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 delete_recursive(node, word, index)
+      return false unless node
+
+      if index == word.length
+        return false unless node.word_end
+
+        node.word_end = false
+        return node.children.empty?
+      end
+
+      char = word[index]
+      return false unless node.children[char]
+
+      should_delete = delete_recursive(node.children[char], word, index + 1)
+
+      if should_delete
+        node.children.delete(char)
+        return !node.word_end && node.children.empty?
+      end
+
+      false
+    end
+  end
+end

data/lib/dsa-ruby/union_find.rb

@@ -0,0 +1,50 @@
+module DSA
+  class UnionFind
+    def initialize(n)
+      @parent = (0...n).to_a
+      @rank = Array.new(n, 0)
+      @count = n
+    end
+
+    def find(x)
+      raise IndexError, "index out of bounds" if x < 0 || x >= @parent.size
+
+      @parent[x] = find(@parent[x]) if @parent[x] != x
+      @parent[x]
+    end
+
+    def union(x, y)
+      raise IndexError, "index out of bounds" if x < 0 || x >= @parent.size
+      raise IndexError, "index out of bounds" if y < 0 || y >= @parent.size
+
+      root_x = find(x)
+      root_y = find(y)
+
+      return false if root_x == root_y
+
+      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
+      true
+    end
+
+    def connected?(x, y)
+      find(x) == find(y)
+    end
+
+    def count
+      @count
+    end
+
+    def size
+      @parent.size
+    end
+  end
+end

data/lib/dsa-ruby/version.rb

@@ -0,0 +1,3 @@
+module DSA
+  VERSION = "1.0.0"
+end

data/lib/dsa-ruby.rb

@@ -0,0 +1,10 @@
+require_relative "dsa-ruby/version"
+require_relative "dsa-ruby/stack"
+require_relative "dsa-ruby/queue"
+require_relative "dsa-ruby/binary_search_tree"
+require_relative "dsa-ruby/heap"
+require_relative "dsa-ruby/priority_queue"
+require_relative "dsa-ruby/deque"
+require_relative "dsa-ruby/trie"
+require_relative "dsa-ruby/union_find"
+require_relative "dsa-ruby/linked_list"

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: dsa-ruby
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- You
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Provides MinHeap, MaxHeap, PriorityQueue, Deque, Trie, UnionFind, and
+  LinkedList — data structures commonly needed for coding interviews but missing from
+  Ruby's stdlib.
+email:
+- you@example.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/dsa-ruby.rb
+- lib/dsa-ruby/binary_search_tree.rb
+- lib/dsa-ruby/deque.rb
+- lib/dsa-ruby/heap.rb
+- lib/dsa-ruby/linked_list.rb
+- lib/dsa-ruby/priority_queue.rb
+- lib/dsa-ruby/queue.rb
+- lib/dsa-ruby/stack.rb
+- lib/dsa-ruby/trie.rb
+- lib/dsa-ruby/union_find.rb
+- lib/dsa-ruby/version.rb
+homepage: https://github.com/you/dsa-ruby
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.9
+specification_version: 4
+summary: Data structures for coding interviews in Ruby
+test_files: []