ds 0.0.4 → 0.0.6

data/lib/ds/trees/binary_tree.rb

@@ -1,71 +1,67 @@
 module DS
+  # Class implements binary tree
   class BinaryTree < Tree
-
-    #Inserts a new subtree.
-    def << (value)
-      subtree = BinaryTree.new(value)
+    # Inserts a new subtree.
+    def <<(value)
+      subtree = BinaryTree.new(value, self)
       @children << subtree
-      return subtree
+      subtree
     end
 
-    #Returns left subtree
+    # Returns left subtree
     def left
-      if @children.empty?
-        nil
-      else
-        @children[0]
-      end
+      @children[0]
     end
 
-    #Sets left subtree
+    # Sets left subtree
     def left=(value)
       @children[0] = value
     end
 
-    #Returns right subtree
+    # Returns right subtree
     def right
-      if @children.empty?
-        nil
-      else
-        @children[1]
-      end
+      @children[1]
     end
 
-    #Sets right subtree
+    # Sets right subtree
     def right=(value)
       @children[1] = value
     end
 
-
-    #Inserts new element in BSF order
+    # Inserts new element in BSF order
     def insert(x)
-      q = Queue.new
-      if @data == nil
+      q = SimpleQueue.new
+      if @data.nil?
         @data = x
-      elsif self.left == nil
-        self.left = BinaryTree.new(x)
-      elsif self.right == nil
-        self.right = BinaryTree.new(x)
+      elsif left.nil?
+        self.left = BinaryTree.new(x, self)
+      elsif right.nil?
+        self.right = BinaryTree.new(x, self)
       else
-        q.push self.left
-        q.push self.right
-        loop do
-          node = q.shift
-          if node.left == nil
-            node.insert(x)
-            break
-          else 
-            q.push node.left
-          end
-          if node.right == nil
-            node.insert(x)
-            break
-          else
-            q.push node.right
-          end
+        q.push left
+        q.push right
+        insert_next(q, x)
+      end
+    end
+
+    private
+
+    def insert_next(q, x)
+      loop do
+        node = q.shift
+        if node.left.nil?
+          node.insert(x)
+          break
+        else
+          q.push node.left
+        end
+        if node.right.nil?
+          node.insert(x)
+          break
+        else
+          q.push node.right
         end
       end
     end
   end
 end
-

data/lib/ds/trees/red_black_tree.rb

@@ -0,0 +1,123 @@
+module DS
+  # Class implements Red Black Tree
+  class RedBlackTree
+    RED = true
+    BLACK = false
+
+    include Enumerable
+
+    attr_accessor :root
+    attr_reader :size
+
+    def initialize(hash = nil)
+      @root = nil
+      @size = 0
+      @iterator = TreeWalker.new(root)
+      hash.each { |k, v| insert(k, v) } if hash
+    end
+
+    def insert(key, value)
+      self.root = put(root, key, value)
+      root.color = BLACK
+    end
+
+    def []=(key, value)
+      insert(key, value)
+    end
+
+    def get(key, node = root)
+      x = node
+      while x
+        case key <=> x.key
+        when -1
+          x = x.left
+        when 1
+          x = x.right
+        else
+          return x.data
+        end
+      end
+    end
+
+    def [](key)
+      get(key)
+    end
+
+    def each
+      iterator = TreeWalker.new(root)
+      iterator.traverse(:inorder) { |t| yield t }
+    end
+
+    def to_h
+      each_with_object({}) { |n, h| h[n.key] = n.data }
+    end
+
+    private
+
+    def put(n, key, value)
+      if n.nil?
+        @size += 1
+        return Node.new(key, value, RED)
+      end
+
+      case key <=> n.key
+      when -1
+        n.left = put(n.left, key, value)
+      when 1
+        n.right = put(n.right, key, value)
+      else
+        n.data = value
+      end
+
+      balance(n)
+    end
+
+    def balance(n)
+      n = rotate_left(n)    if right_red?(n)
+      n = rotate_right(n)   if two_red_in_row?(n)
+      flip_colors(n)        if red_children?(n)
+      n
+    end
+
+    def red_children?(n)
+      red?(n.left) && red?(n.right)
+    end
+
+    def two_red_in_row?(n)
+      red?(n.left) && red?(n.left.left)
+    end
+
+    def right_red?(n)
+      red?(n.right) && !red?(n.left)
+    end
+
+    def red?(n)
+      return false if n.nil?
+      n.color == RED
+    end
+
+    def rotate_left(n)
+      x = n.right
+      n.right = x.left
+      x.left = n
+      x.color = n.color
+      n.color = RED
+      x
+    end
+
+    def rotate_right(n)
+      x = n.left
+      n.left = x.right
+      x.right = n
+      x.color = n.color
+      n.color = RED
+      x
+    end
+
+    def flip_colors(n)
+      n.color = RED
+      n.left.color = BLACK
+      n.right.color = BLACK
+    end
+  end
+end

