sorted_containers 0.0.1 → 0.1.1

data/lib/sorted_containers/sorted_hash.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require_relative "sorted_array"
+
+# The SortedContainers module provides data structures for sorted collections.
+module SortedContainers
+  # The SortedHash class represents a sorted hash.
+  class SortedHash
+    include Enumerable
+
+    # Initializes a new instance of the SortedHash class.
+    #
+    # @param load_factor [Integer] The load factor for the SortedHash.
+    def initialize(hash = {}, load_factor: SortedArray::DEFAULT_LOAD_FACTOR)
+      @hash = hash
+      @sorted_array = SortedArray.new(hash.keys, load_factor: load_factor)
+    end
+
+    # Retrieves the value associated with the specified key.
+    #
+    # @param key [Object] The key to retrieve the value for.
+    # @return [Object] The value associated with the key, or nil if the key is not found.
+    def [](key)
+      @hash[key]
+    end
+
+    # Associates the specified value with the specified key.
+    # If the key already exists, the previous value will be replaced.
+    #
+    # @param key [Object] The key to associate the value with.
+    # @param value [Object] The value to be associated with the key.
+    # @return [Object] The value that was associated with the key.
+    def []=(key, value)
+      @sorted_array.delete(key) if @hash.key?(key)
+      @sorted_array.add(key)
+      @hash[key] = value
+    end
+
+    # Returns a string representation of the SortedHash.
+    #
+    # @return [String] A string representation of the SortedHash.
+    def to_s
+      "SortedHash({#{keys.map { |key| "#{key}: #{self[key]}" }.join(", ")}})"
+    end
+
+    # Deletes the key-value pair associated with the specified key.
+    #
+    # @param key [Object] The key to delete.
+    # @return [void]
+    def delete(key)
+      return unless @hash.key?(key)
+
+      @hash.delete(key)
+      @sorted_array.delete(key)
+    end
+
+    # Deletes the key-value pair at the specified index and returns it as a two-element array.
+    #
+    # @param index [Integer] The index of the key-value pair to delete.
+    # @return [Array] A two-element array containing the key and value of the deleted key-value pair.
+    def delete_at(index)
+      return nil if index.abs >= @sorted_array.size
+
+      key = @sorted_array.delete_at(index)
+      value = @hash.delete(key)
+      [key, value]
+    end
+
+    # Retrieves the first key-value pair from the SortedHash as a two-element array.
+    #
+    # @return [Array] A two-element array containing the key and value of the first key-value pair.
+    def first
+      return nil if @sorted_array.empty?
+
+      key = @sorted_array.first
+      [key, @hash[key]]
+    end
+
+    # Removes the first key-value pair from the SortedHash and returns it as a two-element array.
+    #
+    # @return [Array] A two-element array containing the key and value of the first key-value pair.
+    def last
+      return nil if @sorted_array.empty?
+
+      key = @sorted_array.last
+      [key, @hash[key]]
+    end
+
+    # Removes the last key-value pair from the SortedHash and returns it as a two-element array.
+    #
+    # @return [Array] A two-element array containing the key and value of the last key-value pair.
+    def pop
+      return nil if @sorted_array.empty?
+
+      key = @sorted_array.pop
+      value = @hash.delete(key)
+      [key, value]
+    end
+
+    # Removes the first key-value pair from the SortedHash and returns it as a two-element array.
+    #
+    # @return [Array] A two-element array containing the key and value of the first key-value pair.
+    def shift
+      return nil if @sorted_array.empty?
+
+      key = @sorted_array.shift
+      value = @hash.delete(key)
+      [key, value]
+    end
+
+    # Returns the number of key-value pairs in the SortedHash.
+    #
+    # @return [Integer] The number of key-value pairs.
+    def bisect_left(key)
+      @sorted_array.bisect_left(key)
+    end
+
+    # Returns the number of key-value pairs in the SortedHash.
+    #
+    # @return [Integer] The number of key-value pairs.
+    def bisect_right(key)
+      @sorted_array.bisect_right(key)
+    end
+
+    # Returns an array of all the keys in the SortedHash.
+    #
+    # @return [Array] An array of all the keys.
+    def keys
+      @sorted_array.to_a
+    end
+
+    # Returns an array of all the values in the SortedHash.
+    #
+    # @return [Array] An array of all the values.
+    def values
+      @sorted_array.to_a.map { |key| @hash[key] }
+    end
+
+    # Iterates over each key-value pair in the SortedHash.
+    #
+    # @yield [key, value] The block to be executed for each key-value pair.
+    # @yieldparam key [Object] The key of the current key-value pair.
+    # @yieldparam value [Object] The value of the current key-value pair.
+    # @return [void]
+    def each(&block)
+      @sorted_array.each do |key|
+        value = @hash[key]
+        block.call(key, value)
+      end
+    end
+  end
+end

