algorithmable 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 210c9d66c15c6f091c2db2be2063d72db3243051
-  data.tar.gz: fba5ab243cfe9ce27ae93834b16ffb4500f6bcf3
+  metadata.gz: 3d896f5d72bec04a61e50d79c670e1ed9379b8cd
+  data.tar.gz: 701a49b6cb2d478a817baaef1ce743498a62813b
 SHA512:
-  metadata.gz: 7dcddf1680bf74c69b2901e5867d3f2b1c7ff774b5386ed5c59dcc8449d6cc9a52f36478ad3876141fee89e541c2fb71b138ebcf6079ca8d2126f31e4a02050a
-  data.tar.gz: 5fb2fffdacf63cd41aff9436bce9226f8672139e23e01df6bcc3f580914ec204289d99c1ad94610a0d1b9288bf4a0f621dc547d060c462e9943d7c88b5c22be3
+  metadata.gz: 45b738fc98edaaf14ee58050bdf24f8d78345fcda7b6d06394d1d6d9cc26dbb9151ea6832f27a3fd05d4906b1c9e80e7fb3d2684e70080574edb1aeacf12e4ab
+  data.tar.gz: 404eca38ab9c2775ba3f07d6760f2f37cbf303d5b59f36bbbf6fc03af59abe028d3b8bed31ada0c2b747f15eb5eefa92fec78cad1a0bbdaaa9e4c94b0446acfb

data/README.md

@@ -2,7 +2,45 @@
 
 # Algorithmable
 
-Useful algorithms such as Sorting, Searches, Graph Traversal strategies & data structures such as Symbol Tables, BST, Hash Tables, Bag, Linked List, Queue, Stack, Graphs for everyday usage. Implemented using Ruby, for fun.
+Useful algorithms such as Sorting Strategies, Searches and Data Structures such as symbol tables, binary search tree BST, red black tree RBT, 
+hash tables, bag, linked list, deque, queue FIFO, stack LIFO, graphs & Graph Traversal strategies for everyday usage. 
+
+Algorithms and Data Structures implemented using Ruby, for fun.
+
+Library also contains solutions for several puzzles solved by implemented algorithms and data structures.
+
+## Data Structures
+
+- Bag (primitive collection without ability to delete elements)
+- Doubly Linked List
+- Deque (double-ended queue)
+- Queue (FIFO)
+- Stack (LIFO)
+- Ordered Symbol Table BST. Implementation using Unbalanced Binary Search Tree.
+
+## Graphs
+
+- Undirected graph
+
+## Graph Traversals
+
+- Breadth First Search (BFS)
+- Death First Search (DFS)
+
+## Search Algorithms
+
+- Binary Search
+
+## Sorting Algorithms
+
+- Bubble sort
+- Merge sort
+- Heapsort ( Binary Heap )
+
+# Usage
+
+It is always better to check unit tests in order to understand how things going on. 
+Most of the components are encapsulated through the factory methods, so the are could be mixed to other objects.
 
 ## Installation
 
@@ -20,8 +58,6 @@ Or install it yourself as:
 
     $ gem install algorithmable
 
-## Usage
-
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/rlishtaba/algorithmable. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.

data/lib/algorithmable/data_structs/ordered_symbol_table.rb

