honey_mushroom 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b9c416987328997c19925df1a42d0d1496a79cf9
+  data.tar.gz: f7808bb5be33111b3d05dd152c06d707b47fd6e3
+SHA512:
+  metadata.gz: 312e5110c838f5b8699efbec5b918fc385fb89c30c2d5040f2c05d6f6b213b8b5ce29abd773e44db8980204e10661427f5ac390df5f2c5f3aa69a20553dca73d
+  data.tar.gz: 84c193602e6e34a727466209dab93ee91e0bfa1dac0a0f28802e3cef57724d817740c8ba0af4a5dda1cddc8209e93a322b3594ad688ebb188e1d19b510b21de8

data/lib/honey_mushroom.rb

@@ -0,0 +1,12 @@
+require 'honey_mushroom/binary_search_tree'
+require 'honey_mushroom/breadth_first_search'
+require 'honey_mushroom/depth_first_search'
+require 'honey_mushroom/directed_graph'
+require 'honey_mushroom/doubly_linked_list'
+require 'honey_mushroom/linked_list'
+require 'honey_mushroom/node'
+require 'honey_mushroom/queue'
+require 'honey_mushroom/singly_linked_list'
+require 'honey_mushroom/stack_queue'
+require 'honey_mushroom/stack'
+require 'honey_mushroom/undirected_graph'

data/lib/honey_mushroom/binary_search_tree.rb

@@ -0,0 +1,102 @@
+require 'honey_mushroom/node'
+
+class BinarySearchTree
+
+  def initialize
+    @head = nil
+  end
+
+  def set_head(value)
+    @head = Node.new({value: value, left: nil, right: nil})
+  end
+
+  def search(value, node=@head)
+    if value == node.value
+      return node.value
+    elsif value < node.value
+      search(value, node.left) unless node.left.nil?
+    elsif value > node.value
+      search(value, node.right) unless node.right.nil?
+    else
+      return nil
+    end
+  end
+
+  def include?(value, node=@head)
+    !!search(value, node)
+  end
+
+  def delete(value)
+    delete_node(value, node=@head)
+  end
+
+  def insert(value, node=@head)
+    if node.value < value
+      insert_right(value, node)
+    elsif node.value > value
+      insert_left(value, node)
+    else
+      return false
+    end
+  end
+
+  private
+
+  def delete_node(value, node)
+    if value == node
+      remove(value)
+    elsif node < value
+      delete_node(value, node.left)
+    else
+      delete_node(value, node.right)
+    end
+  end
+
+  def remove(node)
+    if node.left.nil? && node.right.nil?
+      node = nil
+    elsif !node.left.nil? && node.right.nil?
+      node = node.left
+    elsif node.left.nil? && !node.right.nil?
+      node = node.right
+    else
+      node = change_parant(node)
+    end
+  end
+
+  def change_paretn(node)
+    node.value = successor_value(node.right)
+    node.right = update(node.right)
+    node
+  end
+
+  def successor_value(node)
+    unless node.left.nil?
+      successor_value(node.left)
+    end
+    node.value
+  end
+
+  def update(node)
+    unless node.left.nil?
+      node.left = update(node)
+    end
+    node.right
+  end
+
+  def insert_left(value, node)
+    if node.left
+      insert(value, node.left)
+    else
+      node.left = Node.new({value: value, left: nil, right: nil})
+    end
+  end
+
+  def insert_right(value, node)
+    if node.right
+      insert(value, node.right)
+    else
+      node.right = Node.new({value: value, left: nil, right: nil})
+    end
+  end
+end

data/lib/honey_mushroom/breadth_first_search.rb

@@ -0,0 +1,19 @@
+module BreadthFirstSearch
+
+  def breadth_first_search_include?(node_id, target_node)
+    queue = []
+    visited_nodes = Hash.new(0)
+    queue << node_id
+    until queue.empty?
+      id = queue.shift
+      visited_nodes[id] += 1
+      if id == target_node && visited_nodes[id] < 2
+        return true
+      else
+        queue.concat(@nodes[id].edges) unless visited_nodes[id] >= 2
+      end
+    end
+    false
+  end
+
+end

data/lib/honey_mushroom/depth_first_search.rb

@@ -0,0 +1,14 @@
+module DepthFirstSearch
+
+  def depth_first_search_include?(node_id, target_node, visited_nodes=Hash.new {0})
+    return true if node_id == target_node
+    @nodes[node_id].edges.each do |child|
+      visited_nodes[child] += 1
+      return false if visited_nodes[child] >= 2
+      result = depth_first_search_include?(@nodes[child].id, target_node, visited_nodes)
+      return true unless result == false
+    end
+    false
+  end
+
+end

