data_structures 1.0.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Isaac Sanders
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# DataStructures
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'data_structures'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install data_structures
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+
+task :test do
+  tests = FileList["test/**/*_test.rb"]
+  tests.each do |test|
+    ruby "-I lib -I test -r test_helper #{test}"
+  end
+end

data/data_structures.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'data_structures/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "data_structures"
+  gem.version       = DataStructures::VERSION
+  gem.authors       = ["Isaac Sanders"]
+  gem.email         = ["isaac@isaacbfsanders.com"]
+  gem.description   = %q{Data Structures that I decided to implement.}
+  gem.summary       = %q{Data Structures that I decided to implement.}
+  gem.homepage      = "http://isaacbfsanders.com/data_structures"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/lib/data_structures.rb

@@ -0,0 +1,4 @@
+require "data_structures/version"
+
+module DataStructures
+end

data/lib/data_structures/binary_heap.rb

@@ -0,0 +1,125 @@
+module DataStructures
+  class BinaryHeap < Array
+    # The Binary Heap is a Max Heap by default.
+    # In order to make it Min Heap, pass DataStructures::BinaryHeap::LOW_TO_HIGH
+    # as the parameter to the constructor.
+    HIGH_TO_LOW = 1
+    LOW_TO_HIGH = -1
+
+    def initialize(ordering = HIGH_TO_LOW)
+      @ordering = ordering
+      @last_index = 0
+    end
+
+    def insert(element)
+      index = @last_index
+      push(element)
+      while has_parent_at?(index) && in_wrong_order_with_parent?(element, parent_of(index))
+        swap_with_parent(index)
+        index = parent_index(index)
+      end
+      @last_index += 1
+    end
+
+    def remove
+      if size == 0
+        return nil
+      else
+        value = shift
+        parent = pop
+        unshift(parent)
+        index = 0
+        bubble_down(index)
+        value
+        # Compare the new root with its children; if they are in the correct order, stop.
+        # If not, swap the element with one of its children and return to the previous step.
+        # (Swap with its smaller child in a min-heap and its larger child in a max-heap.)
+      end
+    end
+
+    def min_heap?
+      @ordering == LOW_TO_HIGH
+    end
+
+    def max_heap?
+      @ordering == HIGH_TO_LOW
+    end
+
+    private
+
+    def bubble_down(index)
+      while in_wrong_order_with_children?(index)
+        if has_two_children_at?(index)
+          if ((left_child(index) <=> right_child(index)) / @ordering) > 0
+            swap_with_parent(left_child_index(index))
+            index = left_child_index(index)
+          else
+            swap_with_parent(right_child_index(index))
+            index = right_child_index(index)
+          end
+        else
+          swap_with_parent(left_child_index(index))
+          index = left_child_index(index)
+        end
+      end
+    end
+
+    def right_child(index)
+      fetch(right_child_index(index))
+    end
+
+    def right_child_index(index)
+      (index * 2) + 2
+    end
+
+    def left_child(index)
+      fetch(left_child_index(index))
+    end
+
+    def left_child_index(index)
+      (index * 2) + 1
+    end
+
+    def in_wrong_order_with_children?(index)
+      parent = fetch(index)
+      (has_left_child_at?(index) && ((parent <=> left_child(index)) / @ordering < 0)) ||
+        (has_right_child_at?(index) && ((parent <=> right_child(index)) / @ordering < 0))
+    end
+
+    def has_two_children_at?(index)
+      has_left_child_at?(index) && has_right_child_at?(index)
+    end
+
+    def has_left_child_at?(index)
+      not self[left_child_index(index)].nil?
+    end
+
+    def has_right_child_at?(index)
+      not self[right_child_index(index)].nil?
+    end
+
+    def has_parent_at?(index)
+      parent_index(index) >= 0
+    end
+
+    def parent_of(index)
+      fetch(parent_index(index))
+    end
+
+    def swap_with_parent(index)
+      child = fetch(index)
+      self[index] = fetch(parent_index(index))
+      self[parent_index(index)] = child
+      nil
+    end
+
+    def in_wrong_order_with_parent?(child, parent)
+      comparison = child <=> parent
+      comparison / @ordering > 0
+    end
+
+    def parent_index(index)
+      (index - 1) / 2
+    end
+  end
+end

data/lib/data_structures/binary_search_tree.rb

