ds 0.0.4 → 0.0.6

data/lib/ds/trees/trie.rb

@@ -1,61 +1,91 @@
 module DS
+  # Trie dictionary data structure
   class Trie < Tree
+    attr_accessor :root
 
-    ALPHABET = %w{- a b c d e f g h i j k l m n o p q r s t u v w x y z} 
+    def initialize(value = nil, alphabet = nil)
+      @root = Node.new(value)
+      self.alphabet = (alphabet || %w(- a b c d e f g h i j k l m n o p q r s t u v w x y z))
+    end
+
+    def alphabet=(arr)
+      @alphabet = {}
+      arr.each_with_index { |c, i| @alphabet[c] = i }
+    end
 
     def alphabet
-      self.class::ALPHABET
+      @alphabet.keys
     end
-    
-    def initialize(value=nil)
-      @children = Array.new(alphabet.size)
-      @data = value
+
+    def key(chr)
+      @alphabet[chr]
     end
 
-    def insert(s, value=true)
-      letters = s.scan(/./)
-      raise ArgumentError, "Not allowed symbol." unless (letters - alphabet).empty?
-      priv_insert(letters, value)
+    def insert(s, value = true)
+      letters = get_letters(s)
+      root.put(letters, value, self)
+    end
+
+    def []=(k, v)
+      insert(k, v)
     end
 
     def find(s)
-      letters = s.scan(/./)
-      raise ArgumentError, "Not allowed symbol." unless (letters - alphabet).empty?
-      priv_find(letters)
+      letters = get_letters(s)
+      node = root.get(letters, self)
+      node.data if node
     end
 
-    protected
-    def key(chr)
-      k=alphabet.index(chr) 
+    def [](k)
+      find(k)
     end
 
+    def delete(s)
+      letters = s.scan(/./)
+      root.delete(letters, self)
+    end
 
-    def priv_insert(s, value)
-      if s.empty?
-          @data = value
-      else
-        index = key(s.first)
-        subtree = if @children[index]
-                    @children[index]
-                  else
-                    @children[index] = Trie.new
-                  end
-
-        subtree.priv_insert(s[1..-1], value)
+    def each(&block)
+      visit(root, '', &block)
+    end
+
+    def visit(node, prefix, &block)
+      yield prefix, node.data if node.data
+      node.children.each_with_index do |n, i|
+        visit(n, prefix + alphabet[i], &block) if n
       end
     end
 
-    def priv_find(search)
-      if search.empty?
-        @data
+    def with_prefix(prefix, &block)
+      letters = get_letters(prefix)
+      node = root.get(letters, self)
+      if block_given?
+        return nil unless node
+        visit(node, prefix, &block)
       else
-        index = key(search.first)
-        if @children[index]
-          @children[index].priv_find(search[1..-1])
-        else
-          nil
-        end
+        arr = []
+        return arr unless node
+        visit(node, prefix) { |n| arr << n }
+        arr
       end
     end
+
+    def to_h
+      h = {}
+      each { |k, v| h[k] = v }
+      h
+    end
+
+    private
+
+    def allowed?(letters)
+      (letters - alphabet).empty?
+    end
+
+    def get_letters(s)
+      letters = s.scan(/./)
+      raise ArgumentError, 'Not allowed symbol.' unless allowed?(letters)
+      letters
+    end
   end
 end

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

@@ -0,0 +1,48 @@
+module DS
+  # Trie dictionary data structure
+  class Trie
+    # Trie node
+    class Node
+      attr_reader :children, :data
+
+      def initialize(value = nil)
+        @children = []
+        @data = value
+      end
+
+      def put(s, value, trie)
+        if s.empty?
+          @data = value
+        else
+          index = trie.key(s.first)
+          @children[index] ||= Node.new
+          @children[index].put(s[1..-1], value, trie)
+        end
+      end
+
+      def get(s, trie)
+        if s.empty?
+          self
+        else
+          index = trie.key(s.first)
+          @children[index].get(s[1..-1], trie) if @children[index]
+        end
+      end
+
+      def delete(s, trie)
+        return true if s.empty?
+        index = trie.key(s.first)
+        flag = @children[index].delete(s[1..-1], trie)
+        flag &&= one_child?
+        @children[index] = nil if flag
+        s.size < 2 ? true : flag && @data.nil?
+      end
+
+      private
+
+      def one_child?
+        @children.compact.size <= 1
+      end
+    end
+  end
+end