data/lib/sorted_containers/sorted_set.rb

@@ -1,16 +1,21 @@
 # frozen_string_literal: true
 
 require "set"
-require_relative "sorted_list"
+require_relative "sorted_array"
 
 # A module that provides sorted container data structures.
 module SortedContainers
   # The SortedSet class is a sorted set implementation.
   class SortedSet
+    include Enumerable
+
     # Initializes a new instance of the SortedSet class.
-    def initialize
-      @set = Set.new
-      @list = SortedContainers::SortedList.new
+    #
+    # @param iterable [Array] The initial elements of the sorted set.
+    # @param load_factor [Integer] The load factor for the sorted set.
+    def initialize(iterable = [], load_factor: SortedArray::DEFAULT_LOAD_FACTOR)
+      @set = Set.new(iterable)
+      @list = SortedContainers::SortedArray.new(@set.to_a, load_factor: load_factor)
     end
 
     # Adds an item to the sorted set.
@@ -22,12 +27,34 @@ module SortedContainers
       @set.add(item)
       @list.add(item)
     end
+    alias << add
 
-    # Adds an item to the sorted set using the `<<` operator.
+    # Retrieves the item at the specified index.
     #
-    # @param item [Object] The item to be added.
-    def <<(item)
-      add(item)
+    # @param index [Integer] The index of the item to retrieve.
+    def [](index)
+      @list[index]
+    end
+
+    # Returns a string representation of the sorted set.
+    #
+    # @return [String] A string representation of the sorted set.
+    def to_s
+      "SortedSet(#{to_a.join(", ")})"
+    end
+
+    # Retrieves the first item in the sorted set.
+    #
+    # @return [Object] The first item.
+    def first
+      @list.first
+    end
+
+    # Retrieves the last item in the sorted set.
+    #
+    # @return [Object] The last item.
+    def last
+      @list.last
     end
 
     # Removes an item from the sorted set.
@@ -37,7 +64,18 @@ module SortedContainers
       return unless @set.include?(item)
 
       @set.delete(item)
-      @list.remove(item)
+      @list.delete(item)
+    end
+
+    # Removes the item at the specified index.
+    #
+    # @param index [Integer] The index of the item to remove.
+    def delete_at(index)
+      return if index.abs >= @list.size
+
+      item = @list.delete_at(index)
+      @set.delete(item)
+      item
     end
 
     # Returns the number of items in the sorted set.
@@ -55,6 +93,41 @@ module SortedContainers
       @set.include?(item)
     end
 