@@ -0,0 +1,164 @@
+module DataStructures
+  class BinarySearchTree
+    attr_reader :root
+
+    def insert(element)
+      if has_root?
+        root.insert(element)
+      else
+        @root = DataStructures::BinarySearchTree::Node.new(element)
+        true
+      end
+    end
+
+    def remove(element)
+      if has_root?
+        @root = root.remove(element)
+      else
+        false
+      end
+    end
+
+    def get(element)
+      if has_root?
+        node = root
+        until(node.element == element)
+          case(node.element <=> element)
+          when Node::LESS_THAN_OTHER
+            if node.has_left_child?
+              node = node.left_child
+            end
+          when Node::GREATER_THAN_OTHER
+            if node.has_right_child?
+              node = node.right_child
+            end
+          end
+        end
+        node.element
+      else
+        nil
+      end
+    end
+
+    def size
+      in_order.size
+    end
+
+    def in_order
+      if has_root?
+        stack = Array.new
+        node = root
+        in_order_array = []
+        in_order_array += node.left_ancestors.map(&:element)
+
+        while(not stack.empty?)
+          node = stack.pop
+          in_order_array.push(node.element)
+          if node.has_right_child?
+            stack.push(node.right_child)
+            node = node.right_child
+            node.left_ancestors.each do |node|
+              stack.push(node)
+            end
+          end
+        end
+
+        in_order_array
+      else
+        []
+      end
+    end
+
+    private
+
+    def has_root?
+      not root.nil?
+    end
+
+    class Node
+      LESS_THAN_OTHER = -1
+      GREATER_THAN_OTHER = 1
+      attr_accessor :left_child, :right_child, :element
+
+      def initialize(element)
+        @element = element
+      end
+
+      def insert(element)
+        case @element <=> element
+        when LESS_THAN_OTHER
+          if has_left_child?
+            left_child.insert(element)
+          else
+            @left_child = DataStructures::BinarySearchTree::Node.new(element)
+            return true
+          end
+        when GREATER_THAN_OTHER
+          if has_right_child?
+            right_child.insert(element)
+          else
+            @right_child = DataStructures::BinarySearchTree::Node.new(element)
+            return true
+          end
+        else
+          return false
+        end
+      end
+
+      def remove(element)
+        case @element <=> element
+        when LESS_THAN_OTHER
+          if has_left_child?
+            @left_child = left_child.remove(element)
+          else
+            nil
+          end
+        when GREATER_THAN_OTHER
+          if has_right_child?
+            @right_child = right_child.remove(element)
+          else
+            nil
+          end
+        else
+          if has_two_children?
+            node = left_child
+            while(node.has_right_child?)
+              node = node.right_child
+            end
+            @left_child = left_child.remove(node.element)
+
+
+          elsif has_left_child?
+            left_child
+          elsif has_right_child?
+            right_child
+          else
+            nil
+          end
+        end
+      end
+
+      def has_two_children?
+        has_left_child? and has_right_child?
+      end
+
+      def left_ancestors
+        left_ancestors = []
+        node = self
+        until node.nil?
+          left_ancestors << node
+          node = node.left_child
+        end
+        left_ancestors
+      end
+
+      def has_left_child?
+        not left_child.nil?
+      end
+
+      def has_right_child?
+        not right_child.nil?
+      end
+    end
+  end
+end

data/lib/data_structures/priority_queue.rb

@@ -0,0 +1,37 @@
+require 'data_structures/binary_heap'
+
+module DataStructures
+  class PriorityQueue
+    extend Forwardable
+
+    def self.low_priority
+      new(DataStructures::BinaryHeap::LOW_TO_HIGH)
+    end
+
+    def initialize(ordering = DataStructures::BinaryHeap::HIGH_TO_LOW)
+      @heap = DataStructures::BinaryHeap.new(ordering)
+    end
+
+    def high_priority?
+      @heap.max_heap?
+    end
+
+    def offer(object, priority)
+      @heap.insert(ObjectWithPriority.new(object, priority))
+    end
+
+    def poll
+      @heap.remove.object
+    end
+
+    private
+
+    class ObjectWithPriority < Struct.new(:object, :priority)
+      include Comparable
+
+      def <=> other
+        priority <=> other.priority
+      end
+    end
+  end
+end

data/lib/data_structures/version.rb

@@ -0,0 +1,3 @@
+module DataStructures
+  VERSION = "1.0.0"
+end

data/test/data_structures/binary_heap_test.rb