data/lib/ds/version.rb

@@ -1,3 +1,4 @@
+# Main module namespace
 module DS
-  VERSION = "0.0.4"
+  VERSION = '0.0.6'.freeze
 end

data/test/help.rb

@@ -1,17 +1,14 @@
 if ENV['COVERAGE']
   require 'simplecov'
   SimpleCov.start do
-    add_filter "/test/"
+    add_filter '/test/'
   end
 end
 
-
 require 'rubygems'
-gem 'minitest'
 require 'minitest/autorun'
-require "minitest/benchmark" if ENV['BENCH']
-require "minitest/pride"
-
+require 'minitest/benchmark' if ENV['BENCH']
+require 'minitest/pride'
 
 require './lib/ds.rb'
 include DS

data/test/performance/binary_heap_performance_test.rb

@@ -0,0 +1,20 @@
+require 'help'
+
+if ENV['BENCH']
+  describe 'performance Bench' do
+    before do
+      @arr = (1..10_000).to_a.shuffle
+      @heap = BinaryHeap.new(*@arr)
+    end
+
+    bench_performance_constant 'creating new heap should be linear operation.', 0.999 do |_n|
+      BinaryHeap.new(*@arr)
+    end
+
+    bench_performance_constant 'accessing max element should be const operation.', 0.999 do |n|
+      n.times do
+        @heap.shift
+      end
+    end
+  end
+end

data/test/performance/list_performance_test.rb

@@ -0,0 +1,36 @@
+if ENV['BENCH']
+  describe 'Lists Bench' do
+    before do
+      @arr = (1..10_000).to_a.sort_by { rand }
+      @list = List.from_array([1, 2, 3, 4])
+      @second = @list.head.next
+
+      10_000.times do
+        @list.append 4
+      end
+    end
+
+    bench_performance_constant '#append should be const operation.', 0.999 do |n|
+      n.times do
+        @list.append 3
+      end
+    end
+
+    bench_performance_constant '#insert after should be const operation.', 0.999 do |n|
+      n.times do
+        @list.insert_after(9, @second)
+      end
+    end
+
+    bench_performance_constant '#unshift should be const operation.', 0.999 do |n|
+      n.times do
+        @list.unshift 3
+      end
+    end
+
+    bench_performance_linear '#reverse! should be linear operation.', 0.999 do |n|
+      list = List.from_array(@arr[0..n])
+      list.reverse!
+    end
+  end
+end

data/test/performance/priority_queue_performance.rb

@@ -0,0 +1,32 @@
+require 'help'
+
+if ENV['BENCH']
+  describe 'performance Bench' do
+    before do
+      @queue = PriorityQueue.new
+      10_000.times do
+        @queue.push :elem, rand(10)
+      end
+
+      @empty_queue = PriorityQueue.new
+    end
+
+    bench_performance_constant '#accessing max element should be const operation.', 0.999 do |n|
+      n.times do
+        @queue.peek
+      end
+    end
+
+    # bench_performance_logarithmic '#removing max element should be log operation.', 0.999 do |n|
+    #   n.times do
+    #     @queue.dequeue
+    #   end
+    # end
+
+    bench_performance_linear 'creating new priority queue should be linear operation.', 0.999 do |n|
+      n.times do
+        @empty_queue.push :elem, rand(10)
+      end
+    end
+  end
+end

data/test/performance/rbt_performance_test.rb

@@ -0,0 +1,17 @@
+require 'help'
+
+if ENV['BENCH']
+  describe 'performance Bench' do
+    before do
+      @tree = RedBlackTree.new
+    end
+
+    bench_performance_constant 'insert is log(n) operation', 0.999 do |n|
+      key = 'a'
+      n.times do
+        key = key.succ
+        @tree.insert key, rand(10)
+      end
+    end
+  end
+end