@@ -0,0 +1,240 @@
+module Algorithmable
+  module DataStructs
+    # 
+    # Ordered Symbol Table. Implementation using Unbalanced Binary Tree.
+    #
+    class OrderedSymbolTable
+      def initialize(key_type, value_type)
+        @key_type = key_type
+        @value_type = value_type
+        @root = nil
+      end
+
+      def empty?
+        !size.nonzero?
+      end
+
+      def size
+        node_size(@root)
+      end
+
+      def key?(key)
+        assert_key_type(key)
+        !self[key].nil?
+      end
+
+      def [](key)
+        assert_key_type(key)
+        impl_get(@root, key)
+      end
+
+      def []=(key, value)
+        assert_value_type(value)
+        assert_key_type(key)
+        delete key
+        @root = impl_put(@root, key, value)
+        check_tree
+      end
+
+      def delete_min
+        @root = impl_delete_min @root
+        check_tree
+      end
+
+      def delete_max
+        @root = impl_delete_max @root
+        check_tree
+      end
+
+      def delete(key)
+        assert_key_type(key)
+        @root = impl_delete(@root, key)
+        check_tree
+      end
+
+      def min
+        impl_min(@root).key
+      end
+
+      def max
+        impl_max(@root).key
+      end
+
+      def floor(key)
+        assert_key_type(key)
+        return unless key || empty?
+        found = impl_floor(@root, key)
+        return unless found
+        found.key
+      end
+
+      def ceiling(key)
+        assert_key_type(key)
+        return unless key || empty?
+        found = impl_ceiling(@root, key)
+        return unless found
+        found.key
+      end
+
+      def select(integer)
+        return if integer < 0 || integer >= size
+        found = impl_select(@root, integer)
+        found.key
+      end
+
+      def rank(key)
+        assert_key_type(key)
+        return unless key
+        impl_rank @root, key
+      end
+
+      private
+
+      def check_tree
+        true
+      end
+
+      def assert_value_type(value)
+        fail "Type expectation not met. Use value type `#{@value_type}` instead." unless value.is_a? @value_type
+      end
+
+      def assert_key_type(key)
+        fail "Type expectation not met. Use key type `#{@key_type}` instead." unless key.is_a? @key_type
+      end
+
+      def impl_rank(node, key)
+        return 0 unless node
+        comparison = key <=> node.key
+        if comparison < 0
+          impl_rank(node.left, key)
+        elsif comparison > 0
+          1 + node_size(node.left) + impl_rank(node.right, key)
+        else
+          node_size node.left
+        end
+      end
+
+      def impl_select(node, index)
+        return unless node
+        left_size = node_size(node.left)
+        if left_size > index
+          impl_select(node.left, index)
+        elsif left_size < index
+          impl_select node.right, (index - left_size - 1)
+        else
+          node
+        end
+      end
+
+      def impl_ceiling(node, key)
+        return unless node
+        comparison = key <=> node.key
+        return node if 0 == comparison
+        if comparison < 0
+          found = impl_ceiling(node.left, key)
+          return found if found
+          return node
+        end
+        impl_ceiling node.right, key
+      end
+
+      def impl_floor(node, key)
+        return unless node
+        comparison = key <=> node.key
+        return node if 0 == comparison
+        return impl_floor(node.left, key) if comparison < 0
+        found = impl_floor(node.right, key)
+        return found if found
+        node
+      end
+
+      def impl_delete(node, key)
+        return unless node
+        comparison = key <=> node.key
+        if comparison < 0
+          node.left = impl_delete(node.left, key)
+        elsif comparison > 0
+          node.right = impl_delete(node.right, key)
+        else
+          return unless node.left || node.right
+          temp = node
+          node = impl_min(temp.right)
+          node.right = impl_delete_min(temp.right)
+          node.left = temp.left
+        end
+        node.size = computed_node_size(node)
+        node
+      end
+
+      def impl_max(node)
+        return node unless node.right
+        impl_max node.right
+      end
+
+      def impl_min(node)
+        return node unless node.left
+        impl_min node.left
+      end
+
+      def impl_delete_max(node)
+        return node.left unless node.right
+        node.right = impl_delete_max(node.right)
+        node.size = computed_node_size(node)
+        node
+      end
+
+      def impl_delete_min(node)
+        return node.right unless node.left
+        node.left = impl_delete_min(node.left)
+        node.size = computed_node_size(node)
+        node
+      end
+
+      def impl_put(node, key, value)
+        return Node.new(key, value, 1) unless node
+        comparison = key <=> node.key
+        if comparison < 0
+          node.left = impl_put(node.left, key, value)
+        elsif comparison > 0
+          node.right = impl_put(node.right, key, value)
+        else
+          node.value = value
+        end
+        node.size = computed_node_size(node)
+        node
+      end
+
+      def impl_get(node, key)
+        return unless node
+        comparison = key <=> node.key
+        if comparison < 0
+          impl_get(node.left, key)
+        elsif comparison > 0
+          impl_get(node.right, key)
+        else
+          node.value
+        end
+      end
+
+      def node_size(node)
+        node.nil? ? 0 : node.size
+      end
+
+      def computed_node_size(node)
+        1 + node_size(node.left) + node_size(node.right)
+      end
+
+      class Node
+        attr_accessor :key, :value, :left, :right, :size
+
+        def initialize(key = nil, value = nil, size = 0)
+          @key = key
+          @value = value
+          @left = nil
+          @right = nil
+          @size = size
+        end
+      end
+    end
+  end
+end

data/lib/algorithmable/data_structs.rb

@@ -5,6 +5,7 @@ module Algorithmable
     autoload :LinkedList, 'algorithmable/data_structs/linked_list'
     autoload :Queue, 'algorithmable/data_structs/queue'
     autoload :Stack, 'algorithmable/data_structs/stack'
+    autoload :OrderedSymbolTable, 'algorithmable/data_structs/ordered_symbol_table'
 
     def new_bag
       Bag.new
@@ -21,5 +22,9 @@ module Algorithmable
     def new_lifo_queue
       Stack.new
     end
+
+    def new_ordered_symbol_table(key_type, value_type)
+      OrderedSymbolTable.new(key_type, value_type)
+    end
   end
 end

data/lib/algorithmable/search/binary.rb

@@ -6,15 +6,17 @@ module Algorithmable
       end
 
       def lookup(element, collection)
+        return if element.nil?
         traverse element, collection, 0, collection.length - 1
       end
 
       def traverse(element, collection, low, high)
         while low <= high
           mid = low + (high - low) / 2
-          if element < collection[mid]
+          value_at = collection[mid]
+          if element < value_at
             high = mid.pred
-          elsif element > collection[mid]
+          elsif element > value_at
             low = mid.next
           else
             return mid

data/lib/algorithmable/search.rb

@@ -4,7 +4,7 @@ module Algorithmable
 
     class << self
       def binary(element, collection)
-        Binary.index_of(element, collection)
+        Binary.lookup(element, collection)
       end
     end
   end

data/lib/algorithmable/version.rb

@@ -1,3 +1,3 @@
 module Algorithmable
-  VERSION = '0.8.0'
+  VERSION = '0.9.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: algorithmable
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Roman Lishtaba
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-01-08 00:00:00.000000000 Z
+date: 2016-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -144,6 +144,7 @@ files:
 - lib/algorithmable/data_structs/bag.rb
 - lib/algorithmable/data_structs/deque.rb
 - lib/algorithmable/data_structs/linked_list.rb
+- lib/algorithmable/data_structs/ordered_symbol_table.rb
 - lib/algorithmable/data_structs/queue.rb
 - lib/algorithmable/data_structs/stack.rb
 - lib/algorithmable/errors.rb