data/lib/ds/trees/red_black_tree/node.rb

@@ -0,0 +1,21 @@
+module DS
+  # Class implements Red Black Tree
+  class RedBlackTree
+    # Red Black Tree Node
+    class Node
+      attr_accessor :color, :right, :left, :data, :key
+
+      def initialize(key, value, color)
+        @key = key
+        @data = value
+        @color = color
+        @left = nil
+        @right = nil
+      end
+
+      def children
+        [@left, @right]
+      end
+    end
+  end
+end

data/lib/ds/trees/tree.rb

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

data/lib/ds/trees/tree_walker.rb

@@ -1,180 +1,109 @@
 module DS
+  # Tree enumerator
   class TreeWalker
+    attr_accessor :visited, :tree, :action, :order
 
-    attr_accessor :visited
-    attr_accessor :tree
-
-
-    #Creates new tree iterator.
-    def initialize(tree=nil)
-      @visited = [] 
+    # Creates new tree iterator.
+    def initialize(tree, options = {}, &block)
+      @visited = []
       @tree = tree
+      @order = options[:order] || :bfs
+      @action = block
     end
 
-
-    #Traversing tree in given order:
-    #bfs - Breadth-first search - default
-    #postorder - postorder search
-    #preorder - preorder search
-    #inorder - inorder search - only for Binary Trees
+    # 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)
+    # If block is  given, passes each visited subtree to block.
+    # Returns values of nodes in given order
+
+    def traverse(traverse_order = nil, &block)
+      self.action = block if block_given?
+      self.order = traverse_order if traverse_order
+      reset!
+
+      if order == :bfs
+        traverse_bfs
+      else
+        walk(tree)
       end
-
-      return visited
+      visited
     end
 
-    #Traverses tree in BFS order.
-    def traverse_bfs
-      q = Queue.new
-      q.push @tree
-      
+    # Traverses tree in BFS order.
+    def traverse_bfs(&block)
+      self.action = block if block_given?
+      q = SimpleQueue.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
+        visit_node(node)
+        node.children.each { |n| q.push n } if node.children
       end
     end
 
-    #Resets tree walker.
-    def reset
+    # Resets tree walker.
+    def reset!
       @visited.clear
       self
     end
 
-
-
-    #Traverses tree with tracking level.
-    def traverse_with_h(tree,height=nil,&block)
-
+    # Traverses tree with tracking level.
+    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
+        traverse_with_h(t, height + 1, &block)
       end
 
+      yield tree, height if block_given?
     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,memo,&block)
-
-            tree.data = yield tree, memo
-            memo = tree.data
-
-          recalculate!(tree.right,order,memo,&block)
-
+    # Recalculates tree by evaluating block on every node.
+    def recalculate!(tree, order, memo = nil, &block)
+      case order
+      when :postorder
+        arr = tree.children.map { |t| recalculate!(t, order, memo, &block) }
+        tree.data = yield tree, arr
+      when :preorder
+        tree.data = yield tree, memo
+        tree.children.each do |t|
+          recalculate!(t, order, tree.data, &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
       when :inorder
-        recalculate!(self.tree,:inorder,0){|x,memo| memo = memo+x.data if x.data and memo} 
-        self.tree
-      end
+        recalculate!(tree.left, order, memo, &block)
+        tree.data = yield tree, memo
+        recalculate!(tree.right, order, tree.data, &block)
+      end if tree
     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
+    def visit_node(node)
+      action.call(node) if action
+      @visited << node.data
+    end
 
-          walk(tree.right,order,&block)
+    def visit_children(node)
+      node.children.each { |t| walk(t) }
+    end
 
-        end
-      end
+    def walk(node)
+      case order
+      when :postorder
+        visit_children(node)
+        visit_node(node)
+      when :preorder
+        visit_node(node)
+        visit_children(node)
+      when :inorder
+        walk(node.left)
+        visit_node(node)
+        walk(node.right)
+      end if node
     end
   end
 end
-