+    # Returns an index to insert `value` in the sorted list.
+    #
+    # If the `value` is already present, the insertion point will be before
+    # (to the left of) any existing values.
+    #
+    # Runtime complexity: `O(log(n))` -- approximate.
+    #
+    # @see SortedArray#bisect_left
+    # @param value [Object] The value to insert.
+    # @return [Integer] The index to insert the value.
+    def bisect_left(value)
+      @list.bisect_left(value)
+    end
+
+    # Returns an index to insert `value` in the sorted list.
+    #
+    # If the `value` is already present, the insertion point will be after
+    # (to the right of) any existing values.
+    #
+    # Runtime complexity: `O(log(n))` -- approximate.
+    #
+    # @see SortedArray#bisect_right
+    # @param value [Object] The value to insert.
+    # @return [Integer] The index to insert the value.
+    def bisect_right(value)
+      @list.bisect_right(value)
+    end
+
+    # Returns the items in the sorted set as an array.
+    #
+    # @return [Array] The items in the sorted set.
+    def to_a
+      @list.to_a
+    end
+
     # Iterates over each item in the sorted set.
     #
     # @yield [item] Gives each item to the block.

data/lib/sorted_containers/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SortedContainers
-  VERSION = "0.0.1"
+  VERSION = "0.1.1"
 end

data/lib/sorted_containers.rb

@@ -1,9 +1,6 @@
 # frozen_string_literal: true
 
 require_relative "sorted_containers/version"
-require_relative "sorted_containers/sorted_list"
+require_relative "sorted_containers/sorted_array"
 require_relative "sorted_containers/sorted_set"
-
-module SortedContainers
-  class Error < StandardError; end
-end
+require_relative "sorted_containers/sorted_hash"

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: sorted_containers
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.1
 platform: ruby
 authors:
 - Garrison Jensen
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-16 00:00:00.000000000 Z
+date: 2024-04-26 00:00:00.000000000 Z
 dependencies: []
-description: A collection of sorted containers including SortedList, SortedDict, and
-  SortedSet.
+description: A collection of sorted containers including SortedArray, SortedDict,
+  and SortedSet.
 email:
 - garrison.jensen@gmail.com
 executables: []
@@ -26,7 +26,8 @@ files:
 - README.md
 - Rakefile
 - lib/sorted_containers.rb
-- lib/sorted_containers/sorted_list.rb
+- lib/sorted_containers/sorted_array.rb
+- lib/sorted_containers/sorted_hash.rb
 - lib/sorted_containers/sorted_set.rb
 - lib/sorted_containers/version.rb
 - sig/sorted_containers.rbs
@@ -54,8 +55,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.7
+rubygems_version: 3.5.9
 signing_key:
 specification_version: 4
-summary: A collection of sorted containers including SortedList, SortedDict, and SortedSet.
+summary: A collection of sorted containers including SortedArray, SortedDict, and
+  SortedSet.
 test_files: []

data/lib/sorted_containers/sorted_list.rb

