binary_search_tree 2.0 → 2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 03a236331048d1d421274964c9bb1f786a2433f8
-  data.tar.gz: dc1468a43def290f733104a9df3cd23966c80dd5
+  metadata.gz: 1146c21c38df640ed4d1660d3628ac131b045f73
+  data.tar.gz: 17f900353706322d84eb7d392223350914b65895
 SHA512:
-  metadata.gz: 3809ba134072969efddf39f35284abaf407680821c17eab8932d7b05133ef651eb81ae6ff78793a99fe11c28a703f2b8af892305098a7e499e807f5d21d271e6
-  data.tar.gz: 3edbf53d2331c7629d2aa4dbffac2930ec9aa99a16786cf34a7888f4af1380e7fd53eb947f026da982062cfb6fdb1b378e39490176ad7a1b93e5fca96b40bff5
+  metadata.gz: c5938628cedda9f0d9292c54fd5f45e93df32a2bcb226e5ec078c5dd53f79a76e9893423a2e26d9dbac9ea9ed6faff7dd4464f05e73974cf97f2270114b65ec7
+  data.tar.gz: 90bb4aff76e0097329279cd832a1af1f6b936a1a7be34e3f3ea72be5c13b58a900dcf3a7edbb0bd8cea542671ea774673f76fa450978d91bdd8e42000a043bae

data/.gitignore

@@ -0,0 +1 @@
+*.swp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in conversocial.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,32 @@
+PATH
+  remote: .
+  specs:
+    binary_search_tree (2.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.5)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.1)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  binary_search_tree!
+  rspec
+
+BUNDLED WITH
+   1.10.6

data/README

@@ -0,0 +1,76 @@
+Installation:
+gem install binary_search_tree
+
+Info:
+This gem implements the two classes BinarySearchTree and BinarySearchTreeHash. BinarySearchTree is a self balancing avl tree.
+
+Most people will only need to be concerned with BinarySearchTreeHash as it is a wrapper over BinarySearchTree that provides the same interface as the native Ruby hash. This class is useful when you want a container that provides fast lookups with minimal memory footprint. Since it is self balancing, it will reorganize itself on every new insert to make subsequent lookups optimal.
+
+-----------------------------------------
+-----------------------------------------
+--Example usage of BinarySearchTreeHash--
+-----------------------------------------
+-----------------------------------------
+ruby-1.9.2> h = BinarySearchTreeHash.new logger     (note: passing a logger is optional)
+ => {}
+ruby-1.9.2> (1..100).each{|i| h[i] = i*1000}
+ruby-1.9.2> h[45]
+  DEBUG - [03/May/2011 15:02:07] "find operation completed in 7 lookups..."
+ => 45000
+ruby-1.9.2> h[77]
+  DEBUG - [03/May/2011 15:02:14] "find operation completed in 6 lookups..."
+ => 77000
+ruby-1.9.2> h[32]
+  DEBUG - [03/May/2011 15:02:18] "find operation completed in 2 lookups..."
+ => 32000
+ruby-1.9.2> h.delete 32
+  DEBUG - [03/May/2011 15:02:29] "find operation completed in 2 lookups..."
+ruby-1.9.2> h[32]
+  DEBUG - [03/May/2011 15:02:58] "find operation completed in 8 lookups..."
+ => nil
+ruby-1.9.2> h[5000] = 7777
+ => 7777
+ruby-1.9.2> h[5000]
+  DEBUG - [03/May/2011 15:03:33] "find operation completed in 7 lookups..."
+ => 7777
+ruby-1.9.2> h.size
+ => 100
+ruby-1.9.2> h.delete 50
+  DEBUG - [03/May/2011 15:03:48] "find operation completed in 6 lookups..."
+ruby-1.9.2> h.size
+ => 99
+
+---------------------------------------------------------------------------------------
+---------------------------------------------------------------------------------------
+--Example usage of BinarySearchTree (only use this if you want something lower level)--
+---------------------------------------------------------------------------------------
+---------------------------------------------------------------------------------------
+ruby-1.9.2> b = BinarySearchTree.new logger   (note: passing a logger is optional)
+ruby-1.9.2> b.insert 45, 78
+ruby-1.9.2> b.insert 23, 5
+ruby-1.9.2> b.insert 77, 999
+ruby-1.9.2> b.insert 43, 999
+ruby-1.9.2> b.find(23).value
+  DEBUG - [03/May/2011 15:23:15] "find operation completed in 2 lookups..."
+ => 5
+ruby-1.9.2> b.find(24)
+  DEBUG - [03/May/2011 15:23:32] "find operation completed in 4 lookups..."
+ => nil
+ruby-1.9.2> b.find(43).value
+  DEBUG - [03/May/2011 15:23:40] "find operation completed in 3 lookups..."
+ => 999
+ruby-1.9.2> b.max.value
+ => 999
+ruby-1.9.2> b.min.value
+ => 5
+ruby-1.9.2> b.size
+ => 4
+ruby-1.9.2> b.remove 23
+  DEBUG - [03/May/2011 15:24:41] "find operation completed in 2 lookups..."
+ruby-1.9.2> b.size
+ => 3
+ruby-1.9.2> b.clear
+ => 0
+ruby-1.9.2> b.size
+ => 0
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/binary_search_tree.gemspec

@@ -0,0 +1,20 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'binary_search_tree/version'
+
+Gem::Specification.new do |s|
+  s.name = "binary_search_tree"
+  s.version = BinarySearch::VERSION
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
+  s.authors = ["Misha Conway"]
+  s.email = "MishaAConway@gmail.com"
+  s.files = `git ls-files -z`.split("\x0")
+  s.licenses = ["MIT"]
+  s.rubyforge_project = "nowarning"
+  s.rubygems_version = "2.4.5"
+  s.summary = "A self balancing avl binary search tree class. Also includes BinarySearchTreeHash which is a hash like class that internally uses binary search tree."
+  s.add_development_dependency "rspec"
+end

data/lib/binary_search_tree.rb

@@ -1,522 +1,4 @@
-require 'active_support/core_ext/object/blank'
-class BinaryNode
-  attr_accessor :height, :parent, :left, :right, :key, :value
-
-  def initialize key, value, parent
-    @key = key
-    @value = value
-    @parent = parent
-    @height = 0
-  end
-
-  def is_leaf?
-    height.zero?
-  end
-
-  def max_children_height
-    if left.present? && right.present?
-      [left.height, right.height].max
-    elsif left.present?
-      left.height
-    elsif right.present?
-      right.height
-    else
-      -1
-    end
-  end
-
-  def balance_factor
-    (left.height rescue -1) - (right.height rescue -1)
-  end
-end
-
-
-class BinarySearchTree
-  attr_reader :size, :root
-
-  def initialize logger=nil
-    @logger = logger
-    clear
-  end
-
-  def clear
-    @root = nil
-    @size = 0
-  end
-
-  def empty?
-    @root.nil?
-  end
-
-  def find key
-    @num_comparisons = 0
-    node = locate key, @root
-    @logger.debug "find operation completed in #{@num_comparisons} lookups..." if @logger.present?
-    node
-  end
-
-  def find_value value
-    find_value_ex @root, value
-  end
-
-  def min
-    @min ||= locate_min @root
-  end
-
-  def max
-    @max ||= locate_max @root
-  end
-
-  def insert element, value
-    put element, value, @root, nil
-  end
-
-  def remove node_or_key
-    delete node_or_key
-  end
-
-  def remove_min
-    delete min
-  end
-
-  def nodes
-    @nodes = []
-    serialize_nodes @root
-    @nodes
-  end
-
-  def == other_bst
-    compare @root, other_bst.root
-  end
-
-  private
-  def invalidate_cached_values
-    @min = @max = nil
-  end
-
-  def locate target, leaf
-    @num_comparisons += 1
-    if leaf.nil?
-      return nil
-    elsif leaf.key < target
-      return locate target, leaf.right
-    elsif leaf.key > target
-      return locate target, leaf.left
-    elsif leaf.key == target
-      return leaf
-    end
-  end
-
-  def locate_min leaf
-    return nil if leaf.nil?
-    return leaf if leaf.left.nil?
-    return locate_min leaf.left
-  end
-
-  def locate_max leaf
-    return nil if leaf.nil?
-    return leaf if leaf.right.nil?
-    return locate_max leaf.right
-  end
-
-  def recompute_heights start_from_node
-    changed = true
-    node = start_from_node
-    while node && changed
-      old_height = node.height
-      if node.right.present? || node.left.present?
-        node.height = node.max_children_height + 1
-      else
-        node.height = 0
-      end
-      changed = node.height != old_height
-      node = node.parent
-    end
-  end
-
-  def put element, value, leaf, parent, link_type=nil
-    #once you reach a point where you can place a new node
-    if leaf.nil?
-      #create that new node
-      leaf = BinaryNode.new element, value, parent
-      @size += 1
-      invalidate_cached_values
-      if parent.present?
-        if 'left' == link_type
-          parent.left = leaf
-        else
-          parent.right = leaf
-        end
-      else
-        @root = leaf
-      end
-      if parent.present? && parent.height.zero?
-        #if it has a parent but it is balanced, move up
-        node = parent
-        node_to_rebalance = nil
-
-        #continue moving up until you git the root
-        while node.present?
-          node.height = node.max_children_height + 1
-          if node.balance_factor.abs > 1
-            node_to_rebalance = node
-            break
-          end
-          node = node.parent
-        end
-        #if at any point you reach an unbalanced node, rebalance it
-        rebalance node_to_rebalance if node_to_rebalance.present?
-      end
-
-    elsif leaf.key < element
-      put element, value, leaf.right, leaf, "right"
-    elsif leaf.key > element
-      put element, value, leaf.left, leaf, "left"
-    elsif leaf.key == element
-      leaf.value = value
-    end
-  end
-
-  def find_value_ex leaf, value
-    if leaf.present?
-      node_with_value = find_value_ex leaf.left, value
-      return node_with_value if node_with_value.present?
-      return leaf if leaf.value == value
-      node_with_value = find_value_ex leaf.right, value
-      return node_with_value if node_with_value.present?
-    end
-    nil
-  end
-
-  def serialize_nodes leaf
-    if !leaf.nil?
-      serialize_nodes leaf.left
-      @nodes += [leaf]
-      serialize_nodes leaf.right
-    end
-  end
-
-  def compare leaf, other_bst_leaf
-    if leaf.present? && other_bst_leaf.present?
-        leaf.value == other_bst_leaf.value &&
-        compare(leaf.left, other_bst_leaf.left) &&
-        compare(leaf.right, other_bst_leaf.right)
-    else
-      leaf.nil? && other_bst_leaf.nil?
-    end
-  end
-
-  def assert condition
-    raise "assertion failed" unless condition
-  end
-
-  def rrc_rebalance a, f
-
-    #puts "performing rrc rebalance"
-    b = a.right
-    c = b.right
-    assert a.present? && b.present? && c.present?
-    a.right = b.left
-    if a.right.present?
-      a.right.parent = a
-    end
-    b.left = a
-    a.parent = b
-    if f.nil?
-      @root = b
-      @root.parent = nil
-    else
-      if f.right == a
-        f.right = b
-      else
-        f.left = b
-      end
-      b.parent = f
-    end
-    recompute_heights a
-    recompute_heights b.parent
-  end
-
-  def rlc_rebalance a, f
-
-    #puts "performing rlc rebalance"
-    b = a.right
-    c = b.left
-    assert a.present? && b.present? && c.present?
-    b.left = c.right
-    if b.left.present?
-      b.left.parent = b
-    end
-    a.right = c.left
-    if a.right.present?
-      a.right.parent = a
-    end
-    c.right = b
-    b.parent = c
-    c.left = a
-    a.parent = c
-    if f.nil?
-      @root = c
-      @root.parent = nil
-    else
-      if f.right == a
-        f.right = c
-      else
-        f.left = c
-      end
-      c.parent = f
-    end
-    recompute_heights a
-    recompute_heights b
-  end
-
-  def llc_rebalance a, b, c, f
-    #puts "performing llc rebalance"
-    assert a.present? && b.present? && c.present?
-    a.left = b.right
-    if a.left
-      a.left.parent = a
-    end
-    b.right = a
-    a.parent = b
-    if f.nil?
-      @root = b
-      @root.parent = nil
-    else
-      if f.right == a
-        f.right = b
-      else
-        f.left = b
-      end
-      b.parent = f
-    end
-    recompute_heights a
-    recompute_heights b.parent
-  end
-
-  def lrc_rebalance a, b, c, f
-    #puts "performing lrc rebalance"
-    assert a.present? && b.present? && c.present?
-    a.left = c.right
-    if a.left.present?
-      a.left.parent = a
-    end
-    b.right = c.left
-    if b.right.present?
-      b.right.parent = b
-    end
-    c.left = b
-    b.parent = c
-    c.right = a
-    a.parent = c
-    if f.nil?
-      @root = c
-      @root.parent = nil
-    else
-      if f.right == a
-        f.right = c
-      else
-        f.left = c
-      end
-      c.parent = f
-    end
-    recompute_heights a
-    recompute_heights b
-  end
-
-  def rebalance node_to_rebalance
-    a = node_to_rebalance
-    f = a.parent #allowed to be NULL
-    if node_to_rebalance.balance_factor == -2
-      if node_to_rebalance.right.balance_factor <= 0
-        # """Rebalance, case RRC """
-        rrc_rebalance a, f
-      else
-        rlc_rebalance a, f
-        # """Rebalance, case RLC """
-      end
-    else
-      assert node_to_rebalance.balance_factor == 2
-      if node_to_rebalance.left.balance_factor >= 0
-        b = a.left
-        c = b.left
-        # """Rebalance, case LLC """
-        llc_rebalance a, b, c, f
-      else
-        b = a.left
-        c = b.right
-        #  """Rebalance, case LRC """
-        lrc_rebalance a, b, c, f
-      end
-    end
-  end
-
-  def delete node_or_key
-    if BinaryNode == node_or_key.class
-      node = node_or_key
-    else
-      node = find node_or_key
-    end
-
-    if node.present?
-      @size -= 1
-      invalidate_cached_values
-
-      #     There are three cases:
-      #
-      #     1) The node is a leaf.  Remove it and return.
-      #
-      #     2) The node is a branch (has only 1 child). Make the pointer to this node
-      #        point to the child of this node.
-      #
-      #     3) The node has two children. Swap items with the successor
-      #        of the node (the smallest item in its right subtree) and
-      #        delete the successor from the right subtree of the node.
-      if node.is_leaf?
-        remove_leaf node
-      elsif node.left.present? ^ node.right.present?
-        remove_branch node
-      else
-        assert node.left.present? && node.right.present?
-        swap_with_successor_and_remove node
-      end
-    end
-    node
-  end
-
-  def remove_leaf node
-    parent = node.parent
-    if parent.present?
-      if parent.left == node
-        parent.left = nil
-      else
-        assert parent.right == node
-        parent.right = nil
-      end
-      recompute_heights parent
-    else
-      @root = nil
-    end
-    #del node
-    # rebalance
-    node = parent
-    while node.present?
-      rebalance node if node.balance_factor.abs > 1
-      node = node.parent
-    end
-  end
-
-
-  def remove_branch node
-    parent = node.parent
-    if parent
-      if parent.left == node
-        if node.right.present?
-          parent.left = node.right
-        else
-          parent.left = node.left
-        end
-      else
-        assert parent.right == node
-        if node.right.present?
-          parent.right = node.right
-        else
-          parent.right = node.left
-        end
-      end
-      if node.left
-        node.left.parent = parent
-      else
-        assert node.right.present?
-        node.right.parent = parent
-      end
-      recompute_heights parent
-
-    end
-
-    #del node
-    # rebalance
-    node = parent
-    while node.present?
-      rebalance node if node.balance_factor.abs > 1
-      node = node.parent
-    end
-  end
-
-  def swap_with_successor_and_remove node
-    successor = locate_min node.right
-    swap_nodes node, successor
-    assert node.left.nil?
-    if node.height == 0
-      remove_leaf node
-    else
-      remove_branch node
-    end
-  end
-
-  def swap_nodes node1, node2
-    assert node1.height > node2.height
-    parent1 = node1.parent
-    left_child1 = node1.left
-    right_child1 = node1.right
-    parent2 = node2.parent
-    assert parent2.present?
-    assert parent2.left == node2 || parent2 == node1
-    left_child2 = node2.left
-    assert left_child2.nil?
-    right_child2 = node2.right
-
-    # swap heights
-    tmp = node1.height
-    node1.height = node2.height
-    node2.height = tmp
-
-    if parent1
-      if parent1.left == node1
-        parent1.left = node2
-      else
-        assert parent1.right == node1
-        parent1.right = node2
-      end
-      node2.parent = parent1
-    else
-      @root = node2
-      @root.parent = nil
-    end
-
-    node2.left = left_child1
-    left_child1.parent = node2
-    node1.left = left_child2 # None
-    node1.right = right_child2
-    if right_child2
-      right_child2.parent = node1
-    end
-    if parent2 != node1
-      node2.right = right_child1
-      right_child1.parent = node2
-
-      parent2.left = node1
-      node1.parent = parent2
-    else
-      node2.right = node1
-      node1.parent = node2
-    end
-  end
-
-
-end
-
-# #require 'binary_search_tree_hash.rb'
-# tree = BinarySearchTree.new
-# puts "inserting 9"
-# tree.insert(9, "nine")
-# puts "inserting 5"
-# tree.insert(5, "five")
-# puts "inserting 10"
-# tree.insert(10, "ten")
-# puts "inserting 1"
-# tree.insert(1, "ten")
-# puts "inserting 3"
-# tree.insert(3, "ten")
-# puts "inserting 7"
-# tree.insert(7, "ten")
+require "binary_search_tree/version"
+require 'binary_search_tree/binary_node'
+require 'binary_search_tree/binary_search_tree'
+require 'binary_search_tree/binary_search_tree_hash'