collection_utils 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 917412941f37688077b9cfb8204edd619dc9f9e3
-  data.tar.gz: 0f630cb9f5bb5cdbfd1d0e58d045dd8b6df6e563
+  metadata.gz: be93bf3ee75c35ec31ddec4deaf498b9e6b64787
+  data.tar.gz: 3bf11d6eb814dc595f9ff929939dbae2daad110b
 SHA512:
-  metadata.gz: 971de239372c801638b03a34d0c7fdc7e1894cebbd212848f6ff4ba598cd1d0757173c9c18f4bff9d10ebf2b0d83647503bc9b639b5e4e53a31523307437250e
-  data.tar.gz: a8b94362e213e51afb85a4531b9d073a8586a9f27bf0e2b9b7a7d1169e9cbfd85a4f6056c0b41aa9edf976b99e93e1dfb330f5c036ca884eb3b6938b59635356
+  metadata.gz: 50cf2ca18e195ad0dddb8df31b1f88919fc4a6b98a576ae2b83053e5fba91596aed59f8a82108a161ca1cbcc039e6a449f36948b4825c283147f527e98487ab2
+  data.tar.gz: 550aeb6cc93cfd1246f22f44fe946f1c79798072f289c71cb7ab11cc1635ebd1463db002db8b789c5c939511edd6a82edb15b53f6ce076da11a6aa1865fe80f6

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/Gemfile

@@ -2,3 +2,6 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in collection_utils.gemspec
 gemspec
+
+gem 'coveralls', require: false
+gem 'simplecov', :require => false, :group => :test

data/README.md

@@ -1,4 +1,4 @@
-# CollectionUtils [![Build Status](https://travis-ci.org/deeshugupta/collection_utils.svg?branch=master)](https://travis-ci.org/deeshugupta/collection_utils)
+# CollectionUtils [![Build Status](https://travis-ci.org/deeshugupta/collection_utils.svg?branch=master)](https://travis-ci.org/deeshugupta/collection_utils)  [![Coverage Status](https://coveralls.io/repos/github/deeshugupta/collection_utils/badge.svg?branch=master)](https://coveralls.io/github/deeshugupta/collection_utils?branch=master) [![Gem Version](https://badge.fury.io/rb/collection_utils.svg)](https://badge.fury.io/rb/collection_utils)
 
 CollectionUtils provide with basic collection templates like stack, queues and heaps e.t.c for easier development.
 

data/lib/collection_utils.rb

@@ -1,4 +1,4 @@
 Dir[File.dirname(__FILE__) + '/collection_utils/*.rb'].each {|file| require file }
 module CollectionUtils
-  # Your code goes here...
+  
 end

data/lib/collection_utils/hash_deserialized_object.rb

@@ -0,0 +1,114 @@
+module CollectionUtils
+  class HashDeserializedObject
+    private
+    attr_accessor :original
+
+    def convert_name(name)
+      attr_name = name.gsub(/([A-Z])([A-Z][a-z])/, '\1_\2')
+      attr_name.gsub!(/([a-z])([A-Z])/, '\1_\2')
+      return attr_name.to_s.downcase.gsub(/[\s:+!\?\.\|\{\}\[\]\+\-\*\^%$#@]/, "_")
+    end
+
+    def define_new_method(name, &block)
+       (class << self; self; end).class_eval do
+         define_method name, &block
+       end
+    end
+
+    public
+
+    def initialize(hash = {})
+      @original = hash
+      hash.each do |key, value|
+        insert(key, value)
+      end
+    end
+
+    # Add arguments on the runtime. Define attr_accessor for the arguments
+    # and get original hash for the same. Delete the unecessary arguments using
+    # delete method
+    # @param [Symbol] argument_name name of the argument that needs to be added
+    # @param *args value of the argument
+    # @example Add argument on runtime
+    # => var = CollectionUtils::HashDeserializedObject.new
+    # => var.query.bool.must.match = "hello"
+    # => var.get_serialized_object #{:query=>{:bool=>{:must=>{"match"=>"hello"}}}}
+    def method_missing(argument_name, *args)
+      if argument_name.to_s == "original"
+        super
+        return
+      end
+      name = argument_name
+      if name.to_s.include?"="
+        name = name.to_s.split("=").first
+        insert(name, args.first)
+      else
+        insert(name, {})
+      end
+      return instance_variable_get("@#{name}")
+    end
+
+    # Insert new key value pair in deserialized object.
+    # This will create an attr_accessor with key and value as given value
+    # @param name key of the hash
+    # @param value value of the given jey
+    # @example Insert an value in deserialized object and access it
+    # => obj = CollectionUtils::HashDeserializedObject.new()
+    # => obj.insert(:name, "CollectionUtils")
+    # => obj.name # CollectionUtils
+    def insert(name, value)
+      @original[name] = value
+      if value.class.name == "Hash" || value.class.superclass.name == "Hash"
+        value = CollectionUtils::HashDeserializedObject.new(value)
+      end
+      name = convert_name(name.to_s)
+      self.class.send(:attr_accessor, name)
+      instance_variable_set("@#{name}", value)
+      define_singleton_method "#{name}=".to_sym do |arg|
+        @original[name] = arg
+        instance_variable_set("@#{name}", arg)
+      end
+      define_singleton_method "#{name}".to_sym do
+        instance_variable_get("@#{name}")
+      end
+    end
+
+
+    # Delete the key value pair from deserialized object.
+    # This will rmeove the attr_accessor from object and key value from hash.
+    # @param name attr_accessor name to be deleted
+    # @return  value of the deleted attribute
+    # @example Delete from object
+    # => obj = CollectionUtils::HashDeserializedObject.new()
+    # => obj.insert(:name, "CollectionUtils")
+    # => obj.name #CollectionUtils
+    # => obj.insert(:type, "HashDeserializedObject")
+    # => obj.type #HashDeserializedObject
+    # => value = obj.delete(:name) #CollectionUtils
+    # => obj.get_serialized_object #{type: "HashDeserializedObject"}
+    def delete(name)
+      @original.delete(name)
+      instance_eval("undef :#{name.to_s}")
+      instance_eval("undef :#{name.to_s}=")
+      return remove_instance_variable("@#{name.to_s}")
+    end
+
+    # Get original Hash used to build the object. It will grow as we insert more
+    # values in the object
+    # @return [Hash] original hash used to build the object
+    # @example Create Object from hash, change the hash and get original
+    # => hash = {:message1 => "welcome", :message2 => "to" }
+    # => hash_new = CollectionUtils::HashDeserializedObject.new(hash)
+    # => hash_new(:message3, "Collections")
+    # => hash = hash_new.get_serialized_object # hash = {:message1 => "welcome", :message2 => "to", :message3 => "collections"}
+    def get_serialized_object
+      return @original
+    end
+  end
+end
+
+class Hash
+  def to_hash_deserialized_object
+    return CollectionUtils::HashDeserializedObject.new(self)
+  end
+end

data/lib/collection_utils/heap.rb

@@ -1,28 +1,46 @@
 module CollectionUtils
     class Heap
       private
-      attr_accessor :heap
+      attr_accessor :root, :incomplete_set, :leaf_set, :size, :level
 
-      protected
+      class Node
+        attr_accessor :val, :left, :right, :parent, :level
 
+        def initialize(val, left=nil, right=nil, parent=nil, level=nil)
+          @val = val
+          @left = left
+          @right = right
+          @parent = parent
+          @level = level
+        end
+
+        def is_leaf?
+          left.nil? && right.nil?
+        end
+
+        def is_full?
+          !left.nil? && !right.nil?
+        end
+
+        def is_incomplete?
+          (!left.nil? && right.nil?) || (left.nil? && !right.nil?)
+        end
 
-      #
-      # @return element which is at the root of the tree
-      def root
-        return @heap.first
       end
 
+      private_constant :Node
 
+      protected
       # Traverse the tree in pre-order manner
       #
       # @param node current node being parsed
       # @param [Array] arr which will contain the nodes of tree in pre-order manner
       def pre_order(node, arr)
         return if node.nil?
-        left = left(node[:index])
-        right = right(node[:index])
+        left = node.left
+        right = node.right
 
-        arr << node[:element]
+        arr << node.val
         pre_order(left, arr) unless left.nil?
         pre_order(right, arr) unless right.nil?
 
@@ -36,12 +54,12 @@ module CollectionUtils
       # @param [Array] arr which will contain the nodes of tree in post-order manner
       def post_order(node, arr)
         return if node.nil?
-        left = left(node[:index])
-        right = right(node[:index])
+        left = node.left
+        right = node.right
 
         post_order(left, arr) unless left.nil?
         post_order(right, arr) unless right.nil?
-        arr << node[:element]
+        arr << node.val
         return
       end
 
@@ -52,118 +70,157 @@ module CollectionUtils
       # @param [Array] arr which will contain the nodes of tree in in-order manner
       def in_order(node, arr)
         return if node.nil?
-        left = left(node[:index])
-        right = right(node[:index])
+        left = node.left
+        right = node.right
 
         in_order(left, arr) unless left.nil?
-        arr << node[:element]
+        arr << node.val
         in_order(right, arr) unless right.nil?
         return
       end
 
 
-      # @param [Integer] parent is the index for which left child needs to be founded. Default is 0
-      # @return left_child and index of that left child
-      def left_child(parent = 0)
-        left = (2*parent + 1)
-        return nil, nil if @heap[left].nil?
-        return @heap[left], left
-      end
-
-
-      # @param [Integer] parent is the index for which right child needs to be founded. Default is 0
-      # @return right_child and index of that right child
-      def right_child(parent = 0)
-        right = (2*parent + 2)
-        return nil, nil if @heap[right].nil?
-        return @heap[right], right
-      end
-
-
-      # @param parent is the index for which left child is added. Default is 0
-      # @param node is the element which needs to be assigned to left of the parent
-      def assign_left(parent = 0, node)
-        left = (2*parent + 1)
-        node[:index] = left
-        @heap[left] = node
-      end
-
-
-      # @param parent is the index for which right child is added. Default is 0
-      # @param node is the element which needs to be assigned to right of the parent
-      def assign_right(parent = 0, node)
-        right = (2*parent + 2)
-        node[:index] = right
-        @heap[right] = node
-      end
-
-      # @param parent for which left child index needs to be found
-      # @return [Integer] left child index
-      def left_index(parent = 0)
-        left = (2*parent + 1)
-      end
-
-      # @param parent for which right child index needs to be found
-      # @return [Integer] right child index
-      def right_index(parent = 0)
-        right = (2*parent + 2)
-      end
-
-      # @param child for which parent needs to be found
-      # @return element and parent index
-      def parent(child = 0)
-        par = child/2
-        return @heap[par], par
-      end
-
-
       public
       #Constructors
       def initialize(array = [])
-        @heap = []
+        @size = 0
+        @root = nil
+        @incomplete_set = CollectionUtils::Set.new()
+        @leaf_set = CollectionUtils::Set.new()
         array.each do |element|
-          push(element)
+          insert(element)
         end
       end
 
-       #Public methods
+       # Adds an element to the heap. This is done in O(1) operations and
+       # preference is given to incomplete nodes as compared to leaf nodes
+       # @param element object that needs to be added to heap
+       # => @heap = CollectionUtils::Heap.new([5,2,6,4,3])
+       # => #      5
+       # => #     / \
+       # => #    2   6
+       # => #   / \
+       # => #  4   3
+       # => @heap.insert(7)
+       # => #        5
+       # => #      /  \
+       # => #    2     6
+       # => #   / \   /
+       # => #  4   3 7
+       def insert(element)
+         node = Node.new(element)
+         @size += 1
+         if @root.nil?
+           @root = node
+           @root.level = 1
+           @level = 1
+           @leaf_set.insert(node)
+           return
+         end
+         unless @incomplete_set.is_empty?
+           parent_node = @incomplete_set.get
+           @incomplete_set.delete(parent_node)
+           if parent_node.left.nil?
+             node.parent = parent_node
+             node.level = parent_node.level + 1
+             parent_node.left = node
+             @level = node.level if node.level > @level
+             @incomplete_set.insert(parent_node) if parent_node.right.nil?
+             @leaf_set.insert(node)
+             return
+           end
+           if parent_node.right.nil?
+             node.parent = parent_node
+             node.level = parent_node.level + 1
+             parent_node.right = node
+             @level = node.level if node.level > @level
+             @incomplete_set.insert(parent_node) if parent_node.left.nil?
+             @leaf_set.insert(node)
+             return
+           end
+         end
 
-       # @param [Integer] parent index for which left child needs to be returned
-       # @return left child
-       def left(parent = 0)
-         left_child(parent).first
-       end
+         unless @leaf_set.is_empty?
+           parent_node = @leaf_set.get
+           @leaf_set.delete(parent_node)
+           node.parent = parent_node
+           node.level = parent_node.level + 1
+           parent_node.left = node
+           @level = node.level if node.level > @level
+           @incomplete_set.insert(parent_node)
+           @leaf_set.insert(node)
+           return
+         end
 
-       # @param [Integer] parent index for which right child needs to be returned
-       # @return right child
-       def right(parent = 0)
-         right_child(parent).first
        end
 
-       # push element to heap
-       #
-       # @param element object that needs to be added to heap
-       def push(element)
-         @heap << {element: element, index: size}
+       # Removes a random element from the leaf set and
+       # deletes it. This is done in O(1) operations.
+       # @return removed element
+       # @example delete from heap [5,2,6,4,3]
+       # => @heap = CollectionUtils::Heap.new([5,2,6,4,3])
+       # => #      5
+       # => #     / \
+       # => #    2   6
+       # => #   / \
+       # => #  4   3
+       # => @heap.delete == 4 or 3 or 6
+       def delete
+         @size -= 1
+         node = @leaf_set.get
+         @leaf_set.delete(node)
+         parent = node.parent
+         value = node.val
+         if parent.is_incomplete?
+           @incomplete_set.delete(parent)
+           parent.left == node ? parent.left = nil : parent.right = nil
+           node = nil
+           @leaf_set.insert(parent) if parent.is_leaf?
+         else
+           parent.left == node ? parent.left = nil : parent.right = nil
+           node = nil
+           @incomplete_set.insert(parent)
+         end
+         return value
        end
 
-       # pop an element from heap
+       # Returns the root of the tree
        #
-       # @return removed element
-       def pop
-         element = @heap.pop
-         return element[:element]
+       # @return element which is present at the root of the heap or tree
+       # @example Root of heap [5,2,6,4,3]
+       # => @heap = CollectionUtils::Heap.new([5,2,6,4,3])
+       # => #      5
+       # => #     / \
+       # => #    2   6
+       # => #   / \
+       # => #  4   3
+       # => @heap.root == 5
+       def root
+         @root.val
        end
 
-
+       # Returns the number of elements in a tree or heap. This is returned in
+       # O(1) operations as we are storing the size of the tree which is
+       # otherwise O(n) operations.
        # @return [Integer] size of heap
        def size
-         return @heap.size
+        @size
        end
 
+       # Returns whether the heap or tree is empty. This is just a syntax_sugar
+       # for size == 0
        # @return [Boolean] heap's emptiness
        def is_empty?
-         return size == 0
+        size == 0
+       end
+
+       # Returns the level of the tree. This is returned in O(1) operations
+       # as we are storing the level of the tree which is otherwise a costly
+       # operation
+       #
+       # @return [Integer] height or level of the heap or tree
+       def level
+         @level
        end
 
 
@@ -173,19 +230,19 @@ module CollectionUtils
        #    arr = [1,2,3,4,5]
        #    heap = CollectionUtils::Heap.new(arr)
        #    x = []
-       #    @heap.bfs do |element|
+       #    heap.bfs do |element|
        #      x << element
        #    end
        #    #x = [1,2,3,4,5]
        def bfs
          queue = CollectionUtils::Queue.new
-         queue.enqueue(root)
+         queue.enqueue(@root)
          while true do
            node = queue.dequeue
            next if node.nil?
-           left = left(node[:index])
-           right = right(node[:index])
-           yield(node[:element]) if block_given?
+           left = node.left
+           right = node.right
+           yield(node.val) if block_given?
            queue.enqueue(left) unless left.nil?
            queue.enqueue(right) unless right.nil?
            break if queue.is_empty?
@@ -199,19 +256,19 @@ module CollectionUtils
        #    arr = [1,2,3,4,5]
        #    heap = CollectionUtils::Heap.new(arr)
        #    x = []
-       #    @heap.dfs do |element|
+       #    heap.dfs do |element|
        #      x << element
        #    end
-       #    #x = [1,3,2,5,4]
+       #    #x = [1,3,5,4,2]
        def dfs
          stack = CollectionUtils::Stack.new
-         stack.push(root)
+         stack.push(@root)
          while true do
            node = stack.pop
            next if node.nil?
-           left = left(node[:index])
-           right = right(node[:index])
-           yield(node[:element]) if block_given?
+           left = node.left
+           right =node.right
+           yield(node.val) if block_given?
            stack.push(left) unless left.nil?
            stack.push(right) unless right.nil?
            break if stack.is_empty?
@@ -221,27 +278,51 @@ module CollectionUtils
        # Pre-Order Traversal of Tree
        #
        # @return [Array] elements of heap in pre-ordered manner
+       # @example Preorder Traversal for heap [5,2,6,4,3]
+       # => @heap = CollectionUtils::Heap.new([5,2,6,4,3])
+       # => #      5
+       # => #     / \
+       # => #    2   6
+       # => #   / \
+       # => #  4   3
+       # => arr = @heap.preorder #arr = [5,2,4,3,6]
        def preorder
          arr = []
-         pre_order(root, arr)
+         pre_order(@root, arr)
          return arr
        end
 
        # Post-Order Traversal of Tree
        #
        # @return [Array] elements of heap in post-ordered manner
+       # @example Postorder Traversal for heap [5,2,6,4,3]
+       # => @heap = CollectionUtils::Heap.new([5,2,6,4,3])
+       # => #      5
+       # => #     / \
+       # => #    2   6
+       # => #   / \
+       # => #  4   3
+       # => arr = @heap.postorder #arr = [4,3,2,6,5]
        def postorder
          arr = []
-         post_order(root, arr)
+         post_order(@root, arr)
          return arr
        end
 
        # In-Order Traversal of Tree
        #
        # @return [Array] elements of heap in in-ordered manner
+       # @example Inorder Traversal for heap [5,2,6,4,3]
+       # => @heap = CollectionUtils::Heap.new([5,2,6,4,3])
+       # => #      5
+       # => #     / \
+       # => #    2   6
+       # => #   / \
+       # => #  4   3
+       # => arr = @heap.inorder #arr = [4,2,3,5,6]
        def inorder
          arr = []
-         in_order(root, arr)
+         in_order(@root, arr)
          return arr
        end