data/lib/honey_mushroom/directed_graph.rb

@@ -0,0 +1,2 @@
+require 'honey_mushroom/graph'
+class DirectedGraph < Graph; end

data/lib/honey_mushroom/doubly_linked_list.rb

@@ -0,0 +1,45 @@
+require 'honey_mushroom/node'
+require 'honey_mushroom/linked_list'
+
+class DoublyLinkedList < LinkedList
+  attr_accessor :tail
+  def initialize
+    super
+    @tail = nil
+  end
+
+  def add(value)
+    node = Node.new({value: value, next: nil, last: nil})
+    node.next = @head
+    @head = node
+    node.next.last = node unless node.next.nil?
+    @tail = node if @tail.nil?
+  end
+
+  def remove_front
+    current = @head
+    @head = current.next
+    current.next.last = nil
+
+    return current
+  end
+
+  def remove_back
+    current = @tail
+    @tail = current.last
+    current.last.next = nil
+    return current
+  end
+
+
+  def to_s
+    s = '@head<->'
+    current = @head
+    until current.nil?
+      s += "[#{current.value}]<->"
+      current = current.next
+    end
+
+    return s
+  end
+end

data/lib/honey_mushroom/graph.rb

@@ -0,0 +1,63 @@
+require 'honey_mushroom/node'
+require 'honey_mushroom/depth_first_search'
+require 'honey_mushroom/breadth_first_search'
+
+class Graph
+
+  attr_accessor :nodes
+  include DepthFirstSearch
+  include BreadthFirstSearch
+
+  def initialize
+    @nodes = {}
+  end
+
+  def add_node(value, edges=[])
+    node = Node.new({value: value, edges: edges})
+    @nodes[node.id] = node
+    self
+  end
+
+  def delete_node(node_id)
+    @nodes.delete(node_id)
+  end
+
+  def get_node_value(node_id)
+    @node[node_id].value
+  end
+
+  def set_node_value(node_id, value)
+    @nodes[node_id].value = value
+  end
+
+  def add_edge(node_id, edge)
+    @nodes[node_id].edges << edge
+  end
+
+  def delete_edge(node_id, edge_id)
+    @nodes[node_id].edges.delete(edge_id)
+  end
+
+  def adjacent?(node_id, edge)
+    @nodes[node_id].edges.include?(edge)
+  end
+
+  def neighbors(node_id)
+    @nodes[node_id].edges
+  end
+
+  #FIXIT: to_s broken for undirected graph
+  def to_s
+    s = ""
+    @nodes.each do |node_id, node|
+      s += "#{node_id} (#{node.value}) => #{node.edges} \n"
+    end
+    return s
+  end
+
+  def get_id_from_value(value)
+    #TODO
+    #find a fast way to get id from value
+    #returns an array of all node ids with a given value
+  end
+end

data/lib/honey_mushroom/linked_list.rb

@@ -0,0 +1,28 @@
+class LinkedList
+  attr_accessor :head
+  def initialize
+    @head = nil
+  end
+
+  def add(value)
+    node = Node.new({value: value, next: nil})
+    node.next = @head
+    @head = node
+  end
+
+  def remove_front
+    current = @head
+    @head = current.next
+
+    return current
+  end
+
+  def find(value)
+    current = @head
+    until current.value == value
+      current = current.next
+    end
+
+    return "Value: #{current.value}  Next: #{current.next.value}  ID: #{current.id}"
+  end
+end

data/lib/honey_mushroom/node.rb

@@ -0,0 +1,22 @@
+class Node
+  @@auto_increment = 0
+  attr_reader :id
+  attr_accessor :value,  :edges,  :next, :last, :left,
+                :right,  :value2, :value3, :value4
+
+  def initialize(args={})
+    @value  = args.fetch(:value,  nil)
+    @edges  = args.fetch(:edges,  nil) if args.include?(:edges )
+    @next   = args.fetch(:next,   nil) if args.include?(:next  )
+    @last   = args.fetch(:last,   nil) if args.include?(:last  )
+    @left   = args.fetch(:left,   nil) if args.include?(:left  )
+    @right  = args.fetch(:right,  nil) if args.include?(:right )
+    @value2 = args.fetch(:value2, nil) if args.include?(:value2)
+    @value3 = args.fetch(:value3, nil) if args.include?(:value3)
+    @value4 = args.fetch(:value4, nil) if args.include?(:value4)
+
+    @id     = args.fetch(:id, @@auto_increment)
+
+    @@auto_increment += 1
+  end
+end

