data-struct 0.0.9 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e5e32796574806001e31a7808fffbd22a9e6be13
-  data.tar.gz: 6ec9af9dcbfaac5fee5dd717c3d4bc401d1cf5b1
+  metadata.gz: 9afef8d83b99609e9b5b7198f2c74d6f8f60df31
+  data.tar.gz: 7e8812d7bf78a9678feb71371149ba352f197f35
 SHA512:
-  metadata.gz: b33ec6a761467cb0d51b06cc68fc7ec39446b7d2bf70db09e0a75967c120823dee2931d209285a474cdf287111bf762b1fb8e76abe62607c36a96f11bf55e445
-  data.tar.gz: a2334b34c6d5c5efb35eba7750932c38f6b1a3da3aa5ae43f21ccc2f3895376bc7f41b0965511bed415dc9a2b93974df0ece3b440ee68acfb2795a8c9d6984c2
+  metadata.gz: dd8f19a9af0523dfe9176108d549882aedf4610cde4bcaeadf730254392a2bbabae73c4da7c123a8f5f041fb723d02aaef87935c79ec0121c36d833ac9328e7e
+  data.tar.gz: 7100ff534e0f5dd748c03ed0d8a865c6fc15754f5b0e5141a24a3aea47875c93adc3abd0e3ef09d6202c39744d280d35faac1db874126e258a0d67efd68cb7db

data/lib/bin_heap.rb

@@ -0,0 +1,93 @@
+class BinHeap
+  attr_reader :store
+
+  def initialize(&prc)
+    @store = Array.new
+    @prc = prc || Proc.new { |el1, el2| el1 <=> el2 }
+  end
+
+  def insert(value)
+    @store << value
+    self.class.heapify_up(@store, @store.length - 1, &@prc)
+  end
+
+  def extract
+    raise "Heap is empty" if @store.empty?
+
+    top_priority = @store[0]
+    
+    if @store.length > 1
+      @store[0] = @store.pop
+      self.class.heapify_down(@store, 0, &@prc)
+    else
+      @store.pop
+    end
+    
+    top_priority  
+  end
+
+  protected
+    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]
+
+      children = []
+      children << store[c0_idx] if c0_idx
+      children << store[c1_idx] if c1_idx
+
+      parent = store[parent_idx]
+
+      #When the parent index is where it's supposed to be
+      if children.all? { |child| prc.call(child, parent) >= 0}
+        return store
+      end
+
+      if store.length == 1
+        swap_idx = c0_idx
+      else
+        swap_idx = prc.call(children[0], children[1]) == 1 ? c1_idx : c0_idx
+      end
+
+      store[swap_idx], store[parent_idx] = parent, store[swap_idx]
+
+      heapify_down(store, swap_idx, &prc)
+    end
+
+    def self.find_children(last_idx, parent_idx)
+      child1 = (parent_idx * 2) + 1
+      child2 = (parent_idx * 2) + 2
+
+
+      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

@@ -0,0 +1,174 @@
+class BinarySearchTree
+  attr_accessor :value, :parent, :left, :right, :depth, :balance
+
+  def initialize(value)
+    @value = value
+    @parent = EmptyNode.new
+    @left = EmptyNode.new
+    @right = EmptyNode.new
+    @depth = 0
+    @balance = 0
+  end
+
+  def self.from_array(array)
+    BinarySearchTree.new(array.first).tap do |tree|
+      array.each { |val| tree.insert(val) }
+    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
+    #       / \          / \
+    #      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.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 = 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.parent = self
+
+    new_left = left.left
+    new_left.parent = 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 0 then false
+    end
+
+    self
+  end
+
+  def inspect
+    " { #{value} : #{left.inspect} | #{right.inspect} } "
+  end
+
+  def include?(val)
+    case val <=> value
+    when -1 then left.include?(val)
+    when 1 then right.include?(val)
+    when 0 then true
+    end
+  end
+
+  def to_a
+    left.to_a + [value] + right.to_a
+  end
+
+  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)
+    else
+      new_node = BinarySearchTree.new(val)
+      self.right, new_node.parent = new_node, self
+      new_node.update_depth_and_balance
+    end
+  end
+
+  def rebalance
+    if @balance == -2
+      left.left_rotate if left.balance == 1
+      right_rotate
+    elsif @balance == 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
+  end
+end
+
+class EmptyNode
+  attr_reader :depth
+  attr_accessor :parent
+
+  def initialize
+    @depth = 0
+    @parent = nil
+  end
+
+  def include?(*)
+    false
+  end
+
+  def insert(*)
+    false
+  end
+
+  def inspect
+    "{}"
+  end
+
+  def recalculate_depth_and_balance
+    true
+  end
+
+  def to_a
+    []
+  end
+
+  def update_depth_and_balance
+    true
+  end
+end

data/lib/data-struct.rb

@@ -1,22 +1,17 @@
-
-# require_relative "doubly_linked_list"                           
+require_relative "binary_search_tree"
 require_relative "dynamic_array"
+# require_relative "doubly_linked_list"                         
 require_relative "max_stack"
 require_relative "min_max_stack"
 # require_relative "min_max_queue"
-require_relative "single_linked_list"
+
+require_relative "singly_linked_list"
 # require_relative "stack_queue"
 
 module DataStruct
-  class DynamicArray < DynamicArray
-  end
-
-  class MaxStack < MaxStack
-  end
-
-  class MinMaxStack < MinMaxStack
-  end
-
-  class SingleLinkedList < SingleLinkedList
-  end
-end
+  class BinarySearchTree < BinarySearchTree; end
+  class DynamicArray < DynamicArray; end
+  class MaxStack < MaxStack; end
+  class MinMaxStack < MinMaxStack; end
+  class SinglyLinkedList < SinglyLinkedList; end
+end

data/lib/{single_linked_list.rb → singly_linked_list.rb}

@@ -1,9 +1,9 @@
 # singly linked list
-class SingleLinkedList
+class SinglyLinkedList
   attr_reader :sentinel
 
   def initialize
-    @sentinel = SingleLink.new(nil)
+    @sentinel = SinglyLink.new(nil)
   end
 
   def pop
@@ -15,7 +15,7 @@ class SingleLinkedList
   end
 
   def push(val)
-    link = SingleLink.new(val)
+    link = SinglyLink.new(val)
     _, last_link = walkthrough
     last_link.next = link
 
@@ -32,7 +32,7 @@ class SingleLinkedList
   end
 
   def unshift(val)
-    link = SingleLink.new(val)
+    link = SinglyLink.new(val)
     @sentinel.next, link.next = link, @sentinel.next
     
     self
@@ -52,7 +52,7 @@ class SingleLinkedList
   end
 end
 
-class SingleLink
+class SinglyLink
   attr_accessor :next, :val
 
   def initialize(val)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: data-struct
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
 platform: ruby
 authors:
 - Kevin Wang
@@ -13,18 +13,21 @@ bindir: bin
 cert_chain: []
 date: 2015-07-16 00:00:00.000000000 Z
 dependencies: []
-description: A simple gem that provides several useful implementations of data structures
+description: A simple gem that provides several useful implementations of data structures.
+  Contribute at github.com/kswang2400/data-struct
 email: kevinwang2400@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/bin_heap.rb
+- lib/binary_search_tree.rb
 - lib/data-struct.rb
 - lib/doubly_linked_list.rb
 - lib/dynamic_array.rb
 - lib/max_stack.rb
 - lib/min_max_stack.rb
-- lib/single_linked_list.rb
+- lib/singly_linked_list.rb
 - lib/stack_queue.rb
 homepage: http://rubygems.org/gems/data-struct
 licenses: