data-struct 0.0.10 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9afef8d83b99609e9b5b7198f2c74d6f8f60df31
-  data.tar.gz: 7e8812d7bf78a9678feb71371149ba352f197f35
+  metadata.gz: c437ac066dcec6997b160235477be36c58441660
+  data.tar.gz: 053bae6faad59521f3ce8169d1e39ca1cf82db85
 SHA512:
-  metadata.gz: dd8f19a9af0523dfe9176108d549882aedf4610cde4bcaeadf730254392a2bbabae73c4da7c123a8f5f041fb723d02aaef87935c79ec0121c36d833ac9328e7e
-  data.tar.gz: 7100ff534e0f5dd748c03ed0d8a865c6fc15754f5b0e5141a24a3aea47875c93adc3abd0e3ef09d6202c39744d280d35faac1db874126e258a0d67efd68cb7db
+  metadata.gz: 055ccbb07e98d24aa728034e4d28b674b045c71aa354bbee01610bb19f0a2cff3f1a11dd60c452482da2656ff67261622aff975246db03eaac89cd158a16013f
+  data.tar.gz: ca1608ee961b31799490719f028bc8936c9bdbeeb8a0045a1a1f657f35d8b03ae3ce978173061b001e2222c7dae949fe38dfe7ddb9db229c05eda669ee135ad7

data/lib/bin_heap.rb

@@ -27,67 +27,68 @@ class BinHeap
   end
 
   protected
-    attr_writer :prc, :store
+  
+  attr_writer :prc, :store
 
   public
-    def self.heapify_up(store, child_idx, &prc)
-      prc = prc || Proc.new { |el1, el2| el1 <=> el2 }      
-      return store if child_idx == 0 
-
-      parent_idx = find_parent(child_idx)
-      
-      if prc.call(store[child_idx], store[parent_idx]) == -1
-        store[child_idx], store[parent_idx] = store[parent_idx], store[child_idx]
-        heapify_up(store, parent_idx, &prc)
-      else
-        return store
-      end
-    end
 
-    def self.heapify_down(store, parent_idx, &prc)
-      prc = prc || Proc.new { |el1, el2| el1 <=> el2 }      
-      
-      children_idx = find_children(store.length - 1, parent_idx)
-      
-      c0_idx = children_idx[0]
-      c1_idx = children_idx[1]
+  def self.heapify_up(store, child_idx, &prc)
+    prc = prc || Proc.new { |el1, el2| el1 <=> el2 }      
+    return store if child_idx == 0 
 
-      children = []
-      children << store[c0_idx] if c0_idx
-      children << store[c1_idx] if c1_idx
+    parent_idx = find_parent(child_idx)
+    
+    if prc.call(store[child_idx], store[parent_idx]) == -1
+      store[child_idx], store[parent_idx] = store[parent_idx], store[child_idx]
+      heapify_up(store, parent_idx, &prc)
+    else
+      return store
+    end
+  end
 
-      parent = store[parent_idx]
+  def self.heapify_down(store, parent_idx, &prc)
+    prc = prc || Proc.new { |el1, el2| el1 <=> el2 }      
+    
+    children_idx = find_children(store.length - 1, parent_idx)
+    
+    c0_idx = children_idx[0]
+    c1_idx = children_idx[1]
 
-      #When the parent index is where it's supposed to be
-      if children.all? { |child| prc.call(child, parent) >= 0}
-        return store
-      end
+    children = []
+    children << store[c0_idx] if c0_idx
+    children << store[c1_idx] if c1_idx
 
-      if store.length == 1
-        swap_idx = c0_idx
-      else
-        swap_idx = prc.call(children[0], children[1]) == 1 ? c1_idx : c0_idx
-      end
+    parent = store[parent_idx]
 
-      store[swap_idx], store[parent_idx] = parent, store[swap_idx]
+    # When the parent index is where it's supposed to be
+    if children.all? { |child| prc.call(child, parent) >= 0 }
+      return store
+    end
 
-      heapify_down(store, swap_idx, &prc)
+    if store.length == 1
+      swap_idx = c0_idx
+    else
+      swap_idx = prc.call(children[0], children[1]) == 1 ? c1_idx : c0_idx
     end
 
-    def self.find_children(last_idx, parent_idx)
-      child1 = (parent_idx * 2) + 1
-      child2 = (parent_idx * 2) + 2
+    store[swap_idx], store[parent_idx] = parent, store[swap_idx]
 
+    heapify_down(store, swap_idx, &prc)
+  end
 
-      return [child1, child2].select{ |idx| idx <= last_idx }
-    end
+  def self.find_children(last_idx, parent_idx)
+    child1 = (parent_idx * 2) + 1
+    child2 = (parent_idx * 2) + 2
 
