algorithms 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7cee1c06e078dc124212a3462d765d26ce5fbe16dd6b31ca6392388d8f51644c
-  data.tar.gz: 491e3540ee5567752d208bb7b8502d1ee998b55e9664c66b5cf5fc17394e10e7
+  metadata.gz: 2710897393899fe90ddd5a3046f0fee0dd6d29aec842879ec28654e2767d1626
+  data.tar.gz: 8ccc55227d725e590ea965767765c29bb66211866cc948d81a3ed4997d6db733
 SHA512:
-  metadata.gz: a4a533a2053ae799f87df22b51ff93744e8128e0982239f3d6717bfb6f8ee8817d9c6ebffd6b4a2b478694a3f2f742fc4465eba242e5d2d0d23bfc0c881c1daa
-  data.tar.gz: 4ffaed30fc92fca18dd258102a702f8fceb1a77594ac6b086c627e1a3ab8ae1ad6650295acd0fb423a6ce441b6b7ab686bb56ae9ff937448d031f319d937a427
+  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.png)](https://travis-ci.org/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/)
 
@@ -8,7 +8,7 @@ Started as a [Google Summer of Code 2008](http://code.google.com/soc/2008/ruby/a
 
 Written by [Kanwei Li](http://kanwei.com/), mentored by Austin Ziegler
 
-### Original Proposal: ###
+## Original Proposal: ##
 
 Using the right data structure or algorithm for the situation is an important
 aspect of programming. In computer science literature, many data structures

data/algorithms.gemspec

@@ -2,12 +2,12 @@
 
 Gem::Specification.new do |s|
   s.name = "algorithms"
-  s.version = "1.0.0"
+  s.version = "1.1.0"
 
   s.authors = ["Kanwei Li"]
   s.email = "kanwei@gmail.com"
   s.license = 'MIT'
-  s.date = "2021-04-04"
+  s.date = "2023-11-11"
   s.summary = "Useful algorithms and data structures for Ruby. Optional C extensions."
   s.description = "Heap, Priority Queue, Deque, Stack, Queue, Red-Black Trees, Splay Trees, sorting algorithms, and more"
   if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'

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
@@ -75,13 +74,6 @@ class Containers::Heap
     end
     @size += 1
     
-    arr = []
-    w = @next.right
-    until w == @next do
-      arr << w.value
-      w = w.right
-    end
-    arr << @next.value
     @stored[key] ||= []
     @stored[key] << node
     value
@@ -376,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/lib/containers/rb_tree_map.rb

@@ -15,7 +15,7 @@ require 'containers/stack'
     explicitly used as well; their functionality is identical.
     
     Most methods have O(log n) complexity.
-    
+
 =end
 class Containers::RubyRBTreeMap
   include Enumerable
@@ -160,7 +160,7 @@ class Containers::RubyRBTreeMap
     result
   end
   
-  # Deletes the item with the smallest key and returns the item. Returns nil
+  # Deletes the item with the largest key and returns the item. Returns nil
   # if key is not present.
   #
   # Complexity: O(log n)

data/lib/containers/suffix_array.rb

@@ -12,10 +12,10 @@ class Containers::SuffixArray
   #
   # Complexity: O(n^2 log n)
   #
-  #   s_array = Containers::SuffixArray("abracadabra")
+  #   s_array = Containers::SuffixArray.new("abracadabra")
   #   s_array["abra"] #=> true
   #
-  #   number = Containers::SuffixArray(1234567)
+  #   number = Containers::SuffixArray.new(1234567)
   #   number[1] #=> true
   #   number[13] #=> false 
   def initialize(string)
@@ -65,4 +65,4 @@ class Containers::SuffixArray
     return false
   end
   alias_method :[], :has_substring?
-end
+end

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,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: algorithms
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Kanwei Li
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-04-04 00:00:00.000000000 Z
+date: 2023-11-11 00:00:00.000000000 Z
 dependencies: []
 description: Heap, Priority Queue, Deque, Stack, Queue, Red-Black Trees, Splay Trees,
   sorting algorithms, and more
@@ -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.1.2
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Useful algorithms and data structures for Ruby. Optional C extensions.
 test_files: []