tree-red_black 0.4.2

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require 'rdoc/task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+RDoc::Task.new do |rdoc|
+  rdoc.main = "README.md"
+  rdoc.rdoc_files.include("lib/ *.rb")
+end

data/contrib/iterate_dot_graphs.rb

@@ -0,0 +1,208 @@
+#!/usr/bin/env ruby
+
+require 'tree/red_black'
+require 'benchmark'
+
+values = [*0..10]
+# values = [2, 10, 4, 5, 6, 3, 1, 0, 9, 8, 7]
+# values = [0, 2, 6, 4, 5, 3, 7, 1, 9, 8, 10]
+puts "values.size: #{values.size}"
+
+# rbt = Tree::RedBlack.new
+# values.each do |v|
+#   # rbt = rbt.insert_red_black(v)
+#   rbt.insert(v)
+# end
+
+
+rbt = rbt_copy = nil
+Benchmark.bm do |benchmark|
+  benchmark.report("insert:") do
+    # rbt = values.reduce(Tree::RedBlackNode.new) do |acc, v|
+    #   acc.insert_red_black(v)
+    # end
+    rbt = values.reduce(Tree::RedBlack.new) do |acc, v|
+      acc.insert(v)
+    end
+  end
+
+  # benchmark.report("dup:") do
+  #   rbt_copy = rbt.dup
+  # end
+end
+
+
+# rbt = rbt.insert_red_black(values.size)
+# rbt_copy = rbt_copy.insert_red_black(values.size).delete_red_black(rbt_copy.key)
+# rbt.insert(values.size)
+# rbt_copy.insert(values.size)
+
+
+File.open('dot.txt', 'w') do |file|
+  file.write "graph \"\"\n{\n  label=\"Red-Black Tree\"\n"
+
+  i = 0
+  rbt.each do |node|
+    file.write("  #{node.key} [style=filled,color=#{node.color.to_s.downcase},fontcolor=white];\n")
+    file.write("  #{node.key} -- %s;\n" % [node.left ? "#{node.left.key}" :   'NULL' + (i += 1).to_s])
+    file.write("  #{node.key} -- %s;\n" % [node.right ? "#{node.right.key}" : 'NULL' + (i += 1).to_s])
+  end
+  i.times do |n|
+    file.write("  NULL#{n + 1} [fontsize=6,shape=box,width=0.2,height=0.2,style=filled,color=gray,label=\"NULL\"];\n")
+  end
+  file.write("}\n")
+end
+
+system 'dot -Tpng -odot.png dot.txt'
+system 'open dot.png'
+
+# puts "root: #{rbt_copy.key}"
+puts "root: #{rbt.root.key}"
+puts "size: #{rbt.size}"
+
+p rbt.each.map(&:key)
+
+paths = {}
+rbt.pre_order do |node; path, count, ancestor|
+  if node.left.nil? || node.right.nil?
+    path = []
+    count = 0
+    ancestor = node
+    loop do
+      path.unshift ancestor.key
+      count += 1 if ancestor.color == :BLACK
+      break if (ancestor = ancestor.parent).nil?
+    end
+    paths[path] = count
+  end
+end
+
+# puts "paths from root (#{paths.size}):"
+# paths.each do |path, count|
+#   p path
+# end
+
+puts "black-node counts: #{paths.values.uniq}"
+
+
+def delete_keys_of_interest(rbt, deleted)
+  # puts "root: #{rbt.root.key}"
+  # puts "size: #{rbt.size}"
+
+  paths = {}
+  rbt.pre_order do |node; path, count, ancestor|
+    if node.left.nil? || node.right.nil?
+      path = []
+      count = 0
+      ancestor = node
+      loop do
+        path.unshift ancestor.key
+        count += 1 if ancestor.color == :BLACK
+        break if (ancestor = ancestor.parent).nil?
+      end
+      paths[path] = count
+    end
+  end
+
+  # puts "paths from root (#{paths.size}):"
+  # paths.each do |path, count|
+  #   p path
+  # end
+
+  # puts "black-node counts: #{paths.values.uniq}"
+
+  raise "Unbalanced tree after deleting: #{deleted}" if paths.values.uniq.size > 1
+
+  koi = rbt.each.select do |node|
+    node.color == :BLACK && node.left.nil? && node.right.nil?
+  end.map(&:key)
+  # puts "keys of interest: #{koi}"
+
+  v = koi.size > 0 ? koi.shuffle.first : rbt.root&.key
+
+  return if v.nil?
+
+  deleted << v
+  # rbt = rbt.delete_red_black(v)
+  rbt.delete(v)
+
+  delete_keys_of_interest(rbt, deleted)
+end
+
+# deleted = []
+
+# Benchmark.bm do |benchmark|
+#   # benchmark.report("koi:") do
+#   #   delete_keys_of_interest(rbt_copy, deleted)
+#   # end
+#   # rbt_copy = rbt.dup
+#   benchmark.report("delete:") do
+#     # values.each { |v| rbt_copy = rbt_copy.delete_red_black(v) }
+#     values.each { |v| rbt.delete(v) }
+#   end
+# end
+
+# # p "deleted: #{deleted}"
+# p rbt.inspect
+
+print "Value to delete? "
+n = gets.to_i
+
+toggle = 0
+while n >= 0
+  # rbt_copy = rbt.delete_red_black(n)
+  rbt.delete(n)
+
+  name = toggle == 0  ? 'dot2' : 'dot'
+  File.open(name + '.txt', 'w') do |file|
+    file.write "graph \"\"\n{\n  label=\"Red-Black Tree - #{n}\"\n"
+    # file.write "  labelfontsize=8.0\n"
+
+    i = 0
+    rbt.each do |node|
+      file.write("  #{node.key} [style=filled,color=#{node.color.to_s.downcase},fontcolor=white];\n")
+      file.write("  #{node.key} -- %s;\n" % [node.left ? "#{node.left.key}" :   'NULL' + (i += 1).to_s])
+      file.write("  #{node.key} -- %s;\n" % [node.right ? "#{node.right.key}" : 'NULL' + (i += 1).to_s])
+    end
+    i.times do |n|
+      file.write("  NULL#{n + 1} [fontsize=6,shape=box,width=0.2,height=0.2,style=filled,color=gray,label=\"NULL\"];\n")
+    end
+    file.write("}\n")
+  end
+
+  system  'dot -Tpng -o' + name + '.png ' + name + '.txt'
+  system 'open ' + name + '.png'
+
+  print "Value to delete? "
+  n = gets.to_i
+  toggle ^= 1
+end
+
+# values.delete(n)
+# values.each do |v|
+#   puts "deleting #{v}"
+#   rbt = rbt.delete_red_black(v)
+# end
+
+# puts "empty rbt: #{rbt.inspect}"
+
+
+# name = 'dot2'
+# File.open(name + '.txt', 'w') do |file|
+#   file.write "graph \"\"\n{\n  label=\"Red-Black Tree Copy\"\n"
+#   # file.write "  labelfontsize=8.0\n"
+
+#   i = 0
+#   rbt_copy.each do |node|
+#     file.write("  #{node.key} [style=filled,color=#{node.color.to_s.downcase},fontcolor=white];\n")
+#     file.write("  #{node.key} -- %s;\n" % [node.left ? "#{node.left.key}" :   'NULL' + (i += 1).to_s])
+#     file.write("  #{node.key} -- %s;\n" % [node.right ? "#{node.right.key}" : 'NULL' + (i += 1).to_s])
+#   end
+#   i.times do |n|
+#     file.write("  NULL#{n + 1} [fontsize=6,shape=box,width=0.2,height=0.2,style=filled,color=gray,label=\"NULL\"];\n")
+#   end
+#   file.write("}\n")
+# end
+
+# system  'dot -Tpng -o' + name + '.png ' + name + '.txt'
+# system 'open ' + name + '.png'

data/lib/tree-red_black.rb

@@ -0,0 +1 @@
+require 'tree/red_black'

data/lib/tree/red_black.rb

@@ -0,0 +1,243 @@
+# -*- coding: utf-8 -*-
+# coding: UTF-8
+
+require 'tree/red_black/red_black_node'
+
+module Tree
+
+  ##
+  # Tree::RedBlack is a pure-Ruby implementation of a
+  # {Red-Black tree}[https://en.wikipedia.org/wiki/Red–black_tree] --
+  # i.e., a self-balancing binary search tree with
+  # {O(log n)}[https://en.wikipedia.org/wiki/Big-O_notation]
+  # search, insert and delete operations. It is appropriate for
+  # maintaining an ordered collection where insertion and deletion
+  # are desired at arbitrary positions.
+  #
+  # The implementation differs slightly from the Wikipedia description
+  # referenced above. In particular, leaf nodes are +nil+, which
+  # affects the details of node deletion.
+
+  class RedBlack
+    include Enumerable
+
+    attr_accessor :root, :size, :allow_duplicates
+
+    ##
+    # Returns a new, empty Red-Black tree. If option +allow_duplicates+ is
+    # +false+, then only unique values are inserted in a Red-Black tree.
+    #
+    # The +root+ attribute references the root node of the tree.
+    # The +size+ attribute indicates the number of nodes in the tree.
+    # When +size+ is +0+, +root+ is always +nil+.
+    #
+    # === Example
+    #
+    #     require 'tree/red_black'
+    #
+    #     rbt = Tree::RedBlack.new
+    #     p rbt.root              #=> nil
+    #     p rbt.size              #=> 0
+    #     p rbt.allow_duplicates? #=> true
+
+    def initialize(allow_duplicates = true)
+      @root = nil
+      @size = 0
+      @allow_duplicates = allow_duplicates
+    end
+
+    def allow_duplicates?
+      @allow_duplicates
+    end
+
+    ##
+    # Inserts a value or sequence of values in a Red-Black tree and
+    # increments the +size+ attribute by the number of values
+    # inserted.
+    #
+    # Since a Red-Black tree maintains an ordered, Enumerable
+    # collection, every value inserted must be comparable with every
+    # other value. Methods +each+, +map+, +select+, +find+, +sort+,
+    # etc., can be applied directly to the tree.
+    #
+    # The individual nodes yielded by enumeration respond to method
+    # +key+ to retrieve the value stored in that node. Method +each+,
+    # in particular, is aliased to +in_order+, so that nodes are
+    # sorted in ascending order by +key+ value. Nodes can also be
+    # traversed by method +pre_order+, e.g., to generate paths in the
+    # tree.
+    #
+    # === Example
+    #
+    #     require 'tree/red_black'
+    #
+    #     rbt = Tree::RedBlack.new
+    #     rbt.insert(*1..10)      #=> #<Tree::RedBlack:0x00...>
+    #     p rbt.size              #=> 10
+    #     rbt.map(&:key)          #=> [1, 2, ..., 10]
+    #     rbt.select { |node| node.key % 2 == 0 }.map(&:key)
+    #                             #=> [2, 4, ..., 10]
+
+    def insert(*values)
+      values.each do |value; new_root|
+        new_root = (root.nil? ? RedBlackNode.new(value, :BLACK) :
+                    root.insert_red_black(value, @allow_duplicates))
+        unless new_root.nil?
+          @root = new_root
+          @size += 1
+        end
+      end
+      self
+    end
+
+    ##
+    # Deletes a value or sequence of values from a Red-Black tree.
+    #
+    # === Example
+    #
+    #     require 'tree/red_black'
+    #
+    #     rbt = Tree::RedBlack.new
+    #     rbt.insert(*1..10)      #=> #<Tree::RedBlack:0x00...>
+    #     p rbt.size              #=> 10
+    #     rbt.delete(*4..8)       #=> #<Tree::RedBlack:0x00...>
+    #     p rbt.size              #=> 5
+    #     rbt.map(&:key)          #=> [1, 2, 3, 9, 10]
+
+    def delete(*values)
+      values.each do |value; new_root|
+        new_root = root.nil? ? nil : root.delete_red_black(value)
+        unless new_root.nil?
+          @root = new_root
+          @size -= 1
+        end
+        @root = nil if size == 0
+      end
+      self
+    end
+
+    ##
+    # Returns a Red-Black tree node whose +key+ matches +value+ by
+    # binary search. If no match is found, calls non-nil +ifnone+,
+    # otherwise returns +nil+.
+    #
+    # === Example
+    #     require 'tree/red_black'
+    #
+    #     shuffled_values = [*1..10].shuffle
+    #     rbt = shuffled_values.reduce(Tree::RedBlack.new) do |acc, v|
+    #       acc.insert(v)
+    #     end
+    #     rbt.search(7)        #=> <Tree::RedBlackNode:0x00..., @key=7, ...>
+
+    def search(value, ifnone = nil)
+      root ? root.search(value, ifnone) : nil
+    end
+
+    ##
+    # Returns a Red-Black tree node satisfying a criterion defined in
+    # +block+ by binary search.
+    #
+    # If +block+ evaluates to +true+ or +false+, returns the first node
+    # for which the +block+ evaluates to +true+. In this case, the
+    # criterion is expected to return +false+ for nodes preceding
+    # the matching node and +true+ for subsequent nodes.
+    #
+    # === Example
+    #     require 'tree/red_black'
+    #
+    #     shuffled_values = [*1..10].shuffle
+    #     rbt = shuffled_values.reduce(Tree::RedBlack.new) do |acc, v|
+    #       acc.insert(v)
+    #     end
+    #     rbt.bsearch { |node| node.key >= 7 }
+    #                           #=> <Tree::RedBlackNode:0x00... @key=7 ...>
+    #
+    # If +block+ evaluates to <tt><0</tt>, +0+ or <tt>>0</tt>, returns
+    # first node for which +block+ evaluates to +0+. Otherwise returns
+    # +nil+. In this case, the criterion is expected to return
+    # <tt><0</tt> for nodes preceding the matching node, +0+ for some
+    # subsequent nodes and <tt>>0</tt> for nodes beyond that.
+    #
+    # === Example
+    #     require 'tree/red_black'
+    #
+    #     shuffled_values = [*1..10].shuffle
+    #     rbt = shuffled_values.reduce(Tree::RedBlack.new) do |acc, v|
+    #       acc.insert(v)
+    #     end
+    #     rbt.bsearch { |node| 7 <=> node.key }
+    #                           #=> <Tree::RedBlackNode:0x00... @key=7 ...>
+    #
+    # If +block++ is not given, returns an enumerator.
+
+    def bsearch(&block)
+      return enum_for(:bsearch) unless block_given?
+
+      root ? root.bsearch(&block) : nil
+    end
+
+    ##
+    # Returns an enumerator for nodes in a Red-Black tree by pre-order
+    # traversal.
+    #
+    # === Example
+    #     require 'tree/red_black'
+    #
+    #     rbt = Tree::RedBlack.new
+    #     rbt.insert(*1..10)              #=> #<Tree::RedBlack:0x00...>
+    #     rbt.pre_order.map(&:key)        #=> [4, 2, 1, 3, 6, 5, 8, 7, 9, 10]
+
+    def pre_order(&block)
+      return enum_for(:pre_order) unless block_given?
+      return if root.nil?
+
+      root.pre_order(&block)
+    end
+
+    ##
+    # Returns an enumerator for nodes in a Red-Black tree by in-order
+    # traversal. The +each+ method is aliased to +in_order+
+    #
+    # === Example
+    #     require 'tree/red_black'
+    #
+    #     rbt = Tree::RedBlack.new
+    #     shuffled_values = [*1..10].shuffle
+    #     rbt.insert(*shuffled_values)
+    #     rbt.in_order.map(&:key)        #=> [1, 2, ..., 10]
+
+    def in_order(&block)
+      return enum_for(:in_order) unless block_given?
+      return if root.nil?
+
+      root.in_order(&block)
+    end
+
+    ##
+    # Returns a deep copy of a Red-Black tree, provided that the
+    # +dup+ method for values in the tree is also a deep copy.
+    #
+    # === Example
+    #
+    #     require 'tree/red_black'
+    #
+    #     rbt = Tree::RedBlack.new
+    #     rbt.insert({a: 1, b: 2})
+    #     rbt_copy = rbt.dup
+    #     p rbt.root.key            #=> {:a=>1, :b=>2}
+    #     p rbt.root.key.delete(:a) #=> 1
+    #     p rbt.root.key            #=> {:b=>2}
+    #     p rbt_copy.root.key       #=> {:a=>1, :b=>2}
+
+    def dup
+      copy = RedBlack.new
+      copy.size = size
+      copy.allow_duplicates = allow_duplicates
+      copy.root = root.dup
+      copy
+    end
+
+    alias each in_order
+  end
+end