-    def self.find_parent(child_idx)
-      if child_idx == 0 
-        raise "Out of bounds"
-      else
-        return (child_idx - 1) / 2 
-      end
+    return [child1, child2].select{ |idx| idx <= last_idx }
+  end
+
+  def self.find_parent(child_idx)
+    if child_idx == 0 
+      raise "Out of bounds"
+    else
+      return (child_idx - 1) / 2 
     end
+  end
 end
 

data/lib/binary_search_tree.rb

@@ -16,57 +16,42 @@ class BinarySearchTree
     end
   end
 
-  def children
-    count = 0
-    count += 1 if left.class == BinarySearchTree
-    count += 1 if right.class == BinarySearchTree
-
-    count
-  end
-
   def left_rotate
+    #
     #      A                B
     #     / \              / \
-    #    D   B     <=>    A'  C
+    #    D   B     <=>    A   C
     #       / \          / \
     #      E   C        D   E
     #
 
-    # KW: still need to refactor this, unnecessary creation of new node
-    # reassign parent
-    new_left = BinarySearchTree.new(value)   # A'
+    new_left = BinarySearchTree.new(value)                        # A'
+
+    new_left.left, left.parent = left, new_left                   # A' <-> D
+    new_left.right, right.left.parent = right.left, new_left      # A' <-> E
+    new_left.parent = self                                        # A' <- A
 
-    new_left.left = left            # A' -> D
-    left.parent = new_left          # D  <- A'
-    new_left.right = right.left     # A' -> E
-    right.left.parent = new_left    # E  <- A'
-    new_left.parent = self          # A' <- A
+    new_right, new_right.parent = right.right, self               # C <-> A
 
-    new_right = right.right         # C
-    new_right.parent = self         # C <- A
-    
     @value, @left, @right = right.value, new_left, new_right
   end
 
   def right_rotate
     new_right = BinarySearchTree.new(value)
 
-    new_right.right = right
-    right.parent = new_right
-    new_right.left = left.right
-    left.right.parent = new_right
+    new_right.right, right.parent = right, new_right
+    new_right.left, left.right.parent = left.right, new_right
     new_right.parent = self
 
-    new_left = left.left
-    new_left.parent = self
+    new_left, new_left.parent = left.left, self
 
     @value, @left, @right = left.value, new_left, new_right
   end
 
   def insert(val)
     case val <=> value
-    when -1 then insert_left(val)
-    when 1 then insert_right(val)
+    when -1 then insert_at(val, left, -1)
+    when 1 then insert_at(val, right, 1)
     when 0 then false
     end
 
@@ -92,50 +77,40 @@ class BinarySearchTree
   def recalculate_depth_and_balance
     @depth = ([left.depth, right.depth].max + 1)
     @balance = right.depth - left.depth
-    # p "RECALULATED DEPTH = #{depth}: BALANCE = #{balance}"
   end
 
   def update_depth_and_balance
     # recursively update depth and balance, rebalances if needed and crawls up the tree
     recalculate_depth_and_balance
     rebalance if ([-2, 2].include?(@balance))
-    # p "RECALULATED #{self.inspect} DEPTH = #{depth}: BALANCE = #{balance}"
     parent.update_depth_and_balance
   end
 
   private
 
-  def insert_left(val)
-    if (left.class != EmptyNode)
-      left.insert(val)
-    else
-      new_node = BinarySearchTree.new(val)
-      self.left, new_node.parent = new_node, self
-      new_node.update_depth_and_balance
-    end
-  end
-
-  def insert_right(val)
-    if (right.class != EmptyNode)
-      right.insert(val)
+  def insert_at(val, node, dir)
+    # dir: -1 => left, 1 => right
+    if (node.class != EmptyNode)
+      node.insert(val)
     else
       new_node = BinarySearchTree.new(val)
-      self.right, new_node.parent = new_node, self
+      (dir == 1) ? self.right = new_node : self.left = new_node
+      new_node.parent = self
       new_node.update_depth_and_balance
     end
   end
 
   def rebalance
-    if @balance == -2
+    case @balance
+    when -2
       left.left_rotate if left.balance == 1
       right_rotate
-    elsif @balance == 2
+    when 2
       right.right_rotate if right.balance == -1
       left_rotate
     end
-    right.recalculate_depth_and_balance
-    left.recalculate_depth_and_balance
-    recalculate_depth_and_balance
+
+    [right, left, self].each { |n| n.recalculate_depth_and_balance }
   end
 end
 
@@ -152,18 +127,10 @@ class EmptyNode
     false
   end
 
-  def insert(*)
-    false
-  end
-
   def inspect
     "{}"
   end
 
-  def recalculate_depth_and_balance
-    true
-  end
-
   def to_a
     []
   end

data/lib/doubly_linked_list.rb