data/test/performance/simple_queue_performance_test.rb

@@ -0,0 +1,37 @@
+require 'help'
+if ENV['BENCH']
+  describe 'performance Bench' do
+    before do
+      @queue = SimpleQueue.new
+      @queue2 = SimpleQueue.create
+      100_000.times do
+        @queue.push 4
+        @queue2.push 4
+      end
+    end
+
+    bench_performance_constant '#shift(array implementation) should be const operation.', 0.999 do |n|
+      n.times do
+        @queue.shift
+      end
+    end
+
+    bench_performance_constant '#shift(list implementation) should be const operation.', 0.999 do |n|
+      n.times do
+        @queue2.shift
+      end
+    end
+
+    bench_performance_constant '#push(array implementation) should be const operation.', 0.999 do |n|
+      n.times do
+        @queue.push 2
+      end
+    end
+
+    bench_performance_constant '#push(list implementation) should be const operation.', 0.999 do |n|
+      n.times do
+        @queue2.push 2
+      end
+    end
+  end
+end

data/test/performance/stack_test.rb

@@ -0,0 +1,45 @@
+require 'help'
+
+if ENV['BENCH']
+  describe 'implement as Array Bench' do
+    before do
+      @stack = Stack.new
+      100_000.times do
+        @stack.push 4
+      end
+    end
+
+    bench_performance_constant 'array #pop should be const op', 0.999 do |n|
+      n.times do
+        @stack.pop
+      end
+    end
+
+    bench_performance_constant 'array #push should be const op', 0.999 do |n|
+      n.times do
+        @stack.push 3
+      end
+    end
+  end
+
+  describe 'implement as List Bench' do
+    before do
+      @stack = Stack.create
+      100_000.times do
+        @stack.push 4
+      end
+    end
+
+    bench_performance_constant 'list #pop should be const op', 0.999 do |n|
+      n.times do
+        @stack.pop
+      end
+    end
+
+    bench_performance_constant 'list #push should be const op.', 0.999 do |n|
+      n.times do
+        @stack.push 3
+      end
+    end
+  end
+end

data/test/test_array2d.rb

@@ -1,61 +1,59 @@
 require 'help'
 
 describe Array2D do
-
-  describe "initialized with 0" do
-
+  describe 'initialized with 0' do
     before do
-      @zero_matrix = Array2D.new(2,0)
+      @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 
+    it 'should return zero for any index.' do
+      @zero_matrix[1, 1].must_equal 0
+      @zero_matrix[0, 0].must_equal 0
     end
 
-    it "#flatten should return matrix flattened to array." do
+    it '#flatten should return matrix flattened to array.' do
       @zero_matrix.flatten.must_be_instance_of Array
-      @zero_matrix.flatten.must_equal [0,0,0,0] 
+      @zero_matrix.flatten.must_equal [0, 0, 0, 0]
     end
-    
-    it "#to_a should return internal representation (nested arrays)" do
+
+    it '#to_a should return internal representation (nested arrays)' do
       @zero_matrix.to_a.must_be_instance_of Array
-      @zero_matrix.to_a.must_equal [[0,0],[0,0]]
+      @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
+    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
-
+  describe 'initialized with false' do
     before do
-      @discrete_matrix = Array2D.new(3,false)
+      @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]
+    it 'should return false for any index.' do
+      refute @discrete_matrix[1, 1]
+      refute @discrete_matrix[0, 0]
     end
 
-    it "#flatten should return matrix flattened to array." do
+    it '#flatten should return matrix flattened to array.' do
       @discrete_matrix.flatten.must_be_instance_of Array
-      @discrete_matrix.flatten.must_equal [false,false,false,false,false,false,false,false,false] 
+      @discrete_matrix.flatten.must_equal [false, false, false, false, false, false, false, false, false]
     end
 
-    it "#to_a should return internal representation (nested arrays)" do
+    it '#to_a should return internal representation (nested arrays)' 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]]
+      @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
+    it '#should extend magically.' do
+      refute @discrete_matrix[3, 3]
+      @discrete_matrix[4, 8].wont_be_nil
     end
-
   end
 end
-
-