RubyGems - collection_utils - Versions diffs - 0.1.0 → 1.0.0 - Mend

collection_utils 0.1.0 → 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (36) hide show

checksums.yaml +4 -4
data/.travis.yml +1 -0
data/README.md +3 -3
data/documentation/CollectionUtils/Heap.html +1276 -0
data/documentation/CollectionUtils/HeapUtils/MaxHeap.html +490 -0
data/documentation/CollectionUtils/HeapUtils/MinHeap.html +490 -0
data/documentation/CollectionUtils/HeapUtils.html +117 -0
data/documentation/CollectionUtils/Queue.html +749 -0
data/documentation/CollectionUtils/Stack.html +674 -0
data/documentation/CollectionUtils/TreeUtils/BST.html +515 -0
data/documentation/CollectionUtils/TreeUtils.html +117 -0
data/documentation/CollectionUtils.html +134 -0
data/documentation/_index.html +211 -0
data/documentation/class_list.html +51 -0
data/documentation/css/common.css +1 -0
data/documentation/css/full_list.css +58 -0
data/documentation/css/style.css +492 -0
data/documentation/file.README.html +124 -0
data/documentation/file_list.html +56 -0
data/documentation/frames.html +17 -0
data/documentation/index.html +124 -0
data/documentation/js/app.js +248 -0
data/documentation/js/full_list.js +216 -0
data/documentation/js/jquery.js +4 -0
data/documentation/method_list.html +355 -0
data/documentation/top-level-namespace.html +110 -0
data/lib/collection_utils/heap.rb +251 -0
data/lib/collection_utils/heap_utils/max_heap.rb +12 -12
data/lib/collection_utils/heap_utils/min_heap.rb +13 -11
data/lib/collection_utils/queue.rb +21 -0
data/lib/collection_utils/stack.rb +25 -2
data/lib/collection_utils/tree_utils/bst.rb +69 -0
data/lib/collection_utils/tree_utils.rb +5 -0
data/lib/collection_utils/version.rb +1 -1
metadata +28 -3
data/lib/collection_utils/heap_utils/heap.rb +0 -97

data/documentation/top-level-namespace.html ADDED Viewed

@@ -0,0 +1,110 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>
+  Top Level Namespace
+    &mdash; Documentation by YARD 0.9.9
+</title>
+  <link rel="stylesheet" href="css/style.css" type="text/css" charset="utf-8" />
+  <link rel="stylesheet" href="css/common.css" type="text/css" charset="utf-8" />
+<script type="text/javascript" charset="utf-8">
+  pathId = "";
+  relpath = '';
+</script>
+  <script type="text/javascript" charset="utf-8" src="js/jquery.js"></script>
+  <script type="text/javascript" charset="utf-8" src="js/app.js"></script>
+  </head>
+  <body>
+    <div class="nav_wrap">
+      <iframe id="nav" src="class_list.html?1"></iframe>
+      <div id="resizer"></div>
+    </div>
+    <div id="main" tabindex="-1">
+      <div id="header">
+        <div id="menu">
+    <a href="_index.html">Index</a> &raquo;
+    <span class="title">Top Level Namespace</span>
+</div>
+        <div id="search">
+    <a class="full_list_link" id="class_list_link"
+        href="class_list.html">
+        <svg width="24" height="24">
+          <rect x="0" y="4" width="24" height="4" rx="1" ry="1"></rect>
+          <rect x="0" y="12" width="24" height="4" rx="1" ry="1"></rect>
+          <rect x="0" y="20" width="24" height="4" rx="1" ry="1"></rect>
+        </svg>
+    </a>
+</div>
+        <div class="clear"></div>
+      </div>
+      <div id="content"><h1>Top Level Namespace
+</h1>
+<div class="box_info">
+</div>
+<h2>Defined Under Namespace</h2>
+<p class="children">
+      <strong class="modules">Modules:</strong> <span class='object_link'><a href="CollectionUtils.html" title="CollectionUtils (module)">CollectionUtils</a></span>
+</p>
+</div>
+      <div id="footer">
+  Generated on Thu Jul 20 01:32:56 2017 by
+  <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
+  0.9.9 (ruby-2.0.0).
+</div>
+    </div>
+  </body>
+</html>

data/lib/collection_utils/heap.rb ADDED Viewed

@@ -0,0 +1,251 @@
+module CollectionUtils
+    class Heap
+      private
+      attr_accessor :heap
+      protected
+      #
+      # @return element which is at the root of the tree
+      def root
+        return @heap.first
+      end
+      # 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])
+        arr << node[:element]
+        pre_order(left, arr) unless left.nil?
+        pre_order(right, arr) unless right.nil?
+        return
+      end
+      # Traverse the tree in post-order manner
+      #
+      # @param node current node being parsed
+      # @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])
+        post_order(left, arr) unless left.nil?
+        post_order(right, arr) unless right.nil?
+        arr << node[:element]
+        return
+      end
+      # Traverse the tree in in-order manner
+      #
+      # @param node current node being parsed
+      # @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])
+        in_order(left, arr) unless left.nil?
+        arr << node[:element]
+        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 = []
+        array.each do |element|
+          push(element)
+        end
+      end
+       #Public methods
+       # @param [Integer] parent index for which left child needs to be returned
+       # @return left child
+       def left(parent = 0)
+         left_child(parent).first
+       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}
+       end
+       # pop an element from heap
+       #
+       # @return removed element
+       def pop
+         element = @heap.pop
+         return element[:element]
+       end
+       # @return [Integer] size of heap
+       def size
+         return @heap.size
+       end
+       # @return [Boolean] heap's emptiness
+       def is_empty?
+         return size == 0
+       end
+       # bfs stands for breadth first search.
+       # @yield [element] this will take the element returned in bfs manner and execute the passed block.
+       # @example Create Heap and in bfs manner assign it to array
+       #    arr = [1,2,3,4,5]
+       #    heap = CollectionUtils::Heap.new(arr)
+       #    x = []
+       #    @heap.bfs do |element|
+       #      x << element
+       #    end
+       #    #x = [1,2,3,4,5]
+       def bfs
+         queue = CollectionUtils::Queue.new
+         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?
+           queue.enqueue(left) unless left.nil?
+           queue.enqueue(right) unless right.nil?
+           break if queue.is_empty?
+         end
+       end
+       # dfs stands for depth first search.
+       # @yield [element] this will take the element returned in dfs manner and execute the passed block.
+       # @example Create Heap and in dfs manner assign it to array
+       #    arr = [1,2,3,4,5]
+       #    heap = CollectionUtils::Heap.new(arr)
+       #    x = []
+       #    @heap.dfs do |element|
+       #      x << element
+       #    end
+       #    #x = [1,3,2,5,4]
+       def dfs
+         stack = CollectionUtils::Stack.new
+         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?
+           stack.push(left) unless left.nil?
+           stack.push(right) unless right.nil?
+           break if stack.is_empty?
+         end
+       end
+       # Pre-Order Traversal of Tree
+       #
+       # @return [Array] elements of heap in pre-ordered manner
+       def preorder
+         arr = []
+         pre_order(root, arr)
+         return arr
+       end
+       # Post-Order Traversal of Tree
+       #
+       # @return [Array] elements of heap in post-ordered manner
+       def postorder
+         arr = []
+         post_order(root, arr)
+         return arr
+       end
+       # In-Order Traversal of Tree
+       #
+       # @return [Array] elements of heap in in-ordered manner
+       def inorder
+         arr = []
+         in_order(root, arr)
+         return arr
+       end
+    end
+    Tree = Heap
+end

data/lib/collection_utils/heap_utils/max_heap.rb CHANGED Viewed

@@ -1,7 +1,7 @@
-require_relative './heap'
+require_relative '../heap'
 module CollectionUtils
   module HeapUtils
-    class MaxHeap < Heap
+    class MaxHeap < CollectionUtils::Heap
       private
       attr_accessor :heap
@@ -14,8 +14,8 @@ module CollectionUtils
       end
       def heapify(node)
-        left = left_child(node[:index]).first
-        right = right_child(node[:index]).first
+        left = left(node[:index])
+        right = right(node[:index])
         largest = node
         if !left.nil? && left[:element] >= node[:element]
           largest = left
@@ -32,10 +32,6 @@ module CollectionUtils
       end
-      def max
-        @heap.first
-      end
       public
       def initialize(array = [])
         @heap = []
@@ -44,7 +40,7 @@ module CollectionUtils
         end
       end
-      def insert(value)
+      def insert(element)
         value = {element: element, index: size}
         @heap << value
         i = @heap.size - 1
@@ -56,20 +52,24 @@ module CollectionUtils
         end
       end
+      # @return element which has maximum value in heap
       def get_max
         return if is_empty?
-        return max[:element]
+        return root[:element]
       end
+     # Removes the maximum value element from heap and
+     # corrects the whole heap again
+     # @return maximum value element
       def extract_max
         return if is_empty?
-        maximum = max
+        maximum = root
         if @heap.size > 1
           last_value = @heap.last
           last_value[:index] = 0
           @heap = @heap.slice(0..@heap.size-2)
           @heap[0] = last_value
-          heapify(max)
+          heapify(root)
         else
           @heap =[  ]
         end

data/lib/collection_utils/heap_utils/min_heap.rb CHANGED Viewed

@@ -1,7 +1,7 @@
-require_relative './heap'
+require_relative '../heap'
 module CollectionUtils
   module HeapUtils
-    class MinHeap < Heap
+    class MinHeap < CollectionUtils::Heap
       private
       attr_accessor :heap
@@ -14,8 +14,8 @@ module CollectionUtils
       end
       def heapify(node)
-        left = left_child(node[:index]).first
-        right = right_child(node[:index]).first
+        left = left(node[:index])
+        right = right(node[:index])
         smallest = node
         if !left.nil? && left[:element] < node[:element]
           smallest = left
@@ -32,9 +32,6 @@ module CollectionUtils
       end
-      def min
-        @heap.first
-      end
       public
       def initialize(array = [])
@@ -56,22 +53,27 @@ module CollectionUtils
         end
       end
+      # @return element which has minimum value in heap
       def get_min
         return if is_empty?
-        return min[:element]
+        return root[:element]
       end
+      # Removes the minimum value element from heap and
+      # corrects the whole heap again
+      # @return minimum value element
       def extract_min
         return if is_empty?
-        minimum = min
+        minimum = root
         if @heap.size > 1
           last_value = @heap.last
           last_value[:index] = 0
           @heap = @heap.slice(0..@heap.size-2)
           @heap[0] = last_value
-          heapify(min)
+          heapify(root)
         else
-          @heap =[  ]
+          @heap =[]
         end
         return minimum[:element]