algorithms 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d542bb52d6a148cc95802bfc5d84549e605b7077009343496e51a00d405bed05
-  data.tar.gz: b66ba40d7c3b4d29f108294e2623f85c48f52f1cdcfa7282191ed412d1877cf5
+  metadata.gz: 2710897393899fe90ddd5a3046f0fee0dd6d29aec842879ec28654e2767d1626
+  data.tar.gz: 8ccc55227d725e590ea965767765c29bb66211866cc948d81a3ed4997d6db733
 SHA512:
-  metadata.gz: 3bacbfc0793cce5bb67c51b33a64a6a4bb91e0d2cdfea661e5ee5721433bdbc19b723724ebb54e86289b053e71740dcd4c70a7e02fbed998015cd4fa31728f67
-  data.tar.gz: f2ec4934f51e631750aea36af36fb33a4b2dc0fee95ec1b138a8e97c75952b341f9f235e17a12868bb9233e88f6bb4bcfff0800e47fefe417712ee9167d389b1
+  metadata.gz: 8fd77563ddfaecf2ab085f4ff9da6b49e0c63cb65ea666ebf737a3aee175498ddb481908b2135d3ae861ae51f756f9abc9749d27a91d802b4fd8c32965d8a117
+  data.tar.gz: d002eba1aa937be5f7afc70e32155dccb108ef5d71cc874729379b403534e34122311234aab35f05c4c1a2df5b0ecfc7fed32b645c2865d1a59b1b911a3564dd

data/CHANGELOG.markdown

@@ -1,3 +1,7 @@
+=== August 20, 2025
+
+    * Fix Heap not working in certain cases
+
 === January 22, 2013
     
     * JRuby support

data/README.markdown

