ds 0.0.1

data/lib/ds/trees/tree.rb

@@ -0,0 +1,117 @@
+module DS
+  class Tree
+
+    include Enumerable
+
+    attr_accessor :data
+    attr_reader :children
+
+    #Returns a new tree. 
+    def initialize(value=nil)
+      @data = value
+      @children = []
+    end
+
+    #Inserts a new subtree.
+    def << (value)
+      subtree = Tree.new(value)
+      @children << subtree
+      return subtree
+    end
+
+    #Checks if node is leaf.
+    def leaf?
+      self.children.empty?
+    end
+
+    #Returns leaf list.
+    def get_leaves(tree=self)
+      list = List.new
+      walker = TreeWalker.new(self)
+      walker.traverse(:postorder){|t| list.append(t) if t.leaf? }
+      list
+    end
+
+    #Returns the number of leaves for given subtree.
+    def leaf_count(tree=self)
+      if tree.leaf?
+        1
+      else
+        tree.children.inject(0){|m,t| m += leaf_count(t)} 
+      end
+    end
+
+    
+    #Returns number of nodes for each tree level.
+    #{1=>1, 2=>4, 3=>5}
+    def levels
+      walker = TreeWalker.new(self)
+      nodes={}
+
+      walker.traverse_with_h(self,1) do |t,level|
+        if nodes[level] 
+          nodes[level] += 1
+        else
+          nodes[level] = 1
+        end
+      end
+      nodes
+    end
+
+    #Returns tree width.
+    def width
+        levels.values.max
+    end
+  
+    #Returns subtree height.
+    def h(tree)
+      unless tree.leaf?
+        tree.children.map{|t| h(t) }.max + 1
+      else
+        1
+      end
+    end
+
+    #Returns tree height.
+    def height
+      h(self)
+    end
+
+    #Returns node which lies closest to the root. 
+    def lowest_height
+      find{ |node| node.leaf? }.data
+    end
+
+    #Mirrors tree.
+    def mirror!(tree=self)
+      unless tree.leaf?
+        tree.children.reverse!
+        tree.children.each{|t| mirror!(t)}
+      end
+    end
+
+    #Checks if tree is isometric to another tree.
+    def izometric?(other)
+      tree = self
+      unless tree.leaf? and other.leaf?
+        if tree.children.size == other.children.size
+          tree.children.each_with_index{|t,i| return false unless t.izometric?(other.children[i])}
+        else
+          return false
+        end
+      end
+      return true
+    end
+
+
+    #Iterates tree in BFS order.
+    def each
+      TreeWalker.new(self).traverse{ |t| yield t }
+    end
+
+    def to_a
+      map{ |node| node.data }
+    end
+  end
+end
+

data/lib/ds/trees/tree_walker.rb

@@ -0,0 +1,179 @@
+module DS
+  class TreeWalker
+
+    attr_accessor :visited
+    attr_accessor :tree
+
+
+    #Creates new tree iterator.
+    def initialize(tree=nil)
+      @visited = [] 
+      @tree = tree
+    end
+
+
+    #Traversing tree in given order:
+    #bfs - Breadth-first search - default
+    #postorder - postorder search
+    #preorder - preorder search
+    #inorder - inorder search - only for Binary Trees
+    #
+    #If block is  given, passes each visited subtree to block.
+    #Returns values of nodes  in given order
+
+    def traverse(order=:bfs,&block)
+      reset 
+      tree = @tree
+
+      case order
+      when :bfs
+        traverse_bfs &block
+      when :postorder
+        walk(tree,:postorder,&block)
+      when :preorder
+        walk(tree,:preorder, &block)
+      when (:inorder)
+        raise ArgumentError unless tree.kind_of? BinaryTree
+        walk(tree,order,&block)
+      end
+
+      return visited
+    end
+
+    #Traverses tree in BFS order.
+    def traverse_bfs
+      q = Queue.new
+      q.push @tree
+      
+      loop do
+        break if q.empty?
+        node = q.shift
+        if block_given?
+          yield node
+        else
+          @visited << node.data
+        end
+        node.children.each{ |n| q.push n } if node.children
+      end
+    end
+
+    #Resets tree walker.
+    def reset
+      @visited.clear
+      self
+    end
+
+
+
+    def traverse_with_h(tree,height=nil,&block)
+
+      tree.children.each do |t|
+        traverse_with_h(t,height+1,&block)
+      end
+
+      if block_given?
+        yield tree, height
+      else 
+        @visited << tree.data
+      end
+
+    end
+
+
+    #Recalculates tree by evaluating block on every node.
+    def recalculate!(tree,order,memo=nil,&block)
+      if tree
+
+        case order
+        when :postorder
+          
+          arr =  tree.children.map{ |t| recalculate!(t,order,memo,&block) }
+          result =  block.call(arr.push tree.data)
+          tree.data = result
+
+
+        when :preorder
+            
+          tree.data = yield tree, memo
+          memo = tree.data
+
+          tree.children.each do |t|
+            recalculate!(t,order,memo,&block)
+          end
+
+        when :inorder
+          raise ArgumentError unless  self.tree.is_a? BinaryTree
+          recalculate!(tree.left,order,&block)
+
+            tree.data = yield tree.memo
+            memo = tree.data
+
+          recalculate!(tree.right,order,memo,&block)
+
+        end
+      end
+    end
+
+
+
+    #Summarize tree
+    def summarize(direction=:bottomup)
+
+      case direction
+      when :bottomup
+        recalculate!(self.tree,:postorder,0){|ar| ar.inject(0){|x,memo| memo += x}}
+        self.tree
+      when :topdown
+        recalculate!(self.tree,:preorder,0){|x,memo| memo = memo+x.data} 
+        self.tree
+      end
+    end
+
+
+
+    private
+
+    def walk(tree,order,&block)
+      if tree
+
+        case order
+        when :postorder
+          tree.children.each do |t|
+            walk(t,order,&block)
+          end
+
+          if block_given?
+            yield tree
+          else 
+            @visited << tree.data
+          end
+
+        when :preorder
+          if block_given?
+            yield tree
+          else 
+            @visited << tree.data
+          end
+
+          tree.children.each do |t|
+            walk(t,order,&block)
+          end
+
+        when :inorder
+          raise ArgumentError unless  self.tree.is_a? BinaryTree
+          walk(tree.left,order,&block)
+
+          if block_given?
+            yield tree
+          else 
+            @visited << tree.data
+          end
+
+          walk(tree.right,order,&block)
+
+        end
+      end
+    end
+  end
+end
+

