DSA 0.0.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1cf45aaf41acd85971600055fd5dfac1825e539b
-  data.tar.gz: 8ab7c55725ae11725a9e9ef7bff86c6d9416a1a0
+  metadata.gz: cd9d302cc8e21bcb88c9a087cafa81fb2835b371
+  data.tar.gz: d44c6c4347afeab407ffed1fb7fe1dd36a1a18f2
 SHA512:
-  metadata.gz: 1085cb96b51a4b9dd4f168454cb9218bfa8cc473c2050a8cf662cfecc6feabd002876da7a6005bc28db323bd6a8f9f9a338dff5e6930cd20b4044b11a51051d1
-  data.tar.gz: bd64fc623b6c397346f355cc8b6e7cf289e7bc3e4e69138313c985cfb17830f7b2d466eec48df623f5cd217ac07ad771b611412803e6509523c952e954465845
+  metadata.gz: baffedd679af3f07429c79665a58f664bad3ef1f1dcb3ca739b518808c6f60e7319f3b7f536fd36c81fb8b78e7ecc8a7de858a8603866b54f8724a2ee221e53f
+  data.tar.gz: 9784aa8e128162b51b4cf84dea3738aedcfdc22bec40724c4106aa0f28f15a9218e34a06333745a29b1a07433a85dc836618ab5c2f9b282f2e8376183f319530

data/.gitignore

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

data/DSA.gemspec

@@ -1,24 +1,24 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'DSA/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = "DSA"
-  spec.version       = DSA::VERSION
-  spec.authors       = ["lusaisai"]
-  spec.email         = ["lusaisai@163.com"]
-  spec.summary       = %q{Data Structures and Algorithms in Ruby}
-  spec.description   = %q{List, BinarySearchTree(RedBlackTree), PriorityQueue, (Array/List)Stack and Queue}
-  spec.homepage      = "https://github.com/lusaisai/DSA"
-  spec.license       = "MIT"
-
-  spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
-
-  spec.add_development_dependency "bundler", "~> 1.5"
-  spec.add_development_dependency "rake"
-end
-
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'DSA/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "DSA"
+  spec.version       = DSA::VERSION
+  spec.authors       = ["lusaisai"]
+  spec.email         = ["lusaisai@163.com"]
+  spec.summary       = %q{Data Structures and Algorithms in Ruby}
+  spec.description   = %q{List, BinarySearchTree(RedBlackTree), SkipList, PriorityQueue, (Array/List)Stack and Queue}
+  spec.homepage      = "https://github.com/lusaisai/DSA"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+end
+

data/Gemfile

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

data/LICENSE.txt

@@ -1,23 +1,23 @@
-Copyright (c) 2014 lusaisai
-
-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.
-
+Copyright (c) 2014 lusaisai
+
+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

@@ -5,28 +5,28 @@ Ruby gem for basic Data Structures and Algorithms
 ## Installation
 
 Add this line to your application's Gemfile:
-```bash
+```
     gem 'DSA'
 ```
 And then execute:
-```bash
+```
     $ bundle
 ```
 Or install it yourself as:
-```bash
+```
     $ gem install DSA
 ```
 ## Usage
 
 To include the package,
-```ruby
+```
     require 'DSA'
 ```
 
 ### List
 A doubly linked list data structure. Use when there are lots of insertions/deletions in the middle,
 otherwise, built-in array is better.
-```ruby
+```
     l = DSA::List.new
     l.push 'some value'
     l.pop
@@ -38,13 +38,13 @@ otherwise, built-in array is better.
     l.length
 ```
 General access/removal/insertion using index is supported, these operations require linear time, so use carefully.
-```ruby
+```
     l[2]
     l.insert_at 10, 'some value'
     l.remove_at 2
 ```
 To do lots of insertions/deletions, use the iterator, StopIteration is raised when reaching to head or tail
-```ruby
+```
     li = l.begin_iterator # the iterator starts from the head
     puts li.next
     li.insert 'some value'
@@ -61,19 +61,19 @@ the performance might not be the best, use only when a full traversal is inevita
 An ordered map, works like a hash, but preserves an order and provides range search, implemented as a RedBlack tree.
 
 The following three are aliases in creating a new object,
-```ruby
+```
     rb = DSA::BinarySearchTree.new
     rb = DSA::OrderedMap.new
     rb = DSA::RedBlackTree.new
 ```
 Method are very like a hash,
-```ruby
+```
     rb[key] = value
     rb[key]
     rb.delete key
 ```
 And special methods related to orders, those methods yield key/value pairs to block, if no block, enumerator is returned.
-```ruby
+```
     rb.each # in-order traversal
     rb.gt(key) # key/value pairs for keys greater than key
     rb.ge(key)
@@ -81,7 +81,7 @@ And special methods related to orders, those methods yield key/value pairs to bl
     rb.le(key)
 ```
 A help method tried to print a tree, not quite pretty, but may helps test
-```ruby
+```
     rb.bfs_print
 ```
 Enumerable is included, all those method such as 'each' are all available, since other methods are based on each,
@@ -90,7 +90,7 @@ the performance might not be the best, use only when a full traversal is inevita
 ### SkipList
 An ordered map, storing key/value pairs, duplicate keys are allowed, value can be omitted, preserves an order and provides range search, implemented as a skip list.
 
-```ruby
+```
     sl = DSA::SkipList.new
     sl.add key, value
     sl.add key # value will be nil
@@ -99,7 +99,7 @@ An ordered map, storing key/value pairs, duplicate keys are allowed, value can b
 ```
 
 And special methods related to orders, those methods yield key/value pairs to block, if no block, enumerator is returned.
-```ruby
+```
     sl.find key
     sl.each # in-order traversal
     sl.gt(key) # key/value pairs for keys greater than key
@@ -108,7 +108,7 @@ And special methods related to orders, those methods yield key/value pairs to bl
     sl.le(key)
 ```
 A help method prints the skip list
-```ruby
+```
     sl.print_me
     sl.print_me width # width, the length of evert key/value pair, default to 10
 ```
@@ -118,7 +118,7 @@ the performance might not be the best, use only when a full traversal is inevita
 
 ### PriorityQueue
 An array based heap, priority is a number, the smaller it is, higher priority it has
-```ruby
+```
     pq = DSA::PriorityQueue.new
     pq.add 10, 'some job'
     pq.length
@@ -128,7 +128,7 @@ An array based heap, priority is a number, the smaller it is, higher priority it
 
 ### Stack and Queue
 Implemented based on array or list.
-```ruby
+```
     s = DSA::ArrayStack.new
     s = DSA::ListStack.new
     s.push 'some value'
@@ -136,7 +136,8 @@ Implemented based on array or list.
     s.empty?
     s.top
     s.length
-
+```
+```
     q = DSA::ArrayQueue.new
     q = DSA::ListQueue.new
     q.enqueue 'some value'
@@ -148,9 +149,17 @@ Implemented based on array or list.
 ### Algorithm
 The following functions are for demonstrations, specially sort, using built-in Array#bsearch and Array#sort instead,
 they have a better performance.
-```ruby
+```
     DSA::Algorithm::factorial(5)
+    DSA::Algorithm::fibonacci(10) # There are different implementations with different performance, defaults to fibonacci_logarithm(10)
+    DSA::Algorithm::fibonacci_exponential(10)
+    DSA::Algorithm::fibonacci_linear(10)
+    DSA::Algorithm::fibonacci_logarithm(10)
+    DSA::Algorithm::fibonacci_constant(10)
+    DSA::Algorithm::fibonacci_bad(10)
     DSA::Algorithm::binary_search((1..9).to_a, 2, 0, 8)
     DSA::Algorithm::insertion_sort!(array)
     DSA::Algorithm::quick_sort!(array, 0, array.length-1)
+    DSA::Algorithm::radix_sort(array) # array should be integers
+    DSA::Algorithm::sqrt(number)
 ```

data/Rakefile

@@ -1,2 +1,2 @@
-require "bundler/gem_tasks"
-
+require "bundler/gem_tasks"
+

data/lib/DSA.rb

@@ -1,11 +1,11 @@
-require_relative 'DSA/version'
-require_relative 'DSA/algorithm'
-require_relative 'DSA/stack_and_queue'
-require_relative 'DSA/list'
-require_relative 'DSA/priority_queue'
-require_relative 'DSA/binary_search_tree'
-require_relative 'DSA/skip_list'
-
-module DSA
-  # Your code goes here...
-end
+require_relative 'DSA/version'
+require_relative 'DSA/algorithm'
+require_relative 'DSA/stack_and_queue'
+require_relative 'DSA/list'
+require_relative 'DSA/priority_queue'
+require_relative 'DSA/binary_search_tree'
+require_relative 'DSA/skip_list'
+
+module DSA
+  # Your code goes here...
+end

data/lib/DSA/algorithm.rb

@@ -11,6 +11,102 @@ module DSA
     end
 
 
+    def self.fibonacci(n)
+      self.fibonacci_logarithm(n)
+    end
+
+    # we could implement fibonacci using recursion which looks simple, unfortunately, the running time of this algorithm
+    # itself is a fibonacci sequence, which grows fast, kind of exponential
+    def self.fibonacci_exponential(n)
+      if !n.is_a? Integer or n < 0
+        raise ArgumentError
+      end
+
+      if n == 0
+        0
+      elsif n == 1
+        1
+      elsif n >= 2
+        fibonacci_exponential(n-1) + fibonacci_exponential(n-2)
+      end
+    end
+
+
+    # fibonacci numbers
+    def self.fibonacci_linear(n)
+      if !n.is_a? Integer or n < 0
+        raise ArgumentError
+      end
+
+      if n == 0
+        0
+      elsif n == 1
+        1
+      elsif n >= 2
+        a = 0
+        b = 1
+        2.upto(n) {
+          b, a = a + b, b
+        }
+        b
+      end
+    end
+
+    # fibonacci sequences can be calculated in matrix multiplying
+    # [[f(n+1), f(n)], [f(n), f(n-1)]] equals [[1,1], [1,0]] to the nth
+    # matrix multiplying can be achieved in logarithm time if we use divide and conquer
+    def self.fibonacci_logarithm(n)
+      if !n.is_a? Integer or n < 0
+        raise ArgumentError
+      end
+
+      if n == 0
+        0
+      elsif n == 1
+        1
+      elsif n >= 2
+        result = self.fibonacci_matrix_nth(n)
+        result[0][1]
+      end
+    end
+
+    def self.fibonacci_matrix_nth(n)
+      first = [[1,1], [1,0]]
+      if n == 1
+        first
+      elsif n % 2 == 0
+        half = self.fibonacci_matrix_nth(n/2)
+        square_matrix_multiply(half, half)
+      else
+        square_matrix_multiply(first, self.fibonacci_matrix_nth(n-1))
+      end
+    end
+
+    def self.square_matrix_multiply(a, b, size=2)
+      result = []
+      n = size - 1
+      0.upto(n) do |i|
+        result[i] = []
+        0.upto(n) do |j|
+          result[i][j] = 0
+          0.upto(n) do |k|
+            result[i][j] += a[i][k] * b[k][j]
+          end
+        end
+      end
+      result
+    end
+
+
+    # It is kind of cheating, but mathematicians are unbelievable,
+    # they figured out a function to calculate the fibonacci sequence directly.
+    # There's limitation on the 64-bit float numbers, so only use it to calculate small numbers.
+    def self.fibonacci_constant(n)
+      phi = 1.618034
+      ((phi ** n - (1-phi) ** n) / Math.sqrt(5)).round
+    end
+
+
     # Binary search in sorted array
     def self.binary_search(data, target, low, high)
       return false if low > high
@@ -64,5 +160,39 @@ module DSA
       quick_sort!(data, left, high)
     end
 
+    # radix sort, in base 10
+    def self.radix_sort(data)
+      goto_next_digit = true
+      position = 0
+      while goto_next_digit
+        goto_next_digit = false
+        buckets = []
+        10.times { buckets << [] }
+        data.each do |number|
+          digit = get_digit(number, position)
+          goto_next_digit = true if digit > 0 # if all digits are zero, loop will end
+          buckets[digit] << number
+        end
+        data = buckets.flatten!
+        position += 1
+      end
+      data
+    end
+
+    def self.sqrt(n)
+      err = 1e-10
+      r = Float(n)
+      while (r - n/r).abs >= err
+        r = ( r + n/r ) / 2
+      end
+      r
+    end
+
+
+    private
+    def self.get_digit(number, position)
+      number % (10 ** (position+1)) / (10 ** position)
+    end
+
   end
 end

data/lib/DSA/version.rb

@@ -1,3 +1,3 @@
-module DSA
-  VERSION = "0.0.3"
-end
+module DSA
+  VERSION = '1.0.0'
+end

data/test/algorithms_test.rb

@@ -17,11 +17,41 @@ class MyTest < Test::Unit::TestCase
     # Do nothing
   end
 