@@ -0,0 +1,51 @@
+require 'data_structures/binary_heap'
+
+class BinaryHeapTest < Test::Unit::TestCase
+  attr_reader :heap
+
+  def setup
+    @heap = DataStructures::BinaryHeap.new
+  end
+
+  def test_binary_heap_has_log_n_insertion
+    126.times do
+      heap.insert(SameCounter.new)
+    end
+
+    counter = GreaterCounter.new
+    heap.insert(counter)
+
+    assert_equal(counter, heap.first)
+    assert_equal(6, heap.first.count)
+  end
+
+  def test_min_heap_insertion
+    heap = DataStructures::BinaryHeap.new(DataStructures::BinaryHeap::LOW_TO_HIGH)
+    126.times do
+      heap.insert(SameCounter.new)
+    end
+
+    counter = LessCounter.new
+    heap.insert(counter)
+    assert_equal(counter, heap.first)
+    assert_equal(6, heap.first.count)
+  end
+
+  def test_binary_heap_has_log_n_removal
+    126.times do
+      heap.insert(SameCounter.new)
+    end
+
+
+    greater_counter = GreaterCounter.new
+    heap.insert(greater_counter)
+    less_counter = LessCounter.new
+    heap.insert(less_counter)
+
+    assert_equal(greater_counter, heap.remove)
+    assert_equal(127, heap.size)
+    assert_equal(less_counter, heap.last)
+    # 1 comparison on insertion, 6 on removal
+    assert_equal(7, heap.last.count)
+  end
+end

data/test/data_structures/binary_search_tree_test.rb

@@ -0,0 +1,48 @@
+require 'data_structures/binary_search_tree'
+
+class BinarySearchTreeTest < Test::Unit::TestCase
+  attr_reader :tree
+
+  def setup
+    @tree = DataStructures::BinarySearchTree.new
+  end
+
+  def test_binary_search_tree_insertion
+    26.times do
+      tree.insert(LessCounter.new)
+    end
+
+    counter = SameCounter.new
+    assert(tree.insert(counter))
+    refute(tree.insert(SameCounter.new))
+    assert_includes(tree.in_order, counter)
+    assert_equal(27, tree.size)
+  end
+
+  def test_in_order_gives_the_sorted_order
+    (1..10).each do |n|
+      tree.insert(n)
+    end
+
+    assert_equal(tree.in_order, (1..10).to_a)
+  end
+
+  def test_binary_search_tree_removal
+    (1..10).each do |n|
+      tree.insert(n)
+    end
+
+    assert(tree.remove(1))
+  end
+
+  def test_binary_search_tree_get
+    126.times do
+      tree.insert(LessCounter.new)
+    end
+
+    counter = LessCounter.new
+    assert(tree.insert(counter))
+
+    assert(tree.get(counter))
+  end
+end

data/test/data_structures/priority_queue_test.rb

@@ -0,0 +1,36 @@
+require 'data_structures/priority_queue'
+
+class PriorityQueueTest < Test::Unit::TestCase
+  attr_reader :queue
+
+  def setup
+    @queue = DataStructures::PriorityQueue.new
+  end
+
+  def test_priority_queue_defaults_to_high_priority
+    assert(queue.high_priority?)
+  end
+
+  def test_high_priority_queue_poll
+    126.times do |n|
+      queue.offer(Object.new, n)
+    end
+
+    object = Object.new
+    queue.offer(object, 200)
+
+    assert_equal(object, queue.poll)
+  end
+
+  def test_low_priority_queue_poll
+    queue = DataStructures::PriorityQueue.low_priority
+    100.downto(10) do |n|
+      queue.offer(Object.new, n)
+    end
+
+    object = Object.new
+    queue.offer(object, 1)
+
+    assert_equal(object, queue.poll)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,45 @@
+require 'test/unit'
+
+class SameCounter
+  include Comparable
+  attr_accessor :count
+
+  def initialize
+    @count = 0
+  end
+
+  def <=>(other)
+    @count += 1
+    other.count += 1
+    0
+  end
+end
+
+class LessCounter
+  include Comparable
+  attr_accessor :count
+
+  def initialize
+    @count = 0
+  end
+
+  def <=>(other)
+    @count += 1
+    -1
+  end
+end
+
+class GreaterCounter
+  include Comparable
+  attr_accessor :count
+
+  def initialize
+    @count = 0
+  end
+
+  def <=>(other)
+    @count += 1
+    other.count += 1
+    1
+  end
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: data_structures
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Isaac Sanders
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-02 00:00:00.000000000 Z
+dependencies: []
+description: Data Structures that I decided to implement.
+email:
+- isaac@isaacbfsanders.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- data_structures.gemspec
+- lib/data_structures.rb
+- lib/data_structures/binary_heap.rb
+- lib/data_structures/binary_search_tree.rb
+- lib/data_structures/priority_queue.rb
+- lib/data_structures/version.rb
+- test/data_structures/binary_heap_test.rb
+- test/data_structures/binary_search_tree_test.rb
+- test/data_structures/priority_queue_test.rb
+- test/test_helper.rb
+homepage: http://isaacbfsanders.com/data_structures
+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'
+      segments:
+      - 0
+      hash: 4132526296573747409
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 4132526296573747409
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Data Structures that I decided to implement.
+test_files:
+- test/data_structures/binary_heap_test.rb
+- test/data_structures/binary_search_tree_test.rb
+- test/data_structures/priority_queue_test.rb
+- test/test_helper.rb