@@ -9,10 +9,12 @@ class LinkedList
 
   def pop
     last_link = @last_sentinel.prev
-    val = last_link.val
+    return nil if last_link == @begin_sentinel
+
+    last_link.prev.next = @last_sentinel
     @last_sentinel.prev = last_link.prev
 
-    val
+    last_link.val
   end
 
   def push(val)
@@ -23,7 +25,7 @@ class LinkedList
     else
       @begin_sentinel.next = link
     end
-      @last_sentinel.prev = link
+    @last_sentinel.prev = link
 
     self
   end
@@ -44,7 +46,9 @@ class LinkedList
   def shift
     first_link = @begin_sentinel.next
     return nil if first_link.nil?
+
     @begin_sentinel.next = first_link.next
+    first_link.next.prev = @begin_sentinel
 
     first_link.val
   end

data/lib/dynamic_array.rb

@@ -11,8 +11,8 @@ class DynamicArray
   end
 
   def empty?
-    # will refactor to check num_items because I'm not testing that variable right now
-    return @store.empty?
+    # not cheating by checking @store
+    return num_items == 0
   end
 
   def insert(val, idx)
@@ -38,6 +38,7 @@ class DynamicArray
 
   def pop
     # O(1)
+    raise "array is empty" if @num_items == 0
     @num_items -= 1
     idx = @start + @num_items
     val, @store[idx] = @store[idx], nil
@@ -74,6 +75,7 @@ class DynamicArray
 
   def shift
     # O(1)
+    raise "array is empty" if @num_items == 0
     val, @store[@start] = @store[@start], nil
     @num_items -= 1
     @start += 1

data/lib/priority_queue.rb

@@ -0,0 +1,73 @@
+
+require "bin_heap"
+
+class PriorityQueue
+  attr_reader :store
+
+  def initialize(&prc)
+    @store = Array.new
+    @prc = prc || Proc.new { |el1, el2| el1 <=> el2 }
+  end
+
+  def insert(val, priority)
+    @store << [val, priority]
+    self.heapify_up(@store.length - 1)
+  end
+
+  def extract
+    raise "PriorityQueue is empty" if @store.empty?
+
+    value, _ = @store[0]
+
+    if @store.length > 1
+      @store[0] = @store.pop
+      self.heapify_down(0)
+    else
+      @store.pop
+    end
+
+    value
+  end
+
+  def heapify_up(start_idx)
+    return true if start_idx == 0
+
+    parent_idx = find_parent(start_idx)
+
+    if @prc.call(@store[start_idx][1], @store[parent_idx][1]) == -1
+      @store[start_idx], @store[parent_idx] = @store[parent_idx], @store[start_idx]
+      heapify_up(parent_idx)
+    else
+      return true
+    end
+  end
+
+  def heapify_down(start_idx)
+    children_idx = find_children(start_idx)
+    children_idx.select! { |i| i < @store.length }
+
+    return true if children_idx.all? { |i| @prc.call(@store[i][1], @store[start_idx][1]) >= 0 }
+  
+    if children_idx.length == 1
+      temp_idx = children_idx[0] 
+    else
+      temp_idx = @prc.call(@store[children_idx[0]][1], @store[children_idx[1]][1]) == -1 ? children_idx[0] : children_idx[1]
+    end
+
+    @store[temp_idx], @store[start_idx] = @store[start_idx], @store[temp_idx]
+
+    heapify_down(temp_idx)
+  end
+
+  def find_parent(idx)
+    return false if idx == 0
+    return (idx - 1) / 2
+  end
+
+  def find_children(idx)
+    child_1 = (idx * 2) + 1
+    child_2 = (idx * 2) + 2
+
+    return [child_1, child_2].select { |i| i < @store.length }
+  end
+end

metadata

@@ -1,17 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: data-struct
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.12
 platform: ruby
 authors:
 - Kevin Wang
 - Daniel Ng
 - Conan Tzou
 - Karen Ling
+- Aaron Hong
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-16 00:00:00.000000000 Z
+date: 2015-09-09 00:00:00.000000000 Z
 dependencies: []
 description: A simple gem that provides several useful implementations of data structures.
   Contribute at github.com/kswang2400/data-struct
@@ -27,6 +28,7 @@ files:
 - lib/dynamic_array.rb
 - lib/max_stack.rb
 - lib/min_max_stack.rb
+- lib/priority_queue.rb
 - lib/singly_linked_list.rb
 - lib/stack_queue.rb
 homepage: http://rubygems.org/gems/data-struct
@@ -52,5 +54,5 @@ rubyforge_project:
 rubygems_version: 2.4.3
 signing_key: 
 specification_version: 4
-summary: Data structures, some up and running, not fully tested
+summary: Data structures
 test_files: []