@@ -1,174 +0,0 @@
-# frozen_string_literal: true
-
-# The SortedContainers module provides data structures for sorted collections.
-module SortedContainers
-  class Error < StandardError; end
-
-  # The SortedList class is a sorted list implementation.
-  class SortedList
-    DEFAULT_LOAD_FACTOR = 1000
-
-    attr_reader :size
-
-    # Initializes a new SortedList object.
-    #
-    # @param iterable [Enumerable] An optional iterable object to initialize the list with.
-    def initialize(iterable = [])
-      @lists = []
-      @maxes = []
-      @load_factor = DEFAULT_LOAD_FACTOR
-      @size = 0
-      update(iterable)
-    end
-
-    # Adds a value to the sorted list.
-    #
-    # @param value [Object] The value to add.
-    def add(value)
-      i = bisect_right(@maxes, value)
-      if i == @maxes.size
-        @lists.push([value])
-        @maxes.push(value)
-      else
-        idx = bisect_right(@lists[i], value)
-        @lists[i].insert(idx, value)
-        @maxes[i] = @lists[i].last
-        expand(i) if @lists[i].size > (@load_factor * 2)
-      end
-      @size += 1
-    end
-
-    # Adds a value to the sorted list using the << operator.
-    #
-    # @param value [Object] The value to add.
-    def <<(value)
-      add(value)
-    end
-
-    def remove(value)
-      i = bisect_left(@maxes, value)
-      raise "Value not found: #{value}" if i == @maxes.size
-
-      idx = bisect_left(@lists[i], value)
-      raise "Value not found: #{value}" unless @lists[i][idx] == value
-
-      internal_delete(i, idx)
-    end
-
-    # Retrieves the value at the specified index.
-    #
-    # @param index [Integer] The index of the value to retrieve.
-    # @return [Object] The value at the specified index.
-    def [](index)
-      raise "Index out of range" if index.negative? || index >= @size
-
-      @lists.each do |sublist|
-        return sublist[index] if index < sublist.size
-
-        index -= sublist.size
-      end
-    end
-
-    # Deletes the value at the specified index.
-    #
-    # @param index [Integer] The index of the value to delete.
-    def delete_at(index)
-      raise "Index out of range" if index.negative? || index >= @size
-
-      deleted = false
-      @lists.each_with_index do |sublist, sublist_index|
-        if index < sublist.size
-          internal_delete(sublist_index, index)
-          deleted = true
-          break
-        else
-          index -= sublist.size
-        end
-      end
-
-      raise "Index out of range" unless deleted
-    end
-
-    # Clears the sorted list, removing all values.
-    def clear
-      @lists.clear
-      @maxes.clear
-      @size = 0
-    end
-
-    # Checks if the sorted list contains a value.
-    #
-    # @param value [Object] The value to check.
-    # @return [Boolean] True if the value is found, false otherwise.
-    def contains(value)
-      i = bisect_left(@maxes, value)
-      return false if i == @maxes.size
-
-      sublist = @lists[i]
-      idx = bisect_left(sublist, value)
-      idx < sublist.size && sublist[idx] == value
-    end
-
-    # Converts the sorted list to an array.
-    #
-    # @return [Array] An array representation of the sorted list.
-    def to_a
-      @lists.flatten
-    end
-
-    private
-
-    # Performs a left bisect on the array.
-    #
-    # @param array [Array] The array to bisect.
-    # @param value [Object] The value to bisect with.
-    # @return [Integer] The index where the value should be inserted.
-    def bisect_left(array, value)
-      array.bsearch_index { |x| x >= value } || array.size
-    end
-
-    # Performs a right bisect on the array.
-    #
-    # @param array [Array] The array to bisect.
-    # @param value [Object] The value to bisect with.
-    # @return [Integer] The index where the value should be inserted.
-    def bisect_right(array, value)
-      array.bsearch_index { |x| x > value } || array.size
-    end
-
-    # Expands a sublist if it exceeds the load factor.
-    #
-    # @param sublist_index [Integer] The index of the sublist to expand.
-    def expand(sublist_index)
-      sublist = @lists[sublist_index]
-      return unless sublist.size > (@load_factor * 2)
-
-      half = sublist.slice!(@load_factor, sublist.size - @load_factor)
-      @lists.insert(sublist_index + 1, half)
-      @maxes[sublist_index] = @lists[sublist_index].last
-      @maxes.insert(sublist_index + 1, half.last)
-    end
-
-    # Deletes a value from a sublist.
-    #
-    # @param sublist_index [Integer] The index of the sublist.
-    # @param idx [Integer] The index of the value to delete.
-    def internal_delete(sublist_index, idx)
-      @lists[sublist_index].delete_at(idx)
-      if @lists[sublist_index].empty?
-        @lists.delete_at(sublist_index)
-        @maxes.delete_at(sublist_index)
-      else
-        @maxes[sublist_index] = @lists[sublist_index].last
-      end
-      @size -= 1
-    end
-
-    # Updates the sorted list with values from an iterable object.
-    #
-    # @param iterable [Enumerable] The iterable object to update the list with.
-    def update(iterable)
-      iterable.each { |item| add(item) }
-    end
-  end
-end