DSA 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f9927035d95a766e70b9f202d3ccba141d2665bd
-  data.tar.gz: 78444502a579279fe7d288e4fe48a5f24684a7f7
+  metadata.gz: 8b389b9d9e679bc3e426a95abfc2f103c93596a8
+  data.tar.gz: d44481bab4cc8cf982623829d822f91193880f3e
 SHA512:
-  metadata.gz: cf06eb363bfdc2b9e7aee1b746a73f106ac7919df4dc229008b32e9c06d06265ce1157a6191ad0c0af775b04a56c19e7007c78dd89d7b10b9450f89e9ae3191e
-  data.tar.gz: 34e8770d943e932144dcd1e9d61034f1fee333655ee128c32b033110ac9c3c5be3f890fd8da9fa778d7f5edb8aa04dbe08941cd856778963f6e4cc794706bc57
+  metadata.gz: 284aba1b513d954e3a87033ae58b3c4bb9b3123f9f1c49e028e310e0c2f36a6f79d9c5468f17564808e75fa83cc9c0a7736a0623128b3e863d1c49c671614312
+  data.tar.gz: ff67a7432ac7656b1a7697f11448c1148fcc1034c4d5dcc4107a4f560abf33529354149c19aafa6289d8115d8c802146b5f5f47b85ab4cbecaadc22746d1092c

data/README.md

@@ -1,127 +1,128 @@
-# DSA
-
-Ruby gem for basic Data Structures and Algorithms
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-    gem 'DSA'
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install DSA
-
-## Usage
-
-To include the package,
-
-    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.
-
-    l = DSA::List.new
-    l.push 'some value'
-    l.pop
-    l.unshift 'some value'
-    l.shift
-    l.first
-    l.last
-    l.empty?
-    l.length
-
-General access/removal/insertion using index is supported, these operations require linear time, so use carefully.
-
-    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
-
-    li = l.begin_iterator # the iterator starts from the head
-    puts li.next
-    li.insert 'some value'
-    li.remove
-    li.update 'new value'
-
-    li = l.end_iterator # the iterator starts from the tail
-    li.previous
-
-Enumerable is included, all those method such as 'each' are all available, since other methods are based on each,
-the performance might not be the best, use only when a full traversal is inevitable.
-
-### BinarySearchTree
-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,
-
-    rb = DSA::BinarySearchTree.new
-    rb = DSA::OrderedMap.new
-    rb = DSA::RedBlackTree.new
-
-Method are very like a hash,
-
-    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.
-
-    rb.each # in-order traversal
-    rb.gt(key) # key/value pairs for keys greater than key
-    rb.ge(key)
-    rb.lt(key)
-    rb.le(key)
-
-A help method tried to print a tree, not quite pretty, but may helps test
-
-    rb.bfs_print
-
-Enumerable is included, all those method such as 'each' are all available, since other methods are based on each,
-the performance might not be the best, use only when a full traversal is inevitable.
-
-
-### PriorityQueue
-An array based heap, priority is a number, the smaller it is, higher priority it has
-
-    pq = DSA::PriorityQueue.new
-    pq.add 10, 'some job'
-    pq.length
-    pq.top  # look at the highest priority without removing it
-    job = pq.pop # get and remove the highest priority job
-
-
-### Stack and Queue
-Implemented based on array or list.
-
-    s = DSA::ArrayStack.new
-    s = DSA::ListStack.new
-    s.push 'some value'
-    s.pop
-    s.empty?
-    s.top
-    s.length
-
-    q = DSA::ArrayQueue.new
-    q = DSA::ListQueue.new
-    q.enqueue 'some value'
-    q.dequeue
-    q.empty?
-    q.first
-    q.length
-
-### Algorithm
-The following functions are for demonstrations, specially sort, using built-in Array#bsearch and Array#sort instead,
-they have a better performance.
-
-    DSA::Algorithm::factorial(5)
-    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
+
+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
+    l.unshift 'some value'
+    l.shift
+    l.first
+    l.last
+    l.empty?
+    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'
+    li.remove
+    li.update 'new value'
+
+    li = l.end_iterator # the iterator starts from the tail
+    li.previous
+```
+Enumerable is included, all those method such as 'each' are all available, since other methods are based on each,
+the performance might not be the best, use only when a full traversal is inevitable.
+
+### BinarySearchTree
+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)
+    rb.lt(key)
+    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,
+the performance might not be the best, use only when a full traversal is inevitable.
+
+
+### 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
+    pq.top  # look at the highest priority without removing it
+    job = pq.pop # get and remove the highest priority job
+```
+
+### Stack and Queue
+Implemented based on array or list.
+```ruby
+    s = DSA::ArrayStack.new
+    s = DSA::ListStack.new
+    s.push 'some value'
+    s.pop
+    s.empty?
+    s.top
+    s.length
+
+    q = DSA::ArrayQueue.new
+    q = DSA::ListQueue.new
+    q.enqueue 'some value'
+    q.dequeue
+    q.empty?
+    q.first
+    q.length
+```
+### 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::binary_search((1..9).to_a, 2, 0, 8)
+    DSA::Algorithm::insertion_sort!(array)
+    DSA::Algorithm::quick_sort!(array, 0, array.length-1)
+```

data/lib/DSA/algorithm.rb

@@ -44,9 +44,9 @@ module DSA
     # in place quick sort
     def self.quick_sort!(data, low, high)
       return if low >= high
-      pivot = data[high]
+      pivot = data[Random.rand(low..high)]
       left = low
-      right = high - 1
+      right = high
       while left <= right
         until left > right || data[left] >= pivot
           left += 1
@@ -60,9 +60,8 @@ module DSA
           right -= 1
         end
       end
-      data[left], data[high] = data[high], data[left]
-      quick_sort!(data, low, left - 1)
-      quick_sort!(data, left+1, high)
+      quick_sort!(data, low, right)
+      quick_sort!(data, left, high)
     end
 
   end

data/lib/DSA/version.rb

@@ -1,3 +1,3 @@
 module DSA
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/test/algorithms_test.rb

@@ -47,32 +47,41 @@ class MyTest < Test::Unit::TestCase
     DSA::Algorithm::quick_sort!(original, 0, original.length-1)
     assert_equal expect, original, 'sort failed'
 
-    puts
-    puts 'insertion sort vs built in'
-    value = 10**3
-    sorted_a = (0..value).to_a
-    sorted_b = (0..value).to_a
-    sorted_c = (0..value).to_a
+  end
+
+  def test_sort_performance
+
 
 
     puts 'sort on already sorted'
+    puts
+    value = 10**5
+    sorted_a = (0..value).to_a
+    sorted_b = sorted_a.map {|e| e}
+    sorted_c = sorted_a.map {|e| e}
+    assert_equal sorted_a, sorted_b, ''
+    assert_equal sorted_a, sorted_c, ''
     Benchmark.bm(20) do |x|
       x.report('insertion sort') { DSA::Algorithm::insertion_sort! sorted_a }
       x.report('quick sort') { DSA::Algorithm::quick_sort! sorted_c, 0, sorted_c.length-1 }
       x.report('built in sort') { sorted_b.sort!  }
     end
+    assert_equal sorted_a, sorted_b, ''
+    assert_equal sorted_a, sorted_c, ''
 
 
     puts 'sort on not sorted'
     value = 10**4
     not_sorted_a = value.times.map { Random.rand(value) }
-    not_sorted_b = value.times.map { Random.rand(value) }
-    not_sorted_c = value.times.map { Random.rand(value) }
+    not_sorted_b = not_sorted_a.map { |e| e }
+    not_sorted_c = not_sorted_a.map { |e| e }
     Benchmark.bm(20) do |x|
       x.report('insertion sort') { DSA::Algorithm::insertion_sort! not_sorted_a }
       x.report('quick sort') { DSA::Algorithm::quick_sort! not_sorted_c, 0, not_sorted_c.length-1 }
       x.report('built in sort') { not_sorted_b.sort!  }
     end
+    assert_equal not_sorted_a, not_sorted_b, ''
+    assert_equal not_sorted_a, not_sorted_c, ''
 
     puts 'sort on not sorted'
     value = 10**6

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: DSA
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - lusaisai
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-20 00:00:00.000000000 Z
+date: 2014-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler