collection_utils 0.1.0 → 1.0.0

data/lib/collection_utils/queue.rb

@@ -15,28 +15,49 @@ module CollectionUtils
 
     #Public Methods
 
+    # Enqueue will add an element in queue.
+    # The added element can be seen through rear function call
+    #
+    # @param element to be added in queue
+    # @example Add element in queue
+    #   queue = CollectionUtils::Queue.new()
+    #   queue.enqueue(1)
+    #   queue.enqueue([1,3,4,])
     def enqueue(element)
       @queue << element
     end
 
+    # Dequeue will remove element from queue and return the value
+    #
+    # @return element that has been removed
+    # @example delete element from queue
+    #   queue = CollectionUtils::Queue.new()
+    #   queue.enqueue(1)
+    #   queue.enqueue([1,3,4,])
+    #   element = queue.dequeue #element = 1
     def dequeue
       element = @queue.first
       @queue = @queue.slice(1..-1)
       return element
     end
 
+
+    # @return element that has been recently added
     def front
       return @queue.first
     end
 
+    # @return element that will be dequeued next
     def rear
       return @queue.last
     end
 
+    # @return [Boolean] which tells queue's emptiness
     def is_empty?
       return @queue.size == 0
     end
 
+    # @return [Integer] size of queue
     def size
       return @queue.size
     end

data/lib/collection_utils/stack.rb

@@ -12,23 +12,46 @@ module CollectionUtils
       end
     end
 
-   #Public methods
-    def pop()
+    # Pop will remove the top element from the stack and return the
+    # removed element.
+    # @return Top element of the stack
+    #
+    # @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()
+    def pop
       return @stack.pop
     end
 
+
+    # Add the element to the stack using push
+    #
+    # @param element that needs to added to stack. This element will the top element
+    # @example Create a stack [1,2,3,4,5] and add 6 to it.
+    #   stack = CollectionUtils::Stack.new([1,2,3,4,5])
+    #   stack.push(6)
+    #   #stack will be [1,2,3,4,5,6]
     def push(element)
       @stack << element
     end
 
+    # @return [Boolean] stack's emptiness
     def is_empty?
       return @stack.size == 0
     end
 
+    # View the top element of the stack without removing it
+    #
+    # @return Top element of the stack
+    #
+    # @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
     def peek
       return @stack.last
     end
 
+    # @return [Integer] size of stack
     def size
       return @stack.size
     end

data/lib/collection_utils/tree_utils/bst.rb

@@ -0,0 +1,69 @@
+require_relative '../heap'
+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)
+        end
+      end
+
+      def insert(element, node)
+        if !is_empty? && node == root
+          @height = 1
+        end
+        if is_empty?
+          @height = 1
+          @heap << {element: element, index: 0}
+          return
+        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
+          else
+            insert(element, right)
+            return
+          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)
+            return
+          else
+            insert(element, left)
+            return
+          end
+        end
+
+      end
+
+      def get_min
+        return root[:element]
+      end
+
+      def is_empty?
+        return @heap.empty?
+      end
+
+      def get_height
+        @height
+      end
+
+    end
+  end
+end

data/lib/collection_utils/tree_utils.rb

@@ -0,0 +1,5 @@
+Dir[File.dirname(__FILE__) + '/tree_utils/*.rb'].each {|file| require file }
+module CollectionUtils
+  module TreeUtils
+  end
+end

data/lib/collection_utils/version.rb

@@ -1,3 +1,3 @@
 module CollectionUtils
-  VERSION = "0.1.0"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: collection_utils
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - deeshugupta
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-07-18 00:00:00.000000000 Z
+date: 2017-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -71,13 +71,38 @@ files:
 - bin/console
 - bin/setup
 - collection_utils.gemspec
+- documentation/CollectionUtils.html
+- documentation/CollectionUtils/Heap.html
+- documentation/CollectionUtils/HeapUtils.html
+- documentation/CollectionUtils/HeapUtils/MaxHeap.html
+- documentation/CollectionUtils/HeapUtils/MinHeap.html
+- documentation/CollectionUtils/Queue.html
+- documentation/CollectionUtils/Stack.html
+- documentation/CollectionUtils/TreeUtils.html
+- documentation/CollectionUtils/TreeUtils/BST.html
+- documentation/_index.html
+- documentation/class_list.html
+- documentation/css/common.css
+- documentation/css/full_list.css
+- documentation/css/style.css
+- documentation/file.README.html
+- documentation/file_list.html
+- documentation/frames.html
+- documentation/index.html
+- documentation/js/app.js
+- documentation/js/full_list.js
+- documentation/js/jquery.js
+- documentation/method_list.html
+- documentation/top-level-namespace.html
 - lib/collection_utils.rb
+- lib/collection_utils/heap.rb
 - lib/collection_utils/heap_utils.rb
-- lib/collection_utils/heap_utils/heap.rb
 - lib/collection_utils/heap_utils/max_heap.rb
 - lib/collection_utils/heap_utils/min_heap.rb
 - lib/collection_utils/queue.rb
 - lib/collection_utils/stack.rb
+- lib/collection_utils/tree_utils.rb
+- lib/collection_utils/tree_utils/bst.rb
 - lib/collection_utils/version.rb
 homepage: https://github.com/deeshugupta/collection_utils
 licenses:

data/lib/collection_utils/heap_utils/heap.rb

@@ -1,97 +0,0 @@
-module CollectionUtils
-  module HeapUtils
-    class Heap
-      private
-      attr_accessor :heap
-
-      public
-      #Constructors
-      def initialize(array = [])
-        @heap = array
-      end
-
-       #Public methods
-       def root
-         return @heap.first
-       end
-
-       def push(element)
-         @heap << element
-       end
-
-       def pop
-         element = @heap.pop
-         return element
-       end
-
-       def left_child(parent = 0)
-         left = (2*parent + 1)
-         return nil, nil if @heap[left].nil?
-         return @heap[left], left
-       end
-
-       def right_child(parent = 0)
-         right = (2*parent + 2)
-         return nil, nil if @heap[right].nil?
-         return @heap[right], right
-       end
-
-       def assign_left(parent =0, node)
-         left = (2*parent + 1)
-         @heap[left] = node
-       end
-
-       def assign_right(parent =0, node)
-         right = (2*parent + 2)
-         @heap[right] = node
-       end
-
-       def parent(child = 0)
-         par = child/2
-         return @heap[par], par
-       end
-
-       def size
-         return @heap.size
-       end
-
-       def is_empty?
-         return size == 0
-       end
-
-       def bfs
-         queue = CollectionUtils::Queue.new
-         queue.enqueue({element: @heap.first, index: 0})
-         while true do
-           node = queue.dequeue
-           break if node.nil?
-           left = left_child(node[:index])
-           right = right_child(node[:index])
-           yield(node[:element]) if block_given?
-           queue.enqueue({element: left.first, index: left.last}) if !left.first.nil?
-           queue.enqueue({element: right.first, index: right.last}) if !right.first.nil?
-           break if left.first.nil? && right.first
-         end
-
-       end
-
-       def dfs
-         stack = CollectionUtils::Stack.new
-         stack.push({element: @heap.first, index: 0})
-         while true do
-           node = stack.pop
-           break if node.nil?
-           left = left_child(node[:index])
-           right = right_child(node[:index])
-           yield(node[:element]) if block_given?
-           stack.push({element: left.first, index: left.last}) if !left.first.nil?
-           stack.push({element: right.first, index: right.last}) if !right.first.nil?
-           break if left.first.nil? && right.first
-         end
-
-       end
-
-    end
-    Tree = Heap
-  end
-end