avl_tree 1.0.0

data/README

@@ -0,0 +1,21 @@
+avl_tree - Naive implementation of AVL tree for Ruby
+Copyright (C) 2012 Hiroshi Nakamura <nahi@ruby-lang.org>
+
+
+== TODO
+
+It's still under development.
+
+
+== Author
+
+Name:: Hiroshi Nakamura
+E-mail:: nahi@ruby-lang.org
+Project web site:: http://github.com/nahi/radix_tree
+
+
+== License
+
+This program is copyrighted free software by Hiroshi Nakamura.  You can
+redistribute it and/or modify it under the same terms of Ruby's license;
+either the dual license version in 2003, or any later version.

data/bench/bench.rb

@@ -0,0 +1,50 @@
+require 'benchmark'
+require 'radix_tree' # gem install radix_tree
+require 'avl_tree'
+
+random = Random.new(0)
+
+TIMES = 100000
+key_size = 10
+
+def aset(h, keys)
+  keys.each do |k|
+    h[k] = 1
+  end
+end
+
+def aref(h, keys)
+  keys.each do |k|
+    h[k]
+  end
+end
+
+def delete(h, keys)
+  keys.each do |k|
+    h.delete(k)
+  end
+end
+
+def run(bm, h, keys)
+  name = h.class.name
+  bm.report("#{name} aset") do
+    aset(h, keys)
+  end
+  bm.report("#{name} aref") do
+    aref(h, keys)
+  end
+  bm.report("#{name} delete") do
+    delete(h, keys)
+  end
+end
+
+keys = []
+TIMES.times do
+  keys << random.bytes(key_size)
+end
+
+Benchmark.bmbm do |bm|
+  run(bm, Hash.new, keys)
+  run(bm, RadixTree.new, keys)
+  run(bm, AVLTree.new, keys)
+end

data/bench/bench_element_size.rb

@@ -0,0 +1,52 @@
+require 'benchmark'
+require 'radix_tree' # gem install radix_tree
+require 'avl_tree'
+
+random = Random.new(0)
+
+times = 100000
+key_size = 10
+
+def aset(h, keys)
+  keys.each do |k|
+    h[k] = 1
+  end
+end
+
+def aref(h, keys)
+  keys.each do |k|
+    h[k]
+  end
+end
+
+def delete(h, keys)
+  keys.each do |k|
+    h.delete(k)
+  end
+end
+
+def run(bm, h, keys)
+  name = h.class.name
+  bm.report("#{name} aset (#{keys.size})") do
+    aset(h, keys)
+  end
+  bm.report("#{name} aref (#{keys.size})") do
+    aref(h, keys)
+  end
+  bm.report("#{name} delete (#{keys.size})") do
+    delete(h, keys)
+  end
+end
+
+[10000, 20000, 50000, 100000, 200000, 500000].each do |elements|
+  keys = []
+  elements.times do
+    keys << random.bytes(key_size)
+  end
+
+  Benchmark.bm(30) do |bm|
+    run(bm, Hash.new, keys)
+    run(bm, RadixTree.new, keys)
+    run(bm, AVLTree.new, keys)
+  end
+end

data/bench/profile.rb

@@ -0,0 +1,13 @@
+require File.expand_path('../lib/avl_tree', File.dirname(__FILE__))
+
+random = Random.new(0)
+
+TIMES = 200000
+key_size = 10
+
+h = AVLTree.new
+TIMES.times do
+  h[random.bytes(key_size)] = 1
+  h[random.bytes(key_size)]
+  h.delete(random.bytes(key_size))
+end

data/lib/avl_tree.rb

@@ -0,0 +1,454 @@
+class AVLTree
+  include Enumerable
+
+  class Node
+    UNDEFINED = Object.new
+
+    class EmptyNode
+      def empty?
+        true
+      end
+
+      def height
+        0
+      end
+
+      def value
+        nil
+      end
+
+      def size
+        0
+      end
+
+      def each(&block)
+        # intentionally blank
+      end
+
+      # returns new_root
+      def store(key, value)
+        Node.new(key, value)
+      end
+
+      # returns value
+      def retrieve(key)
+        UNDEFINED
+      end
+
+      # returns [deleted_node, new_root]
+      def delete(key)
+        [self, self]
+      end
+
+      def dump_tree(io, indent = '')
+        # intentionally blank
+      end
+
+      def dump_sexp
+        # intentionally blank
+      end
+
+      def rotate
+        self
+      end
+
+      def update_height
+        # intentionally blank
+      end
+
+      # for debugging
+      def check_height
+        # intentionally blank
+      end
+    end
+    EMPTY = Node::EmptyNode.new
+
+    attr_reader :key, :value, :height
+    attr_reader :left, :right
+
+    def initialize(key, value)
+      @key, @value = key, value
+      @left = @right = EMPTY
+      @height = 1
+    end
+
+    def empty?
+      false
+    end
+
+    def size
+      @left.size + 1 + @right.size
+    end
+
+    # inorder
+    def each(&block)
+      @left.each(&block)
+      yield [@key, @value]
+      @right.each(&block)
+    end
+    
+    def each_key
+      each do |k, v|
+        yield k
+      end
+    end
+    
+    def each_value
+      each do |k, v|
+        yield v
+      end
+    end
+
+    def keys
+      collect { |k, v| k }
+    end
+
+    def values
+      collect { |k, v| v }
+    end
+
+    # returns new_root
+    def store(key, value)
+      case key <=> @key
+      when -1
+        @left = @left.store(key, value)
+      when 0
+        @value = value
+      when 1
+        @right = @right.store(key, value)
+      end
+      rotate
+    end
+
+    # returns value
+    def retrieve(key)
+      case key <=> @key
+      when -1
+        @left.retrieve(key)
+      when 0
+        @value
+      when 1
+        @right.retrieve(key)
+      end
+    end
+
+    # returns [deleted_node, new_root]
+    def delete(key)
+      case key <=> @key
+      when -1
+        deleted, @left = @left.delete(key)
+        [deleted, self.rotate]
+      when 0
+        [self, delete_self.rotate]
+      when 1
+        deleted, @right = @right.delete(key)
+        [deleted, self.rotate]
+      end
+    end
+
+    def delete_min
+      if @left.empty?
+        [self, delete_self]
+      else
+        deleted, @left = @left.delete_min
+        [deleted, rotate]
+      end
+    end
+
+    def delete_max
+      if @right.empty?
+        [self, delete_self]
+      else
+        deleted, @right = @right.delete_max
+        [deleted, rotate]
+      end
+    end
+
+    def dump_tree(io, indent = '')
+      @right.dump_tree(io, indent + '  ')
+      io << indent << sprintf("#<%s:0x%010x %d %s> => %s", self.class.name, __id__, height, @key.inspect, @value.inspect) << $/
+      @left.dump_tree(io, indent + '  ')
+    end
+
+    def dump_sexp
+      left = @left.dump_sexp
+      right = @right.dump_sexp
+      if left or right
+        '(' + [@key, left || '-', right].compact.join(' ') + ')'
+      else
+        @key
+      end
+    end
+
+    # for debugging
+    def check_height
+      @left.check_height
+      @right.check_height
+      lh = @left.height
+      rh = @right.height
+      if (lh - rh).abs > 1
+        puts dump_tree(STDERR)
+        raise "height unbalanced: #{lh} #{height} #{rh}"
+      end
+      if (lh > rh ? lh : rh) + 1 != height
+        puts dump_tree(STDERR)
+        raise "height calc failure: #{lh} #{height} #{rh}"
+      end
+    end
+
+  protected
+
+    def left=(left)
+      @left = left
+    end
+
+    def right=(right)
+      @right = right
+    end
+
+    def update_height
+      @height = (@left.height > @right.height ? @left.height : @right.height) + 1
+    end
+
+    def rotate
+      case @left.height - @right.height
+      when +2
+        if @left.left.height >= @left.right.height
+          root = rotate_LL
+        else
+          root = rotate_LR
+        end
+      when -2
+        if @right.left.height <= @right.right.height
+          root = rotate_RR
+        else
+          root = rotate_RL
+        end
+      else
+        root = self
+      end
+      root.update_height
+      root
+    end
+
+  private
+
+    def delete_self
+      if @left.empty? and @right.empty?
+        deleted = EMPTY
+      elsif @right.height < @left.height
+        deleted, new_left = @left.delete_max
+        deleted.left, deleted.right = new_left, @right
+      else
+        deleted, new_right = @right.delete_min
+        deleted.left, deleted.right = @left, new_right
+      end
+      deleted
+    end
+
+    # Right single rotation
+    # (B a (D c E)) where D-a > 1 && E > c --> (D (B a c) E)
+    #
+    #   B              D
+    #  / \            / \
+    # a   D    ->    B   E
+    #    / \        / \
+    #   c   E      a   c
+    #
+    def rotate_RR
+      root = @right
+      @right = root.left
+      root.left = self
+      root.left.update_height
+      root
+    end
+
+    # Left single rotation
+    # (D (B A c) e) where B-e > 1 && A > c --> (B A (D c e))
+    #
+    #     D          B
+    #    / \        / \
+    #   B   e  ->  A   D
+    #  / \            / \
+    # A   c          c   e
+    #
+    def rotate_LL
+      root = @left
+      @left = root.right
+      root.right = self
+      root.right.update_height
+      root
+    end
+
+    # Right double rotation
+    # (B a (F (D c e) g)) where F-a > 1 && D > g --> (D (B a c) (F e g))
+    #
+    #   B               D
+    #  / \            /   \
+    # a   F    ->    B     F
+    #    / \        / \   / \
+    #   D   g      a   c e   g
+    #  / \
+    # c   e
+    #
+    def rotate_RL
+      other = @right
+      root = other.left
+      @right = root.left
+      other.left = root.right
+      root.left = self
+      root.right = other
+      root.left.update_height
+      root.right.update_height
+      root
+    end
+
+    # Left double rotation
+    # (F (B a (D c e)) g) where B-g > 1 && D > a --> (d (B a c) (F e g))
+    #
+    #     F             D
+    #    / \          /   \
+    #   B   g  ->    B     F
+    #  / \          / \   / \
+    # a   D        a   c e   g
+    #    / \
+    #   c   e
+    #
+    def rotate_LR
+      other = @left
+      root = other.right
+      @left = root.right
+      other.right = root.left
+      root.right = self
+      root.left = other
+      root.left.update_height
+      root.right.update_height
+      root
+    end
+
+    def collect
+      pool = []
+      each do |key, value|
+        pool << yield(key, value)
+      end
+      pool
+    end
+  end
+
+  DEFAULT = Object.new
+
+  attr_accessor :default
+  attr_reader :default_proc
+  
+  def initialize(default = DEFAULT, &block)
+    if block && default != DEFAULT
+      raise ArgumentError, 'wrong number of arguments'
+    end
+    @root = Node::EMPTY
+    @default = default
+    @default_proc = block
+  end
+
+  def empty?
+    @root == Node::EMPTY
+  end
+
+  def size
+    @root.size
+  end
+  alias length size
+
+  def each(&block)
+    if block_given?
+      @root.each(&block)
+      self
+    else
+      Enumerator.new(@root)
+    end
+  end
+  alias each_pair each
+
+  def each_key
+    if block_given?
+      @root.each do |k, v|
+        yield k
+      end
+      self
+    else
+      Enumerator.new(@root, :each_key)
+    end
+  end
+
+  def each_value
+    if block_given?
+      @root.each do |k, v|
+        yield v
+      end
+      self
+    else
+      Enumerator.new(@root, :each_value)
+    end
+  end
+
+  def keys
+    @root.keys
+  end
+
+  def values
+    @root.values
+  end
+
+  def clear
+    @root = Node::EMPTY
+  end
+
+  def []=(key, value)
+    @root = @root.store(key.to_s, value)
+  end
+  alias store []=
+
+  def key?(key)
+    @root.retrieve(key.to_s) != Node::UNDEFINED
+  end
+  alias has_key? key?
+
+  def [](key)
+    value = @root.retrieve(key.to_s)
+    if value == Node::UNDEFINED
+      default_value
+    else
+      value
+    end
+  end
+
+  def delete(key)
+    deleted, @root = @root.delete(key.to_s)
+    deleted.value
+  end
+
+  def dump_tree(io = '')
+    @root.dump_tree(io)
+    io << $/
+    io
+  end
+
+  def dump_sexp
+    @root.dump_sexp || ''
+  end
+
+  def to_hash
+    inject({}) { |r, (k, v)| r[k] = v; r }
+  end
+
+private
+
+  def default_value
+    if @default != DEFAULT
+      @default
+    elsif @default_proc
+      @default_proc.call
+    else
+      nil
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,7 @@
+begin
+  require 'simplecov'
+  SimpleCov.start
+rescue LoadError
+end
+require "test/unit"
+require "avl_tree"

data/test/test_avl_tree.rb

@@ -0,0 +1,445 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('./helper', File.dirname(__FILE__))
+
+class TestAVLTree < Test::Unit::TestCase
+  def test_tree_rotate_RR
+    h = AVLTree.new
+    assert_equal '', h.dump_sexp
+    h['a'] = 1
+    assert_equal 'a', h.dump_sexp
+    h['b'] = 2
+    assert_equal '(a - b)', h.dump_sexp
+    h['c'] = 3
+    assert_equal '(b a c)', h.dump_sexp
+    h['d'] = 4
+    assert_equal '(b a (c - d))', h.dump_sexp
+    h['e'] = 5
+    assert_equal '(b a (d c e))', h.dump_sexp
+  end
+
+  def test_tree_rotate_LL
+    h = AVLTree.new
+    h['e'] = 1
+    h['d'] = 2
+    assert_equal '(e d)', h.dump_sexp
+    h['c'] = 3
+    assert_equal '(d c e)', h.dump_sexp
+    h['b'] = 4
+    assert_equal '(d (c b) e)', h.dump_sexp
+    h['a'] = 5
+    assert_equal '(d (b a c) e)', h.dump_sexp
+  end
+
+  def test_tree_rotate_RL
+    h = AVLTree.new
+    h['b'] = 1
+    h['a'] = 2
+    h['e'] = 3
+    h['d'] = 4
+    h['f'] = 5
+    assert_equal '(b a (e d f))', h.dump_sexp
+    h['c'] = 6
+    assert_equal '(d (b a c) (e - f))', h.dump_sexp
+  end
+
+  def test_tree_rotate_LR
+    h = AVLTree.new
+    h['g'] = 1
+    h['b'] = 2
+    h['h'] = 3
+    h['i'] = 4
+    h['a'] = 5
+    h['d'] = 6
+    h['0'] = 7
+    h['c'] = 8
+    h['e'] = 9
+    assert_equal '(g (b (a 0) (d c e)) (h - i))', h.dump_sexp
+    h['f'] = 10
+    assert_equal '(d (b (a 0) c) (g (e - f) (h - i)))', h.dump_sexp
+  end
+
+  def test_aref_nil
+    h = AVLTree.new
+    h['abc'] = 1
+    assert_equal nil, h['def']
+  end
+
+  def test_empty
+    h = AVLTree.new
+    h['abc'] = 0
+    assert_equal nil, h['']
+    h[''] = 1
+    assert_equal 1, h['']
+    h.delete('')
+    assert_equal nil, h['']
+  end
+
+  def test_aref_single
+    h = AVLTree.new
+    h['abc'] = 1
+    assert_equal 1, h['abc']
+  end
+
+  def test_aref_double
+    h = AVLTree.new
+    h['abc'] = 1
+    h['def'] = 2
+    assert_equal 1, h['abc']
+    assert_equal 2, h['def']
+  end
+
+  def test_aset_override
+    h = AVLTree.new
+    h['abc'] = 1
+    h['abc'] = 2
+    assert_equal 2, h['abc']
+  end
+
+  def test_split
+    h = AVLTree.new
+    h['abcd'] = 1
+    assert_equal 1, h['abcd']
+    h['abce'] = 2
+    assert_equal 1, h['abcd']
+    assert_equal 2, h['abce']
+    h['abd'] = 3
+    assert_equal 1, h['abcd']
+    assert_equal 2, h['abce']
+    assert_equal 3, h['abd']
+    h['ac'] = 4
+    assert_equal 1, h['abcd']
+    assert_equal 2, h['abce']
+    assert_equal 3, h['abd']
+    assert_equal 4, h['ac']
+  end
+
+  def test_split_and_assign
+    h = AVLTree.new
+    h['ab'] = 1
+    h['a'] = 2
+    assert_equal 1, h['ab']
+    assert_equal 2, h['a']
+  end
+
+  def test_push
+    h = AVLTree.new
+    assert_equal 0, h.size
+    h['a'] = 1
+    assert_equal 1, h['a']
+    h['ab'] = 2
+    assert_equal 1, h['a']
+    assert_equal 2, h['ab']
+    h['abc'] = 3
+    assert_equal 1, h['a']
+    assert_equal 2, h['ab']
+    assert_equal 3, h['abc']
+    h['abd'] = 4
+    assert_equal 1, h['a']
+    assert_equal 2, h['ab']
+    assert_equal 3, h['abc']
+    assert_equal 4, h['abd']
+    h['ac'] = 5
+    assert_equal 1, h['a']
+    assert_equal 2, h['ab']
+    assert_equal 3, h['abc']
+    assert_equal 4, h['abd']
+    assert_equal 5, h['ac']
+    h['b'] = 6
+    assert_equal 1, h['a']
+    assert_equal 2, h['ab']
+    assert_equal 3, h['abc']
+    assert_equal 4, h['abd']
+    assert_equal 5, h['ac']
+    assert_equal 6, h['b']
+    assert_equal ['a', 'ab', 'abc', 'abd', 'ac', 'b'].sort, h.keys.sort
+    assert_equal 6, h.size
+  end
+
+  def test_delete_leaf
+    h = AVLTree.new
+    h['b'] = 1
+    h['a'] = 2
+    h['c'] = 3
+    assert_equal 2, h['a']
+    h.delete('a')
+    assert_equal nil, h['a']
+  end
+
+  def test_delete_leaf_single_rotation
+    h = AVLTree.new
+    h['b'] = 1
+    h['a'] = 2
+    h['d'] = 3
+    h['c'] = 4
+    h['e'] = 5
+    assert_equal '(b a (d c e))', h.dump_sexp
+    h.delete('a')
+    assert_equal '(d (b - c) e)', h.dump_sexp
+  end
+
+  def test_delete_leaf_double_rotation
+    h = AVLTree.new
+    h['b'] = 1
+    h['a'] = 2
+    h['e'] = 3
+    h['0'] = 4
+    h['c'] = 5
+    h['f'] = 6
+    h['d'] = 7
+    assert_equal '(b (a 0) (e (c - d) f))', h.dump_sexp
+    h.delete('0')
+    assert_equal '(c (b a) (e d f))', h.dump_sexp
+  end
+
+  def test_delete_node_right
+    h = AVLTree.new
+    h['c'] = 1
+    h['b'] = 2
+    h['g'] = 3
+    h['a'] = 4
+    h['e'] = 5
+    h['i'] = 6
+    h['d'] = 7
+    h['f'] = 8
+    h['h'] = 9
+    h['j'] = 10
+    assert_equal '(c (b a) (g (e d f) (i h j)))', h.dump_sexp
+    h.delete('g')
+    assert_equal '(c (b a) (h (e d f) (i - j)))', h.dump_sexp
+  end
+
+  def test_delete_node_left
+    h = AVLTree.new
+    h['c'] = 1
+    h['b'] = 2
+    h['d'] = 3
+    h['a'] = 4
+    assert_equal '(c (b a) d)', h.dump_sexp
+    h.delete('b')
+    assert_equal '(c a d)', h.dump_sexp
+  end
+
+  def test_delete_root
+    h = AVLTree.new
+    h['b'] = 1
+    h['a'] = 2
+    h['c'] = 3
+    assert_equal 1, h['b']
+    assert_equal '(b a c)', h.dump_sexp
+    h.delete('b')
+    assert_equal '(c a)', h.dump_sexp
+    assert_equal nil, h['b']
+  end
+
+  def test_delete
+    h = AVLTree.new
+    h['a'] = 1
+    h['ab'] = 2
+    h['abc'] = 3
+    h['abd'] = 4
+    h['ac'] = 5
+    h['b'] = 6
+    assert_equal 6, h.size
+    assert_equal nil, h.delete('XXX')
+    # delete leaf
+    assert_equal 4, h.delete('abd')
+    assert_equal 5, h.size
+    assert_equal 1, h['a']
+    assert_equal 2, h['ab']
+    assert_equal 3, h['abc']
+    assert_equal nil, h['abd']
+    assert_equal 5, h['ac']
+    assert_equal 6, h['b']
+    # delete single leaf node
+    assert_equal 2, h.delete('ab')
+    assert_equal 4, h.size
+    assert_equal 1, h['a']
+    assert_equal nil, h['ab']
+    assert_equal 3, h['abc']
+    assert_equal nil, h['abd']
+    assert_equal 5, h['ac']
+    assert_equal 6, h['b']
+    # delete multiple leaf node
+    assert_equal 1, h.delete('a')
+    assert_equal 3, h.size
+    assert_equal nil, h['a']
+    assert_equal nil, h['ab']
+    assert_equal 3, h['abc']
+    assert_equal nil, h['abd']
+    assert_equal 5, h['ac']
+    assert_equal 6, h['b']
+    assert_equal ['abc', 'ac', 'b'].sort, h.keys.sort
+    # delete rest
+    assert_equal 3, h.delete('abc')
+    assert_equal 5, h.delete('ac')
+    assert_equal 6, h.delete('b')
+    assert_equal 0, h.size
+    assert h.empty?
+  end
+
+  def test_delete_compaction_middle
+    h = AVLTree.new
+    h['a'] = 1
+    h['abc'] = 2
+    h['bb'] = 3
+    h['abcdefghi'] = 4
+    h['abcdefghijzz'] = 5
+    h['abcdefghikzz'] = 6
+    assert_equal 6, h.dump_tree.split($/).size
+    h.delete('a')
+    assert_equal 5, h.dump_tree.split($/).size
+    h['a'] = 1
+    assert_equal 6, h.dump_tree.split($/).size
+  end
+
+  def test_delete_compaction_leaf
+    h = AVLTree.new
+    h['a'] = 1
+    h['abc'] = 2
+    h['bb'] = 3
+    h['abcdefghijzz'] = 4
+    assert_equal 4, h.dump_tree.split($/).size
+    h['abcdefghikzz'] = 5
+    assert_equal 5, h.dump_tree.split($/).size
+    h.delete('abcdefghijzz')
+    assert_equal 4, h.dump_tree.split($/).size
+    h['abcdefghijzz'] = 4
+    assert_equal 5, h.dump_tree.split($/).size
+  end
+
+  def test_each
+    h = AVLTree.new
+    s = { 'aa' => 1, 'ab' => 2, 'bb' => 3, 'bc' => 4, 'a' => 5, 'abc' => 6 }
+    s.each do |k, v|
+      h[k] = v
+    end
+    assert_equal s.to_a.sort_by { |k, v| k }, h.each.sort_by { |k, v| k }
+    #
+    values = []
+    h.each do |k, v|
+      values << [k, v]
+    end
+    assert_equal s.to_a.sort_by { |k, v| k }, values.sort_by { |k, v| k }
+  end
+
+  def test_each_key
+    h = AVLTree.new
+    s = { 'aa' => 1, 'ab' => 2, 'bb' => 3, 'bc' => 4, 'a' => 5, 'abc' => 6 }
+    s.each do |k, v|
+      h[k] = v
+    end
+    assert_equal s.keys.sort, h.each_key.sort
+    #
+    values = []
+    h.each_key do |k|
+      values << k
+    end
+    assert_equal s.keys.sort, values.sort
+  end
+
+  def test_each_value
+    h = AVLTree.new
+    s = { 'aa' => 1, 'ab' => 2, 'bb' => 3, 'bc' => 4, 'a' => 5, 'abc' => 6, 'azzzzz' => 6 }
+    s.each do |k, v|
+      h[k] = v
+    end
+    assert_equal s.values.sort, h.each_value.sort
+    #
+    values = []
+    h.each_value do |v|
+      values << v
+    end
+    assert_equal s.values.sort, values.sort
+  end
+
+  def test_keys
+    h = AVLTree.new
+    s = { 'aa' => 1, 'ab' => 2, 'bb' => 3, 'bc' => 4, 'a' => 5, 'abc' => 6 }
+    s.each do |k, v|
+      h[k] = v
+    end
+    assert_equal s.keys.sort, h.keys.sort
+  end
+
+  def test_values
+    h = AVLTree.new
+    s = { 'aa' => 1, 'ab' => 2, 'bb' => 3, 'bc' => 4, 'a' => 5, 'abc' => 6 }
+    s.each do |k, v|
+      h[k] = v
+    end
+    assert_equal s.values.sort, h.values.sort
+  end
+
+  def test_to_s
+    h = AVLTree.new
+    h[:abc] = 1
+    assert_equal 1, h["abc"]
+    assert_equal 1, h[:abc]
+  end
+
+  def test_key?
+    h = AVLTree.new
+    assert !h.key?('a')
+    s = { 'aa' => 1, 'ab' => 2, 'bb' => 3, 'bc' => 4, 'a' => 5, 'abc' => 6 }
+    s.each do |k, v|
+      h[k] = v
+    end
+    assert h.key?('a')
+  end
+
+  def test_default
+    assert_raise(ArgumentError) do
+      AVLTree.new('both') { :not_allowed }
+    end
+
+    h = AVLTree.new('abc')
+    assert_equal 'abc', h['foo']
+    assert_equal 'abc', h['bar']
+    assert h['baz'].object_id == h['qux'].object_id
+
+    h = AVLTree.new { [1, 2] }
+    assert_equal [1, 2], h['foo']
+    assert_equal [1, 2], h['bar']
+    assert h['baz'].object_id != h['qux'].object_id
+  end
+
+  def test_to_hash
+    h = AVLTree.new
+    s = { 'aa' => 1, 'ab' => 2, 'bb' => 3, 'bc' => 4, 'a' => 5, 'abc' => 6 }
+    s.each do |k, v|
+      h[k] = v
+    end
+    assert_equal s, h.to_hash
+  end
+
+  def test_clear
+    h = AVLTree.new
+    s = { 'aa' => 1, 'ab' => 2, 'bb' => 3, 'bc' => 4, 'a' => 5, 'abc' => 6 }
+    s.each do |k, v|
+      h[k] = v
+    end
+    assert_equal s, h.to_hash
+    h.clear
+    assert_equal 0, h.size
+    assert h.to_hash.empty?
+  end
+
+  if RUBY_VERSION >= '1.9.0'
+    # In contrast to RadixTree, AVLTree just uses String#<=> as-is
+    def test_encoding
+      h = AVLTree.new
+      s = { '$B$"$"(B' => 1, '$B$"$$(B' => 2, '$B$$$$(B' => 3, '$B$$$&(B' => 4, '$B$"(B' => 5, '$B$"$$$&(B' => 6 }
+      s.each do |k, v|
+        h[k] = v
+      end
+      assert_equal 6, h.size
+      s.each do |k, v|
+        assert_equal v, h[k]
+      end
+      str = '$B$"$"(B'
+      str.force_encoding('US-ASCII')
+      # it's nil for RadixTree because RadixTree uses char-to-char comparison
+      assert_equal 1, h[str]
+    end
+  end
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: avl_tree
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Hiroshi Nakamura
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-13 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: nahi@ruby-lang.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/avl_tree.rb
+- bench/bench_element_size.rb
+- bench/profile.rb
+- bench/bench.rb
+- test/helper.rb
+- test/test_avl_tree.rb
+- README
+homepage: http://github.com/nahi/avl_tree
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Naive implementation of AVL tree for Ruby
+test_files: []