ruby-avl 0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7a02458c007e726e16b423af5bec30aabd799260
+  data.tar.gz: e0e82835afd930aff2858a6083b2357c084d300e
+SHA512:
+  metadata.gz: 3fd204050d57a8f9918d2487bec619d82043352f0052f71bc75932db3e869ef2e959b02ec094b8252c14986a69c321b23403f5c99634f0f0ac0f012fb3388f4c
+  data.tar.gz: d45ac33cc6aa5850cfe309873000c36b81b66f0f6ef94860988e9e8e4b6e650bd5331c8f6593b10fbabbf9ab107b3eddb6fd788c7866873a49b112c338a2ac5e

data/.gitignore

@@ -0,0 +1 @@
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Rakefile

@@ -0,0 +1,7 @@
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+rescue LoadError
+end
+
+task default: :spec

data/lib/ruby-avl.rb

@@ -0,0 +1,6 @@
+require 'ruby-avl/bs_tree'
+require 'ruby-avl/node'
+require 'ruby-avl/avl_tree'
+require 'ruby-avl/bs_tree_traversal'
+
+module AVLTree; end

data/lib/ruby-avl/avl_tree.rb

@@ -0,0 +1,91 @@
+require_relative 'bs_tree'
+module AVLTree
+  class AVLTree < BSTree::BSTree
+
+    # Public interfaces implemented in superclass
+
+    private
+
+    # Calls superclass (BSTree) method passing in parameters
+    # recieved from caller. Passes in the returned value of
+    # BSTree#add_to_tree to :rebalance and returns final result.
+    def add_to_tree(item, node)
+      return rebalance(super(item, node))
+    end
+
+    # Calls superclass (BSTree) method passing in parameters
+    # recieved from caller. Passes in the returned value of
+    # BSTree#remove_from_tree to :rebalance and returns final
+    # result.
+    def remove_from_tree(item, node)    
+      return rebalance(super(item, node))
+    end
+
+    # Checks the balance factor of the node and rotates the tree
+    # if inbalanced in any way. Balance algorithm:
+    # IF tree is right heavy
+    #   IF tree's right subtree is left heavy (Right Left Case)
+    #      Perform Double Left rotation
+    #   ELSE (Right Right Case)
+    #      Perform Single Left rotation
+    # ELSE IF tree is left heavy
+    #   IF tree's left subtree is right heavy (Left Right Case)
+    #      Perform Double Right rotation
+    #   ELSE (Left Left Case)
+    #      Perform Single Right rotation
+    # END IF
+    def rebalance(node)
+      if balance_factor(node) >= 2
+        if (balance_factor(node.left) < 0)
+          return double_rotate_right(node)
+        else
+          return rotate_right(node)
+        end
+      elsif balance_factor(node) <= -2
+        if (balance_factor(node.right) > 0)
+          return double_rotate_left(node)
+        else
+          return rotate_left(node)
+        end
+      else
+        return node
+      end
+    end
+
+    # Node becomes the left subtree of it's right subtree.
+    def rotate_left(node)
+      new_node = node.right
+      node.right = new_node.left
+      new_node.left = node
+      return new_node
+    end
+
+    # Right rotation performed on node's right subtree before
+    # node is rotated left.
+    def double_rotate_left(node)
+      node.right = rotate_right(node.right)
+      return rotate_left(node)
+    end
+
+    # Node becomes the right subtree of it's left subtree.
+    def rotate_right(node)
+      new_node = node.left
+      node.left = new_node.right
+      new_node.right = node
+      return new_node
+    end
+
+    # Left rotation performed on node's left subtree before
+    # node is rotated right.
+    def double_rotate_right(node)
+      node.left = rotate_left(node.left)
+      return rotate_right(node)    
+    end
+
+    # Calculates the height of the left subtree, then subtracts the height of the
+    # right subtree to produce the balance factor for the node.
+    def balance_factor(node)
+      node.nil? ? 0 : (height(node.left) - height(node.right))
+    end
+  end
+end

data/lib/ruby-avl/bs_tree.rb