data/lib/ds/version.rb

@@ -0,0 +1,3 @@
+module DS
+  VERSION = "0.0.1"
+end

data/lib/ext/ext.rb

@@ -0,0 +1,15 @@
+class Array
+  def sorted?(order = :growing)
+    (size-2).times{ |i| return false if self[i] > self[i+1] }
+    true
+  end
+
+  def push_uniq e
+    if include? e
+      index e
+    else
+      push e
+      size-1
+    end
+  end
+end

data/test/help.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'minitest/autorun'
+require "minitest/benchmark" if ENV['BENCH']
+require 'redgreen'
+
+require 'ds'
+include DS
+

data/test/test_array2d.rb

@@ -0,0 +1,51 @@
+require 'help'
+
+describe Array2D do
+
+  describe "initialized with 0" do
+
+    before do
+      @zero_matrix = Array2D.new(2,0)
+    end
+
+    it "should return zero for any index." do
+      @zero_matrix[1,1].must_equal 0
+      @zero_matrix[0,0].must_equal 0 
+    end
+
+    it "#to_a should return matrix flattened to array." do
+      @zero_matrix.to_a.must_be_instance_of Array
+      @zero_matrix.to_a.must_equal [0,0,0,0] 
+    end
+
+    it "#should extend magically." do
+      @zero_matrix[3,3].must_equal 0
+      @zero_matrix[4,8].wont_be_nil
+    end
+  end
+
+  describe "initialized with false" do
+
+    before do
+      @discrete_matrix = Array2D.new(3,false)
+    end
+
+    it "should return false for any index." do
+      refute @discrete_matrix[1,1]
+      refute @discrete_matrix[0,0]
+    end
+
+    it "#to_a should return matrix flattened to array." do
+      @discrete_matrix.to_a.must_be_instance_of Array
+      @discrete_matrix.to_a.must_equal [false,false,false,false,false,false,false,false,false] 
+    end
+
+    it "#should extend magically." do
+      refute @discrete_matrix[3,3]
+      @discrete_matrix[4,8].wont_be_nil
+    end
+
+  end
+end
+
+

data/test/test_binary_heap.rb

@@ -0,0 +1,35 @@
+require "help"
+
+describe BinaryHeap do
+
+  before do
+    @arr = [9,8,4,5,11,6]
+    @arr2 = [4,2,9,11,3,5,1]
+    @heap = BinaryHeap.new(*@arr)
+    @heap2 = BinaryHeap.new(*@arr2)
+  end
+
+  it "should create heap from array" do
+    @heap.to_a.must_equal [11,9,6,5,8,4]
+    @heap2.to_a.must_equal [11,4,9,2,3,5,1]
+  end
+
+  it "#insert should insert new element to the heap maintaining heap relation." do
+    @heap.insert(13).to_a.must_equal  [13,9,11,5,8,4,6]
+  end
+
+  describe "Minimal Heap" do
+
+    before do
+      @min_heap = BinaryHeap.new(*@arr){|parent,child| parent < child}
+    end
+
+    it "should create heap from array." do
+      @min_heap.to_a.must_equal [4,5,6,8,11,9]
+    end
+
+    it "#insert should insert new element to the heap maintaining heap relation." do
+      @min_heap.insert(3).to_a.must_equal [3,5,4,8,11,9,6]
+    end
+  end
+end

data/test/test_binary_search_tree.rb

@@ -0,0 +1,32 @@
+require 'help'
+
+describe BinarySearchTree do
+
+  before do
+    t = BinarySearchTree.new(7)
+    c1 = t.insert 5
+    c2 = t.insert 8
+
+    c3 = c1.insert 2
+    c1.insert 6
+
+    c3.insert 1
+
+    @bst = t
+
+    @bin_tree = BinaryTree.new
+    [2,5,8,9,11,12,14].each{|x| @bin_tree.insert(x)}
+
+  end
+
+  it "should be valid  Binary Search Tree." do
+    assert BinarySearchTree.valid?(@bst)
+  end
+
+
+  it "not every Binary Tree is valid Binary Search Tree." do
+    refute BinarySearchTree.valid?(@bin_tree)
+  end
+
+end
+