collection_utils 1.0.0 → 2.0.0

data/lib/collection_utils/queue.rb

@@ -22,7 +22,7 @@ module CollectionUtils
     # @example Add element in queue
     #   queue = CollectionUtils::Queue.new()
     #   queue.enqueue(1)
-    #   queue.enqueue([1,3,4,])
+    #   queue.enqueue([1,3,4])
     def enqueue(element)
       @queue << element
     end
@@ -33,8 +33,8 @@ module CollectionUtils
     # @example delete element from queue
     #   queue = CollectionUtils::Queue.new()
     #   queue.enqueue(1)
-    #   queue.enqueue([1,3,4,])
-    #   element = queue.dequeue #element = 1
+    #   queue.enqueue([1,3,4])
+    #   element = queue.dequeue #element = 1, queue = [[1,3,4]]
     def dequeue
       element = @queue.first
       @queue = @queue.slice(1..-1)
@@ -43,21 +43,41 @@ module CollectionUtils
 
 
     # @return element that has been recently added
+    # @example return front element from queue
+    #   queue = CollectionUtils::Queue.new()
+    #   queue.enqueue(1)
+    #   queue.enqueue([1,3,4])
+    #   element = queue.front #element = 1, queue = [1,[1,3,4]]
     def front
       return @queue.first
     end
 
     # @return element that will be dequeued next
+    # @example return rear element from queue
+    #   queue = CollectionUtils::Queue.new()
+    #   queue.enqueue(1)
+    #   queue.enqueue([1,3,4])
+    #   element = queue.rear #element = [1,3,4], queue = [1,[1,3,4]]
     def rear
       return @queue.last
     end
 
     # @return [Boolean] which tells queue's emptiness
+    # @example return emptiness of queue
+    #   queue = CollectionUtils::Queue.new()
+    #   queue.enqueue(1)
+    #   queue.enqueue([1,3,4])
+    #   queue.is_empty? #false
     def is_empty?
       return @queue.size == 0
     end
 
     # @return [Integer] size of queue
+    # @example return size of queue
+    #   queue = CollectionUtils::Queue.new()
+    #   queue.enqueue(1)
+    #   queue.enqueue([1,3,4])
+    #   size = queue.size #size = 2
     def size
       return @queue.size
     end

data/lib/collection_utils/set.rb

@@ -0,0 +1,144 @@
+module CollectionUtils
+  class Set
+    private
+    attr_accessor :set
+
+    def get_key_value(val)
+      instance_variables = val.instance_variables
+      if instance_variables.empty?
+        return val.hash, val
+      end
+      variables = instance_variables.inject(Hash.new(0)) {|h,e|
+        h[e] = val.instance_variable_get(e);h
+      }
+      return variables.hash, val
+    end
+
+    public
+    def initialize(values = [])
+      @set = {}
+      values.each do |value|
+        insert(value)
+      end
+    end
+
+    # Insert an element into set. This is done in O(1) operations
+    #
+    # @param val element that needs to be added
+    # @return [Boolean] true if element is added, false if element is already present
+    # @example Add element into set
+    # => set = CollectionUtils::Set.new([1,2,3,4])
+    # => set.size #4
+    # => set.insert(5)
+    # => set.size #5
+    # => set.insert(4)
+    # => set.size #5
+    def insert(val)
+      key, value = get_key_value(val)
+      @set[key] = value; return true if @set[key].nil?
+      return false
+    end
+
+    # checks whether an element is present or not.
+    # This is done in O(1) operations
+    # @param val which has to be checked whether in set or not
+    # @return [Boolean] true if element is present, false if element is already present
+    # @example check an element in set
+    # => set = CollectionUtils::Set.new([1,2,3,4])
+    # => set.check(4) #true
+    # => set.check(5) #false
+    def check(val)
+      key, value = get_key_value(val)
+      return !@set[key].nil?
+    end
+
+    # deletes an element from the set.
+    # This is done in O(1) operations
+    # @param val which has to be deleted
+    # @example check an element in set
+    # => set = CollectionUtils::Set.new([1,2,3,4])
+    # => set.delete(4) #set = [1,2,3]
+    # => set.delete(5) #set = [1,2,3]
+    def delete(val)
+      key, value = get_key_value(val)
+      @set.delete(key)
+    end
+
+
+    # Get a random element from the set.
+    #
+    # @return a random element from set.
+    # @example get an element from set
+    # => set = CollectionUtils::Set.new([1,2,3,4])
+    # => set.get # 3
+    # => set.get # 4
+    # => set.get # 3
+    def get
+      @set.values.sample
+    end
+
+    # Get all the values from a set.
+    #
+    # @return all the elements from the set.
+    # @example get all element from set
+    # => set = CollectionUtils::Set.new([1,2,3,4])
+    # => set.get_values #[1,2,3,4]
+    def get_values
+      @set.values
+    end
+
+    # @return [Integer] size of the
+    # @example return size of set
+    # => set = CollectionUtils::Set.new([1,2,3,4])
+    # => set.size #4
+    def size
+      @set.keys.size
+    end
+
+    # Returns whether the set is empty. This is just a syntax_sugar
+    # for size == 0
+    # @return [Boolean] set's emptiness
+    def is_empty?
+      size == 0
+    end
+
+    # Intersection of two sets and return the intersected set
+    #
+    # @param [Set] set with which Intersection of the current set needs to be taken
+    # @return [Set] intersected set
+    # @example Intesect two sets and return it.
+    # => set1 = CollectionUtils::Set.new([1,2,3,4])
+    # => set2 = CollectionUtils::Set.new([2,3,4,5])
+    # => set3 = set1 & set2 #[2,3,4]
+    def &(set)
+      new_set = Set.new(get_values & set.get_values)
+      return new_set
+    end
+
+    # Union of two sets and return the united set
+    #
+    # @param [Set] set with which Union of the current set needs to be taken
+    # @return [Set] united set
+    # @example Union two sets and return it.
+    # => set1 = CollectionUtils::Set.new([1,2,3,4])
+    # => set2 = CollectionUtils::Set.new([2,3,4,5])
+    # => set3 = set1 + set2 #[1,2,3,4,5]
+    def +(set)
+      new_set = Set.new(get_values + set.get_values)
+      return new_set
+    end
+
+    # Difference of two sets and return the subtracted set
+    #
+    # @param [Set] set with which Difference of the current set needs to be taken
+    # @return [Set] subtracted set
+    # @example subtracted two sets and return it.
+    # => set1 = CollectionUtils::Set.new([1,2,3,4])
+    # => set2 = CollectionUtils::Set.new([2,3,4,5])
+    # => set3 = set1 - set2 #[1]
+    def -(set)
+      new_set = Set.new(get_values - set.get_values)
+    end
+
+  end
+end

data/lib/collection_utils/stack.rb

@@ -18,7 +18,7 @@ module CollectionUtils
     #
     # @example Create a stack [1,2,3,4,5] and remove 5 using pop
     #   stack = CollectionUtils::Stack.new([1,2,3,4,5])
-    #   top_element = stack.pop()
+    #   top_element = stack.pop() # top_element = 5, stack = [1,2,3,4]
     def pop
       return @stack.pop
     end
@@ -36,6 +36,9 @@ module CollectionUtils
     end
 
     # @return [Boolean] stack's emptiness
+    # @example Create a stack [1,2,3,4,5] and add check emptiness.
+    #   stack = CollectionUtils::Stack.new([1,2,3,4,5])
+    #   stack.is_empty? # false
     def is_empty?
       return @stack.size == 0
     end
@@ -46,12 +49,15 @@ module CollectionUtils
     #
     # @example Create a stack [1,2,3,4,5] and get 5 using peek
     #   stack = CollectionUtils::Stack.new([1,2,3,4,5])
-    #   top_element = stack.peek # top_element = 5
+    #   top_element = stack.peek # top_element = 5, stack = [1,2,3,4,5]
     def peek
       return @stack.last
     end
 
     # @return [Integer] size of stack
+    # @example Create a stack [1,2,3,4,5] and check size.
+    #   stack = CollectionUtils::Stack.new([1,2,3,4,5])
+    #   stack.size # 5
     def size
       return @stack.size
     end

data/lib/collection_utils/tree_utils/bst.rb

@@ -3,65 +3,221 @@ module CollectionUtils
   module TreeUtils
     class BST < CollectionUtils::Tree
       private
-      attr_accessor :bst, :height
 
-      public
-      def initialize(arr = [])
-        @heap = []
-        @height = 0
-        arr.each do |element|
-          insert(element, root)
+      def delete_node(element, node)
+        if element == node.val
+          @size -= 1
+          @leaf_set.delete(node)
+          # if the node is leaf then add the parent to leaf set if
+          # parent.is_leaf? and assign the left or right to nil based on
+          # where the node is attached to the parent.
+          if node.is_leaf?
+            parent = node.parent
+            @leaf_set.delete(parent)
+            parent.left == node ? parent.left = nil : parent.right = nil
+            @leaf_set.insert(parent) if parent.is_leaf?
+            return
+          # if the right child is leaf for the node then exchange the value of
+          # right child and node and delete the right child.
+          elsif node.right.is_leaf?
+            node.val = node.right.val
+            node.right = nil
+            @leaf_set.insert(node) if node.is_leaf?
+            return
+            # if the left child is leaf for the node then exchange the value of
+            # left child and node and delete the left child.
+          elsif node.left.is_leaf?
+            node.val = node.left.val
+            node.left = nil
+            @leaf_set.insert(node) if node.is_leaf?
+            return
+          else
+            # find the smallest child on the right side and exchange the
+            # value with the node. Balance the tree accordingly.
+            smallest = find_smallest(node.right)
+            if smallest.is_leaf?
+              @leaf_set.delete(smallest)
+              node.val = smallest.val
+              @leaf_set.insert(node) if node.is_leaf?
+            else
+              if smallest == smallest.parent.left
+                smallest.parent.left = smallest.right
+                node.val = smallest.val
+                smallest = nil
+              else
+                smallest.parent.right = smallest.right
+                node.val = smallest.val
+                smallest = nil
+              end
+            end
+
+          end
+        elsif element > node.val
+          delete_node(element, node.right)
+        else
+          delete_node(element, node.left)
         end
       end
 
-      def insert(element, node)
-        if !is_empty? && node == root
-          @height = 1
+      def find_smallest(node)
+        smallest = node.val
+        left = node.left
+        while left != nil do
+          smallest = left.val
+          left = left.left
         end
-        if is_empty?
-          @height = 1
-          @heap << {element: element, index: 0}
-          return
+        return smallest
+      end
+
+      def find_largest(node)
+        largest = node.val
+        right = node.right
+        while right != nil do
+          largest = right.val
+          right = right.right
         end
-        @height += 1
-        if element > node[:element]
-          right = right(node[:index])
-          if right.nil?
-            parent = node[:index]
-            right_in = right_index(parent)
-            value = {element: element, index: right_in}
-            assign_right(parent, value)
+        return largest
+      end
+
+      def insert_node(node, parent_node)
+        if node.val >= parent_node.val
+          if parent_node.right.nil?
+            @leaf_set.delete(parent_node)
+            parent_node.right = node
+            node.level = parent_node.level + 1
+            @level = node.level if node.level > @level
+            @leaf_set.insert(node) if node.is_leaf?
             return
           else
-            insert(element, right)
-            return
+            insert_node(node, parent_node.right)
           end
         else
-          left = left(node[:index])
-          if left.nil?
-            parent = node[:index]
-            left_in = left_index(parent)
-            value = {element: element, index: left_in}
-            assign_left(parent, value)
+          if parent_node.left.nil?
+            @leaf_set.delete(parent_node)
+            parent_node.left = node
+            node.level = parent_node.level + 1
+            @level = node.level if node.level > @level
+            @leaf_set.insert(node) if node.is_leaf?
             return
           else
-            insert(element, left)
-            return
+            insert_node(node, parent_node.left)
           end
         end
+      end
+
+      public
+      def initialize(arr = [])
+        @size = 0
+        @root = nil
+        @incomplete_set = CollectionUtils::Set.new()
+        @leaf_set = CollectionUtils::Set.new()
+        arr.each do |element|
+          insert(element)
+        end
+      end
+
+      # Insert would insert the next element in BST according to
+      # BST properties that is if element added is less than the parent_node
+      # then element will be at left side of the node else will be on the right
+      # side of the node. This operation is in O(logn)
+      # @param element Element which needs to be added to BST
+      # @example if tree has values [5,2,3,4]
+      # => @bst = CollectionUtils::TreeUtils::BST.new([5,2,3,4])
+      # => # BST would look like this
+      # => #    5
+      # => #   /
+      # => #  2
+      # => #   \
+      # => #    3
+      # => #     \
+      # => #      4
+      # => @bst.insert(6)
+      # => # Now BST would look like this
+      # => #    5
+      # => #   / \
+      # => #  2   6
+      # => #   \
+      # => #    3
+      # => #     \
+      # => #      4
 
+      def insert(element)
+        node = Node.new(element)
+        if is_empty?
+          @root = node
+          @root.level = 1
+          @level = 1
+          @size += 1
+          @leaf_set.insert(node)
+          return
+        end
+        insert_node(node, @root)
       end
 
-      def get_min
-        return root[:element]
+      # Delete would delete the element in BST and balance the BST accordingly.
+      # The delete option uses the BST property that is every node has lesser value
+      # on the left side and larger value lies on the right side.
+      # This operation is in O(logn)
+      # @param element Element which needs to be deleted from BST
+      # @example if tree has values [5,2,3,4,6]
+      # => @bst = CollectionUtils::TreeUtils::BST.new([5,2,3,4])
+      # => # BST would look like this
+      # => #    5
+      # => #   / \
+      # => #  2   6
+      # => #   \
+      # => #    3
+      # => #     \
+      # => #      4
+      # => @bst.insert(5)
+      # => # Now BST would look like this
+      # => #    6
+      # => #   /
+      # => #  2
+      # => #   \
+      # => #    3
+      # => #     \
+      # => #      4
+      def delete(element)
+        delete_node(element, @root)
       end
 
-      def is_empty?
-        return @heap.empty?
+      # Leftmost value will be the smallest value returned using this function
+      # This operation is in O(logn)
+      # @return element which is smallest in the BST
+      # @example if tree has values [5,2,3,4,6]
+      # => @bst = CollectionUtils::TreeUtils::BST.new([5,2,3,4])
+      # => # BST would look like this
+      # => #    5
+      # => #   / \
+      # => #  2   6
+      # => #   \
+      # => #    3
+      # => #     \
+      # => #      4
+      # => value = @bst.smallest
+      # => value == 2
+      def smallest
+        find_smallest(@root)
       end
 
-      def get_height
-        @height
+      # Rightmost value will be the largest value returned using this function
+      # This operation is in O(logn)
+      # @return element which is largest in the BST
+      # @example if tree has values [5,2,3,4,6]
+      # => @bst = CollectionUtils::TreeUtils::BST.new([5,2,3,4])
+      # => # BST would look like this
+      # => #    5
+      # => #   / \
+      # => #  2   6
+      # => #   \
+      # => #    3
+      # => #     \
+      # => #      4
+      # => value = @bst.largest
+      # => value == 6
+      def largest
+        find_largest(@root)
       end
 
     end