@@ -0,0 +1,117 @@
+module BSTree  
+  class BSTree
+
+    attr_reader :root
+
+    def initialize(root = nil)
+      @root = root  
+    end
+
+    # Starts the search for the insertion at the root of
+    # the tree. Set the new root at the end if it has changed.
+    def insert_item(item)
+      @root = add_to_tree(item, @root)      
+    end
+
+    # Starts the search for the deletion at the root of
+    # the tree. Set the new root at the end if it has changed.
+    def remove_item(item)
+      @root = remove_from_tree(item, @root)
+    end
+
+    # Starts the count at the root node.
+    def number_of_nodes
+      node_count(@root)
+    end
+
+    # Starts the count of the depth at the root node.
+    def depth_of_tree
+      tree_depth(@root, 0)
+    end
+
+    private
+
+    # If the current node is null then a new Node object is created and item
+    # is passed in as a constructor. If item is smaller than the data stored
+    # in the current node then :add_to_tree is called recursively to traverse
+    # the left-sub tree until the node is null. The same thing happens if the 
+    # item is larger, but the right sub-tree is traversed. If item is neither
+    # larger nor smaller then it must be equal, in which case an error will be
+    # raised to inform the user of duplication.
+    def add_to_tree(item, node)
+      if node.nil?
+        return Node::Node.new(item)
+      elsif compare(item, node.data) < 0
+        node.left = add_to_tree(item, node.left)
+      elsif compare(item, node.data) > 0
+        node.right = add_to_tree(item, node.right)
+      else
+        puts 'Duplicate entry. Skipping: %s' % item
+      end
+      return node
+    end
+
+    # If the current node is null then the tree is empty or the item isn't in it. 
+    # If item is smaller or larger than current node like above, if it's neither then
+    # it must be equal so checks are made to see how many children that node has. If
+    # it has two then a the value of the node is swapped with the value of the
+    # smallest item in it's right-sub tree, then removeItem is called again but this time
+    # on the value in the right sub-tree. If the node has less than two children
+    # another check is made: if the left child is not null, the value of the node is 
+    # equal to that value, otherwise it's equal to the value of the right child.
+    def remove_from_tree(item, node)
+      return if node.nil?      
+      if compare(item, node.data) < 0
+        node.left = remove_from_tree(item, node.left)
+      elsif compare(item, node.data) > 0
+        node.right = remove_from_tree(item, node.right)
+      elsif node.left && node.right
+        node.data = least_item(node.right).data
+        node.right = remove_from_tree(node.data, node.right)
+      else
+        node = node.left ? node.left : node.right
+      end
+      return node
+    end
+
+    # Comparison of two objects. Will return -1 if item_one is less than item_two, 0 if
+    # they are equal, and 1 if item_one is greater than item_two. First checks if object
+    # has it's own comparison logic, if not, uses core Ruby comparision.
+    def compare(item_one, item_two)
+      begin
+        item_one.compare_to(item_two)
+      rescue NoMethodError
+        item_one <=> item_two
+      end
+    end
+
+    # Recursively finds the lowest item in a nodes left subtree.
+    def least_item(node)
+      return unless node
+      return node unless node.left
+      least_item(node.left)
+    end
+
+    # Traverses the tree and returns the sum of the nodes.
+    def node_count(node)
+      node.nil? ? 0 : 1 + node_count(node.left) + node_count(node.right)
+    end
+
+    # Traverses the tree and calculates the depth of the longest sub-tree
+    def tree_depth(node, depth)
+      node.nil? ? 0 : depth + max(height(node.left), height(node.right))
+    end
+
+    # Calculates the height of the node using it's leaves. Initial check to see if
+    # node is nil which means it has a height of 0.
+    def height(node)
+      node.nil? ? 0 : 1 + max(height(node.left), height(node.right))
+    end
+
+    # Converts parameters to an Array then calls Enumerable#max on them to return
+    # the largest element.
+    def max(*values)
+      values.max
+    end
+  end
+end

data/lib/ruby-avl/bs_tree_traversal.rb

@@ -0,0 +1,72 @@
+module BSTreeTraversal
+  class BSTreeTraversal
+
+    def pre_order_array(root_node, attribute = nil)
+      pre_order(root_node, attribute, [])
+    end
+
+    def pre_order_string(root_node, attribute = nil)
+      pre_order(root_node, attribute, []).join(', ')
+    end
+
+    def in_order_array(root_node, attribute = nil)
+      in_order(root_node, attribute, [])
+    end
+
+    def in_order_string(root_node, attribute = nil)
+      in_order(root_node, attribute, []).join(', ')    
+    end
+
+    def post_order_array(root_node, attribute = nil)
+      post_order(root_node, attribute, [])
+    end
+
+    def post_order_string(root_node, attribute = nil)
+      post_order(root_node, attribute, []).join(', ')
+    end
+
+    private
+
+    # The idea of preorder traversal is that we visit the nodes in the order root-left-right,
+    # meaning for any subtree in the path, root is processed as the node is visited, left node 
+    # is visited second, followed by right node.
+    # If attribute is set then it is called as a method on the data stored
+    # in the node, and that value is added to the array. If not, the data is added.
+    def pre_order(node, attribute, node_list)
+      unless node.nil?
+        node_list << (attribute ? node.data.send(attribute) : node.data)
+        pre_order(node.left, attribute, node_list)
+        pre_order(node.right, attribute, node_list)
+      end
+      return node_list
+    end
+
+    # The idea of inorder traversal is that we visit the nodes in the order left-root-right,
+    # meaning for any subtree in the path, left node must be visited first followed by root
+    # and right node. Prints the values in ascending order.
+    # If attribute is set then it is called as a method on the data stored
+    # in the node, and that value is added to the array. If not, the data is added.
+    def in_order(node, attribute, node_list)
+      unless node.nil?
+        in_order(node.left, attribute, node_list)
+        node_list << (attribute ? node.data.send(attribute) : node.data)
+        in_order(node.right, attribute, node_list)
+      end
+      return node_list
+    end
+
+    # The idea of postorder traversal is that we visit the nodes in the order left-right-root,
+    # meaning for any subtree in the path, left node must be visited first, followed by the
+    # right node, and root is not processed until the children are.
+    # If attribute is set then it is called as a method on the data stored
+    # in the node, and that value is added to the array. If not, the data is added.
+    def post_order(node, attribute, node_list)
+      unless node.nil?
+        post_order(node.left, attribute, node_list)
+        post_order(node.right, attribute, node_list)
+        node_list << (attribute ? node.data.send(attribute) : node.data)
+      end
+      return node_list
+    end
+  end
+end

data/lib/ruby-avl/node.rb

@@ -0,0 +1,11 @@
+module Node
+	class Node
+	  attr_accessor :data, :left, :right
+
+	  def initialize(data)
+	    @data = data
+	    @left = nil   
+	    @right = nil
+	  end
+	end
+end

data/lib/ruby-avl/version.rb

@@ -0,0 +1,3 @@
+module AVL
+	VERSION = '0.0'
+end

data/ruby-avl.gemspec

@@ -0,0 +1,20 @@
+require File.expand_path('../lib/ruby-avl/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name          = 'ruby-avl'
+  s.version       = AVL::VERSION
+  s.date          = '2016-04-30'
+  s.description   = s.summary = 'A simple AVL Tree implemented in Ruby'
+  s.authors       = ['Daniel Byers']
+  s.email         = 'daniel_byers@hotmail.co.uk'
+  s.homepage      = 'http://rubygems.org/gems/ruby-avl'
+  s.license       = 'MIT'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test}/*`.split("\n")
+  s.require_path  = 'lib'
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rspec-given'
+end

data/spec/avl_tree_spec.rb

@@ -0,0 +1,121 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+Given.use_natural_assertions
+
+describe AVLTree::AVLTree do
+    Given(:node) { Node::Node.new(25) }
+
+  context 'initialize a AVL Tree with a null root' do
+    Then { subject.root == nil }
+  end
+
+  context 'initialize a AVL Tree with a root node' do
+    Given(:subject) { AVLTree::AVLTree.new(node) }
+    Then { subject.root == node }
+  end
+
+  context 'adding to AVL Tree with rebalancing' do
+
+    context 'left rotation' do
+      When(:result) { 
+        subject.insert_item(25)
+        subject.insert_item(50)
+        subject.insert_item(100)
+      }
+      Then { result.data == 50 }
+    end
+
+    context 'double left rotation' do
+      When(:result) {
+        subject.insert_item(25)
+        subject.insert_item(50)
+        subject.insert_item(100)
+        subject.insert_item(80)
+        subject.insert_item(70)
+        subject.insert_item(57)
+      }
+      Then { result.data == 70 }
+    end
+
+    context 'right rotation' do
+      When(:result) {
+        subject.insert_item(25)
+        subject.insert_item(18)
+        subject.insert_item(7)
+      }
+      Then { result.data == 18 }
+    end
+
+    context 'double right rotation' do
+      When(:result) { 
+        subject.insert_item(25)
+        subject.insert_item(18)
+        subject.insert_item(7)        
+        subject.insert_item(13)        
+        subject.insert_item(12)
+        subject.insert_item(17)
+      }
+      Then { result.data == 13 }
+    end
+
+    context 'no rotation' do
+      When(:result) {  
+        subject.insert_item(25)      
+        subject.insert_item(20)
+        subject.insert_item(30)
+      }
+      Then { result.data == 25 }
+    end
+  end
+
+  context 'removing from tree with rebalancing' do
+                                                    
+    When {                                          
+      subject.insert_item(25)                      
+      subject.insert_item(50)                      
+      subject.insert_item(100)                     
+      subject.insert_item(80)    #     Visulisation:
+      subject.insert_item(70)    #          70
+      subject.insert_item(57)    #       /       \
+      subject.insert_item(72)    #     50         80
+      subject.insert_item(77)    #   /   \       /   \            
+      subject.insert_item(94)    #  25    57    72    100           
+      subject.insert_item(63)    #   \     \     \    /
+      subject.insert_item(30)    #   30    63    77  94            
+    }
+
+    context 'left rotation' do
+      When(:result) { 
+        subject.remove_item(25)
+        subject.remove_item(30)
+      }
+      Then { result.left.data == 57 }
+    end
+
+    context 'right rotation' do
+      When(:result) {     
+        subject.insert_item(20)
+        subject.remove_item(30)
+        subject.remove_item(57)
+        subject.remove_item(63)
+      }
+      Then { result.left.data == 25 }
+    end
+
+    context 'double left rotation rotation' do
+      When(:result) {
+        subject.remove_item(72)
+        subject.remove_item(77)
+      }
+      Then { result.right.data == 94 }
+    end
+
+    context 'double right rotation' do
+      When(:result) { 
+        subject.remove_item(100)
+        subject.remove_item(94)
+      }
+      Then { result.right.data == 77 }
+    end
+  end
+end

data/spec/bs_tree_spec.rb

@@ -0,0 +1,95 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+Given.use_natural_assertions
+
+describe BSTree::BSTree do
+  Given(:node) { Node::Node.new(1) }
+
+  context 'initialize a BS Tree with a null root' do
+    Then { subject.root == nil }
+  end
+
+  context 'initialize a BS Tree with a root node' do
+    Given(:subject) { BSTree::BSTree.new(node) }
+    Then { subject.root == node }
+  end
+
+  context 'number of nodes in a tree' do
+    When {
+      subject.insert_item(1)
+      subject.insert_item(2)
+      subject.insert_item(3)
+    }
+    When(:result) { subject.number_of_nodes }
+    Then { result == 3 }
+  end
+
+  context 'depth of the tree' do
+    When {
+      subject.insert_item(1)
+      subject.insert_item(2)
+      subject.insert_item(3)
+    }
+    When(:result) { subject.depth_of_tree }
+    Then { result == 2 }
+  end
+
+  context 'adding items to the tree' do
+
+    context 'add a single item to the tree' do
+      When(:result) { subject.insert_item(1) }
+      Then { result.data == 1 }
+    end
+
+    context 'add multiple items to the tree' do
+      When(:result) { 
+        subject.insert_item(1)
+        subject.insert_item(2)
+        subject.insert_item(3)
+        subject.insert_item(4)
+        subject.insert_item(5)
+      }
+      Then { result.right.data == 2 }
+    end
+
+    context 'adding duplicates should be ignored' do
+      When(:result) { 
+        subject.insert_item(1)
+        subject.insert_item(1)        
+      }
+      Then { result.data == 1}
+    end
+  end
+
+  context 'removing items from the tree' do
+    When {                      
+      subject.insert_item(3)    # Visulisation:
+      subject.insert_item(2)    #       3
+      subject.insert_item(1)    #     /   \
+      subject.insert_item(5)    #    2     5
+      subject.insert_item(4)    #   /     / \
+      subject.insert_item(6)    #  1     4   6 
+    }
+
+    context 'removing a leaf node' do
+      When(:result) { subject.remove_item(1) }
+      Then { result.left.left == nil }
+    end
+
+    context 'removing from a node with a left leaf' do
+      When(:result) { subject.remove_item(2) }
+      Then { result.left.data == 1 }
+    end
+
+    context 'removing from a node with a right leaf' do
+      When(:result) { subject.remove_item(6) }
+      Then { result.right.right == nil }
+    end
+
+    context 'removing from a node with two leaves' do
+      When(:result) { subject.remove_item(5) }
+      Then { result.right.right == nil }
+      And { result.right.left.data == 4 }
+    end
+  end
+end

data/spec/bs_tree_traversal_spec.rb

@@ -0,0 +1,68 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+Given.use_natural_assertions
+
+describe BSTreeTraversal::BSTreeTraversal do
+  # Given returns the last node of the AVL Tree instead of the tree object itself.
+  # In production, avl_tree.root would need to be passed into the traversal methods.
+  Given(:avl_tree) {
+    avl_tree = AVLTree::AVLTree.new
+    avl_tree.insert_item(30)    # Visulisation: 
+    avl_tree.insert_item(10)    #     23
+    avl_tree.insert_item(23)    #    /  \
+    avl_tree.insert_item(55)    #  10   47
+    avl_tree.insert_item(47)    #  /   /  \
+    avl_tree.insert_item(7)     # 7   30  55
+  }
+
+  context 'AVL Tree pre order' do
+    context 'as array' do
+      When(:result) { subject.pre_order_array(avl_tree) }
+      Then { result == [23, 10, 7, 47, 30, 55] }
+    end
+
+    context 'as string' do
+      When(:result) { subject.pre_order_string(avl_tree) }
+      Then { result == '23, 10, 7, 47, 30, 55' }
+    end
+
+    context 'with certain attribute' do
+      When(:result) { subject.pre_order_string(avl_tree, :even) }
+      Then { result = 'False, True, False, False, True, False' }
+    end
+  end
+
+  context 'AVL Tree in order' do
+    context 'as array' do
+      When(:result) { subject.in_order_array(avl_tree) }
+      Then { result == [7, 10, 23, 30, 47, 55] }
+    end
+
+    context 'as string' do
+      When(:result) { subject.in_order_string(avl_tree) }
+      Then { result == '7, 10, 23, 30, 47, 55' }
+    end
+
+    context 'with certain attribute' do
+      When(:result) { subject.in_order_string(avl_tree, :even) }
+      Then { result = 'False, True, False, True, False, False' }
+    end
+  end
+
+  context 'AVL Tree post order' do
+    context 'as array' do
+      When(:result) { subject.post_order_array(avl_tree) }
+      Then { result == [7, 10, 30, 55, 47, 23] }
+    end
+
+    context 'as string' do
+      When(:result) { subject.post_order_string(avl_tree) }
+      Then { result == '7, 10, 30, 55, 47, 23' }
+    end
+
+    context 'with certain attribute' do
+      When(:result) { subject.post_order_string(avl_tree, :even) }
+      Then { result = 'False, True, True, False, False, False' }
+    end
+  end
+end

data/spec/node_spec.rb

@@ -0,0 +1,12 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+Given.use_natural_assertions
+
+describe Node::Node do
+  context 'should initialize a new node' do
+    Given(:node) { Node::Node.new('test string') }
+    Then  { node.data == 'test string' }
+    And   { node.left == nil}
+    And   { node.right == nil}
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'rspec/given'
+require 'ruby-avl'
+
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: ruby-avl
+version: !ruby/object:Gem::Version
+  version: '0.0'
+platform: ruby
+authors:
+- Daniel Byers
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-04-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-given
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A simple AVL Tree implemented in Ruby
+email: daniel_byers@hotmail.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- Rakefile
+- lib/ruby-avl.rb
+- lib/ruby-avl/avl_tree.rb
+- lib/ruby-avl/bs_tree.rb
+- lib/ruby-avl/bs_tree_traversal.rb
+- lib/ruby-avl/node.rb
+- lib/ruby-avl/version.rb
+- ruby-avl.gemspec
+- spec/avl_tree_spec.rb
+- spec/bs_tree_spec.rb
+- spec/bs_tree_traversal_spec.rb
+- spec/node_spec.rb
+- spec/spec_helper.rb
+homepage: http://rubygems.org/gems/ruby-avl
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: A simple AVL Tree implemented in Ruby
+test_files: []