@@ -1,4 +1,4 @@
-# algorithms [![Build Status](https://travis-ci.org/kanwei/algorithms.svg?branch=master)](https://travis-ci.org/github/kanwei/algorithms)
+# algorithms [![Ruby CI](https://github.com/kanwei/algorithms/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/kanwei/algorithms/actions/workflows/ci.yml)
 
 [API Documentation](http://kanwei.github.io/algorithms/)
 

data/algorithms.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = "algorithms"
-  s.version = "1.0.1"
+  s.version = "1.1.0"
 
   s.authors = ["Kanwei Li"]
   s.email = "kanwei@gmail.com"

data/lib/containers/heap.rb

@@ -10,7 +10,6 @@
     This library implements a Fibonacci heap, which allows O(1) complexity for most methods.
 =end
 class Containers::Heap
-  include Enumerable
   
   # call-seq:
   #     size -> int
@@ -369,7 +368,7 @@ class Containers::Heap
           degree += 1
         end
         degrees[degree] = root
-        min = root if min.key == root.key # this fixes a bug with duplicate keys not being in the right order
+        min = root if !@compare_fn[min.key, root.key] # this fixes a bug with duplicate keys not being in the right order
       end
     end
     @next = min

data/lib/containers/priority_queue.rb

@@ -10,7 +10,6 @@ require 'containers/heap'
     This container is implemented using the Fibonacci heap included in the Collections library.
 =end
 class Containers::PriorityQueue
-  include Enumerable
   
   # Create a new, empty PriorityQueue
   def initialize(&block)

data/spec/heap_spec.rb

@@ -1,10 +1,196 @@
 $: << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
 require 'algorithms'
 
+include Comparable
+
+class Book
+  attr_reader :title, :year_published
+
+  def initialize(title, year_published)
+    @title = title
+    @year_published = year_published
+  end
+
+  def <=>(other)
+    return nil unless other.is_a?(Book)
+
+    # 1. Compare by year first
+    year_comparison = self.year_published <=> other.year_published
+
+    # 2. If years are different, return that comparison result
+    return year_comparison unless year_comparison == 0
+
+    # 3. If years are the same (tie), compare by title alphabetically
+    #    (Ensure title comparison returns -1, 0, or 1)
+    self.title <=> other.title
+  end
+
+
+  def to_s
+    "\"#{title}\" (#{year_published})" # Simplified for test output
+  end
+
+  # Add an equality method for clearer test failures if needed,
+  # though <=> returning 0 handles equality for sorting/heap purposes.
+  def ==(other)
+    other.is_a?(Book) &&
+      self.title == other.title &&
+      self.year_published == other.year_published
+  end
+  alias eql? ==
+
+  def hash
+    [title, year_published].hash
+  end
+
+end
+
+describe ::Containers::Heap do
+
+  # --- Test Data Setup ---
+  let!(:book_1932) { Book.new("Brave New World", 1932) }
+  let!(:book_1949) { Book.new("1984", 1949) }
+  let!(:book_1951a) { Book.new("Foundation", 1951) }
+  # Add another book from the same year to test handling of equal priority items
+  let!(:book_1951b) { Book.new("The Illustrated Man", 1951) }
+  let!(:book_1965) { Book.new("Dune", 1965) }
+  let!(:book_1989) { Book.new("Hyperion", 1989) }
+
+  # Use shuffle to ensure tests don't depend on insertion order
+  let(:books) { [book_1965, book_1951a, book_1989, book_1949, book_1932, book_1951b].shuffle }
+
+  let(:expected_min_order) { books.sort }
+
+  let(:expected_max_order) { books.sort.reverse }
+
+  context "Min-Heap (using default <=> via Comparable)" do
+    # Initialize heap with books; it should use Book#<=> by default
+    let(:min_heap) { ::Containers::Heap.new(books) }
+
+    it "initializes with the correct size" do
+      expect(min_heap.size).to eq(books.size)
+      expect(min_heap.empty?).to be false
+    end
+
+    it "gets the next minimum element (earliest year) without removing it" do
+      # next should return the element with the smallest year_published
+      expect(min_heap.next).to eq(book_1932)
+      # next should not change the size
+      expect(min_heap.size).to eq(books.size)
+    end
+
+    it "pops elements in ascending order of year_published" do
+      popped_books = []
+      while (book = min_heap.pop)
+        popped_books << book
+      end
+
+      # Verify the popped order matches the expected sorted order
+      expect(popped_books).to eq(expected_min_order)
+
+      # Verify the heap is now empty
+      expect(min_heap.size).to eq(0)
+      expect(min_heap.empty?).to be true
+      expect(min_heap.pop).to be_nil # Popping an empty heap
+      expect(min_heap.next).to be_nil # Getting next from an empty heap
+    end
+
+    it "correctly updates size after popping" do
+       expect(min_heap.size).to eq(books.size)
+       min_heap.pop
+       expect(min_heap.size).to eq(books.size - 1)
+    end
+  end
+
+
+  context "Max-Heap (using a custom comparison block)" do
+    # Initialize heap with books and a block for max-heap behavior
+    # The block returns true if x should have higher priority (be "larger") than y
+    let(:max_heap) { ::Containers::Heap.new(books) { |x, y| x > y } } # Use > from Comparable
+
+    it "initializes with the correct size" do
+      expect(max_heap.size).to eq(books.size)
+      expect(max_heap.empty?).to be false
+    end
+
+    it "gets the next maximum element (latest year) without removing it" do
+      # next should return the element with the largest year_published
+      expect(max_heap.next).to eq(book_1989)
+      # next should not change the size
+      expect(max_heap.size).to eq(books.size)
+    end
+
+    it "pops elements in descending order of year_published" do
+      popped_books = []
+      while (book = max_heap.pop)
+        popped_books << book
+      end
+
+      # Verify the popped order matches the expected reversed sorted order
+      expect(popped_books).to eq(expected_max_order)
+
+      # Verify the heap is now empty
+      expect(max_heap.size).to eq(0)
+      expect(max_heap.empty?).to be true
+      expect(max_heap.pop).to be_nil # Popping an empty heap
+      expect(max_heap.next).to be_nil # Getting next from an empty heap
+    end
+
+     it "correctly updates size after popping" do
+       expect(max_heap.size).to eq(books.size)
+       max_heap.pop
+       expect(max_heap.size).to eq(books.size - 1)
+    end
+  end
+
+  context "Edge cases" do
+    it "handles an empty initialization" do
+      heap = ::Containers::Heap.new([])
+      expect(heap.size).to eq(0)
+      expect(heap.empty?).to be true
+      expect(heap.pop).to be_nil
+      expect(heap.next).to be_nil
+    end
+
+    it "handles initialization with one element" do
+      heap = ::Containers::Heap.new([book_1965])
+      expect(heap.size).to eq(1)
+      expect(heap.next).to eq(book_1965)
+      expect(heap.pop).to eq(book_1965)
+      expect(heap.empty?).to be true
+    end
+  end
+
+end
+
 describe Containers::Heap do
   before(:each) do
     @heap = Containers::MaxHeap.new
   end
+
+  it "should run without error when given Objects and a non-ordering comparator" do
+    # Create and store the initial distinct objects
+    initial_objects = 10.times.map { Object.new }
+    initial_object_ids = initial_objects.map(&:object_id) # Store IDs for comparison
+
+    min_heap = ::Containers::Heap.new(initial_objects) { |x, y| (x <=> y) == -1 }
+
+    expect(min_heap.size).to eq(10)
+
+    popped_elements = []
+    expect {
+      while val = min_heap.pop do
+        popped_elements << val
+      end
+    }.not_to raise_error
+
+    expect(min_heap.empty?).to be true
+    expect(popped_elements.size).to eq(10)
+
+    # Assert that exactly the same objects were returned, regardless of order.
+    # Comparing by object_id is the most reliable way for distinct Objects.
+    expect(popped_elements.map(&:object_id)).to contain_exactly(*initial_object_ids)
+  end
   
   it "should not let you merge with non-heaps" do
     expect { @heap.merge!(nil) }.to raise_error(ArgumentError)

metadata

@@ -1,11 +1,10 @@
 --- !ruby/object:Gem::Specification
 name: algorithms
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Kanwei Li
-autorequire:
 bindir: bin
 cert_chain: []
 date: 2023-11-11 00:00:00.000000000 Z
@@ -78,7 +77,6 @@ homepage: https://github.com/kanwei/algorithms
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options:
 - "--line-numbers"
 - "--inline-source"
@@ -100,8 +98,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Useful algorithms and data structures for Ruby. Optional C extensions.
 test_files: []