data/lib/honey_mushroom/queue.rb

@@ -0,0 +1,26 @@
+class Queue
+  def initialize
+    @queue = []
+  end
+
+  def enqueue(value)
+    @queue.push(value)
+    return value
+  end
+
+  def dequeue
+    @queue.shift
+  end
+
+  def peek
+    @queue[0]
+  end
+
+  def enq(value) #shorthand = less typing =)
+    enqueue(value)
+  end
+
+  def dq #shorthand = less typing =)
+    dequeue
+  end
+end

data/lib/honey_mushroom/singly_linked_list.rb

@@ -0,0 +1,24 @@
+require 'honey_mushroom/linked_list'
+
+class SinglyLinkedList < LinkedList
+
+  def remove_back
+    current = @head
+    current = current.next until current.next.next.nil?
+    node = current.next
+    current.next = nil
+
+    return node
+  end
+
+  def to_s
+    s = '@head->'
+    current = @head
+    until current.nil?
+      s += "[#{current.value}]->"
+      current = current.next
+    end
+
+    return s
+  end
+end

data/lib/honey_mushroom/stack.rb

@@ -0,0 +1,19 @@
+class Stack
+  attr_accessor :stack
+  def initialize
+    @stack = []
+  end
+
+  def push(value)
+    stack.push(value)
+    return value
+  end
+
+  def pop
+    stack.pop
+  end
+
+  def peek
+    stack[-1]
+  end
+end

data/lib/honey_mushroom/stack_queue.rb

@@ -0,0 +1,30 @@
+require 'honey_mushroom/stack'
+
+class StackQueue
+  attr_accessor :stack_one, :stack_two
+  def initialize
+    @stack_one = Stack.new
+    @stack_two = Stack.new
+  end
+
+  def enqueue(value)
+    stack_one.push(value)
+  end
+
+  def dequeue
+    if stack_two.stack.empty?
+      stack_two.push(stack_one.pop) until stack_one.stack.empty?
+    end
+
+    stack_two.pop
+  end
+
+  def enq(value) #shorthand = less typing =)
+    enqueue(value)
+  end
+
+  def dq  #shorthand = less typing =)
+    dequeue
+  end
+end
+

data/lib/honey_mushroom/undirected_graph.rb

@@ -0,0 +1,27 @@
+require 'honey_mushroom/graph'
+
+class UndirectedGraph < Graph
+
+  def add_node(value, edges=[])
+    node = Node.new({value: value, edges: edges})
+    @nodes[node.id] = node
+    edges.each { |edge| add_edge(edge, node.id) }
+    self
+  end
+
+  def delete_node(node_id)
+    all_edges = @nodes[node_id].edges.dup
+    all_edges.each { |edge| delete_edge(node_id, edge); p edge}
+    super
+  end
+
+  def add_edge(node_id, edge)
+    super
+    @nodes[edge].edges << node_id
+  end
+
+  def delete_edge(node_id, edge_id)
+    @nodes[edge_id].edges.delete(node_id)
+    super
+  end
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: honey_mushroom
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Riley Scheid
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-05-04 00:00:00.000000000 Z
+dependencies: []
+description: Honey Mushroom builds and traverses common abstract data structures in
+  Ruby
+email: riley.k.scheid@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/honey_mushroom.rb
+- lib/honey_mushroom/binary_search_tree.rb
+- lib/honey_mushroom/breadth_first_search.rb
+- lib/honey_mushroom/depth_first_search.rb
+- lib/honey_mushroom/directed_graph.rb
+- lib/honey_mushroom/doubly_linked_list.rb
+- lib/honey_mushroom/graph.rb
+- lib/honey_mushroom/linked_list.rb
+- lib/honey_mushroom/node.rb
+- lib/honey_mushroom/queue.rb
+- lib/honey_mushroom/singly_linked_list.rb
+- lib/honey_mushroom/stack.rb
+- lib/honey_mushroom/stack_queue.rb
+- lib/honey_mushroom/undirected_graph.rb
+- spec/binary_search_tree_spec.rb
+homepage: http://www.github.com/sp33drac3r/honey_mushroom
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Graphs & Traversals
+test_files:
+- spec/binary_search_tree_spec.rb