+  def test_sqrt
+    puts 'square root of 2 is ', DSA::Algorithm::sqrt(2)
+    puts 'square root of 25 is ', DSA::Algorithm::sqrt(25)
+    puts 'square root of 123456.789 is ', DSA::Algorithm::sqrt(123456.789)
+  end
+
+  def test_radix_sort
+    assert_equal( 2, DSA::Algorithm::get_digit(123, 1), 'get digit failed' )
+    assert_equal( 0, DSA::Algorithm::get_digit(123, 5), 'get digit failed' )
+    original = [123,6,7890,88,32,254,345677,238,1,125,29,226]
+    expected = [1, 6, 29, 32, 88, 123, 125, 226, 238, 254, 7890, 345677]
+    assert_equal expected, DSA::Algorithm::radix_sort(original), 'sort failed'
+  end
+
   def test_function
     assert_equal 120, DSA::Algorithm::factorial(5), 'factorial function is wrong'
     assert DSA::Algorithm::binary_search((1..9).to_a, 2, 0, 8), 'binary search failed'
+    assert_equal 55, DSA::Algorithm::fibonacci(10), 'fibonacci failed'
   end
 
+  def test_fibonacci
+    assert_equal 55, DSA::Algorithm::fibonacci_exponential(10), 'fibonacci_exponential failed'
+    assert_equal 55, DSA::Algorithm::fibonacci_linear(10), 'fibonacci_linear failed'
+    assert_equal 55, DSA::Algorithm::fibonacci_logarithm(10), 'fibonacci_logarithm failed'
+    assert_equal 55, DSA::Algorithm::fibonacci_constant(10), 'fibonacci_constant failed'
+    Benchmark.bm(20) do |x|
+      # x.report('fibonacci exponential') { DSA::Algorithm::fibonacci_exponential(35) }
+      x.report('fibonacci linear') { DSA::Algorithm::fibonacci_linear(99999) }
+      x.report('fibonacci logarithm') { DSA::Algorithm::fibonacci_logarithm(99999) }
+      x.report('fibonacci constant') { DSA::Algorithm::fibonacci_constant(1000) }
+      # x.report('fibonacci constant') { DSA::Algorithm::fibonacci_constant(100000) }
+    end
+  end
+
+
   def test_performance
     puts
 
@@ -50,11 +80,8 @@ class MyTest < Test::Unit::TestCase
   end
 
   def test_sort_performance
-
-
-
     puts 'sort on already sorted'
-    puts
+    puts '=' * 50
     value = 10**5
     sorted_a = (0..value).to_a
     sorted_b = sorted_a.map {|e| e}
@@ -69,8 +96,9 @@ class MyTest < Test::Unit::TestCase
     assert_equal sorted_a, sorted_b, ''
     assert_equal sorted_a, sorted_c, ''
 
-
+    puts
     puts 'sort on not sorted'
+    puts '=' * 50
     value = 10**4
     not_sorted_a = value.times.map { Random.rand(value) }
     not_sorted_b = not_sorted_a.map { |e| e }
@@ -83,12 +111,16 @@ class MyTest < Test::Unit::TestCase
     assert_equal not_sorted_a, not_sorted_b, ''
     assert_equal not_sorted_a, not_sorted_c, ''
 
-    puts 'sort on not sorted'
+    puts
+    puts 'sort on a million not sorted'
+    puts '=' * 50
     value = 10**6
     not_sorted_b = value.times.map { Random.rand(value) }
     not_sorted_c = value.times.map { Random.rand(value) }
+    not_sorted_d = value.times.map { Random.rand(value) }
     Benchmark.bm(20) do |x|
       x.report('quick sort') { DSA::Algorithm::quick_sort! not_sorted_c, 0, not_sorted_c.length-1 }
+      x.report('radix sort') { DSA::Algorithm::radix_sort not_sorted_d }
       x.report('built in sort') { not_sorted_b.sort!  }
     end
 

metadata

@@ -1,44 +1,44 @@
 --- !ruby/object:Gem::Specification
 name: DSA
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 1.0.0
 platform: ruby
 authors:
 - lusaisai
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-22 00:00:00.000000000 Z
+date: 2015-03-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: List, BinarySearchTree(RedBlackTree), PriorityQueue, (Array/List)Stack
+description: List, BinarySearchTree(RedBlackTree), SkipList, PriorityQueue, (Array/List)Stack
   and Queue
 email:
 - lusaisai@163.com
@@ -46,7 +46,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - DSA.gemspec
 - Gemfile
 - LICENSE.txt
@@ -76,17 +76,17 @@ 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.0.14
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Data Structures and Algorithms in Ruby