algorithms 0.6.1 → 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d542bb52d6a148cc95802bfc5d84549e605b7077009343496e51a00d405bed05
+  data.tar.gz: b66ba40d7c3b4d29f108294e2623f85c48f52f1cdcfa7282191ed412d1877cf5
+SHA512:
+  metadata.gz: 3bacbfc0793cce5bb67c51b33a64a6a4bb91e0d2cdfea661e5ee5721433bdbc19b723724ebb54e86289b053e71740dcd4c70a7e02fbed998015cd4fa31728f67
+  data.tar.gz: f2ec4934f51e631750aea36af36fb33a4b2dc0fee95ec1b138a8e97c75952b341f9f235e17a12868bb9233e88f6bb4bcfff0800e47fefe417712ee9167d389b1

data/README.markdown

@@ -1,4 +1,6 @@
-# algorithms [![Build Status](https://travis-ci.org/kanwei/algorithms.png)](https://travis-ci.org/kanwei/algorithms)
+# algorithms [![Build Status](https://travis-ci.org/kanwei/algorithms.svg?branch=master)](https://travis-ci.org/github/kanwei/algorithms)
+
+[API Documentation](http://kanwei.github.io/algorithms/)
 
 ## DESCRIPTION:
 
@@ -6,7 +8,7 @@ Started as a [Google Summer of Code 2008](http://code.google.com/soc/2008/ruby/a
 
 Written by [Kanwei Li](http://kanwei.com/), mentored by Austin Ziegler
 
-### Original Proposal: ###
+## Original Proposal: ##
 
 Using the right data structure or algorithm for the situation is an important
 aspect of programming. In computer science literature, many data structures
@@ -41,6 +43,7 @@ compare performance in different situations.
       - Shell sort               Algorithms::Sort.shell_sort
       - Quicksort                Algorithms::Sort.quicksort
       - Mergesort                Algorithms::Sort.mergesort
+      - Dual-Pivot Quicksort     Algorithms::Sort.dualpivotquicksort
 
 ## SYNOPSIS:
 
@@ -60,25 +63,4 @@ compare performance in different situations.
 
 ## LICENSE:
 
-(The MIT License)
-
-Ruby Algorithms and Containers project is Copyright (c) 2009 Kanwei Li
-
-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.
+See [LICENSE.md](LICENSE.md).

data/Rakefile

@@ -16,3 +16,7 @@ if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
 else
   task :default => [:compile, :spec]
 end
+
+task :rdoc do
+    `rdoc -f hanna --main algorithms.rb -t "Ruby Algorithms and Containers Documentation"`
+end

data/algorithms.gemspec

@@ -2,12 +2,12 @@
 
 Gem::Specification.new do |s|
   s.name = "algorithms"
-  s.version = "0.6.1"
+  s.version = "1.0.1"
 
   s.authors = ["Kanwei Li"]
   s.email = "kanwei@gmail.com"
   s.license = 'MIT'
-  s.date = "2013-01-22"
+  s.date = "2023-11-11"
   s.summary = "Useful algorithms and data structures for Ruby. Optional C extensions."
   s.description = "Heap, Priority Queue, Deque, Stack, Queue, Red-Black Trees, Splay Trees, sorting algorithms, and more"
   if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
@@ -19,5 +19,4 @@ Gem::Specification.new do |s|
   s.homepage = "https://github.com/kanwei/algorithms"
   s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Algorithms", "--main", "README.markdown"]
   s.require_paths = ["lib", "ext"]
-  s.rubyforge_project = "algorithms"
 end

data/ext/algorithms/string/string.c

@@ -26,7 +26,7 @@ long levenshtein_distance(VALUE str1, VALUE str2) {
 	s1_len++;
 	s2_len++;
 	
-	d = malloc(sizeof(typeof(d)) * (s1_len) * (s2_len));
+	d = xmalloc(sizeof(typeof(d)) * s1_len * s2_len);
 	
 	for (i = 0; i < s1_len; i++) {
 		d[i] = i; // d[i, 0] = i
@@ -49,7 +49,7 @@ long levenshtein_distance(VALUE str1, VALUE str2) {
 		}
 	}
 	i = d[s1_len * s2_len -1];
-	free(d);
+	xfree(d);
 	return i;
 }
 

data/ext/containers/bst/bst.c

@@ -172,7 +172,7 @@ static void recursively_free_nodes(bst_node *node) {
 	if(node) {
 		recursively_free_nodes(node->left);
 		recursively_free_nodes(node->right);
-		free(node);
+		xfree(node);
 	}
 }
 

data/ext/containers/deque/deque.c

@@ -19,7 +19,7 @@ void free_nodes(deque_node *node) {
 	deque_node *next;
 	while(node) {
 		next = node->right;
-		free(node);
+		xfree(node);
 		node = next;
 	}
 	return;
@@ -71,7 +71,7 @@ static void deque_free(void *ptr) {
 	if (ptr) {
 		deque *deque = ptr;
 		free_nodes(deque->front);
-		free(deque);
+		xfree(deque);
 	}
 }
 

data/ext/containers/rbtree_map/rbtree.c

@@ -31,7 +31,7 @@ static void recursively_free_nodes(rbtree_node *node) {
 	if(node) {
 		recursively_free_nodes(node->left);
 		recursively_free_nodes(node->right);
-		free(node);
+		xfree(node);
 	}
 	return;
 }
@@ -198,7 +198,7 @@ static rbtree_node* delete_min(rbtree_node *h, VALUE *deleted_value) {
 	if ( !h->left ) {
 		if(deleted_value)
 			*deleted_value = h->value;
-		free(h);
+		xfree(h);
 		return NULL;
 	}
 	
@@ -216,7 +216,7 @@ static rbtree_node* delete_max(rbtree_node *h, VALUE *deleted_value) {
 
 	if ( !h->right ) {
 		*deleted_value = h->value;
-		free(h);
+		xfree(h);
 		return NULL;
 	}
 
@@ -245,7 +245,7 @@ static rbtree_node* delete(rbtree *tree, rbtree_node *node, VALUE key, VALUE *de
 		cmp = tree->compare_function(key, node->key);
 		if ( (cmp == 0) && !node->right ) {
 			*deleted_value = node->value;
-			free(node);
+			xfree(node);
 			return NULL;
 		}
 
@@ -339,7 +339,7 @@ static void rbtree_mark(void *ptr) {
 				}
 				old = current;
 				current = current->next;
-				free(old);
+				xfree(old);
 			}
 		}
 	}
@@ -349,7 +349,7 @@ static void rbtree_free(void *ptr) {
 	if (ptr) {
 		rbtree *tree = ptr;
 		recursively_free_nodes(tree->root);
-		free(tree);
+		xfree(tree);
 	}
 }
 

data/ext/containers/splaytree_map/splaytree.c

@@ -28,7 +28,7 @@ static void recursively_free_nodes(splaytree_node *node) {
 	if(node) {
 		recursively_free_nodes(node->left);
 		recursively_free_nodes(node->right);
-		free(node);
+		xfree(node);
 	}
 	return;
 }
@@ -199,7 +199,7 @@ static splaytree_node* delete(splaytree *tree, splaytree_node *n, VALUE key, VAL
 			x = splay(tree, n->left, key);
 			x->right = n->right;
 		}
-		free(n);
+		xfree(n);
 		if (x) {
 			x->size = tsize-1;
 		}
@@ -282,7 +282,7 @@ static void splaytree_mark(void *ptr) {
 				}
 				old = current;
 				current = current->next;
-				free(old);
+				xfree(old);
 			}
 		}
 	}
@@ -292,7 +292,7 @@ static void splaytree_free(void *ptr) {
 	if (ptr) {
 		splaytree *tree = ptr;
 		recursively_free_nodes(tree->root);
-		free(tree);
+		xfree(tree);
 	}
 }
 

data/lib/algorithms/sort.rb

@@ -235,4 +235,134 @@ module Algorithms::Sort
     sorted + left + right
   end
 
+  # Dual-Pivot Quicksort is a variation of Quicksort by Vladimir Yaroslavskiy.
+  # This is an implementation of the algorithm as it was found in the original
+  # research paper:
+  # 
+  # http://iaroslavski.narod.ru/quicksort/DualPivotQuicksort.pdf
+  # 
+  # Mirror:
+  # http://codeblab.com/wp-content/uploads/2009/09/DualPivotQuicksort.pdf
+  #
+  # "This algorithm offers O(n log(n)) performance on many data sets that cause
+  # other quicksorts to degrade to quadratic performance, and is typically 
+  # faster than traditional (one-pivot) Quicksort implementations."
+  #   -- http://download.oracle.com/javase/7/docs/api/java/util/Arrays.html
+  #
+  # The algorithm was improved by Vladimir Yaroslavskiy, Jon Bentley, and 
+  # Joshua Bloch, and was implemented as the default sort algorithm for
+  # primatives in Java 7.
+  #
+  # Implementation in the Java JDK as of November, 2011:
+  # http://www.docjar.com/html/api/java/util/DualPivotQuicksort.java.html
+  #
+  # It is proved that for the Dual-Pivot Quicksort the average number 
+  # of comparisons is 2*n*ln(n), the average number of swaps is 
+  # 0.8*n*ln(n), whereas classical Quicksort algorithm has 2*n*ln(n) 
+  # and 1*n*ln(n) respectively. This has been fully examined mathematically
+  # and experimentally.
+  #
+  # Requirements: Container should implement #pop and include the Enumerable module.
+  # Time Complexity: О(n log n) average, О(n log n) worst-case
+  # Space Complexity: О(n) auxiliary
+  #
+  # Stable: No
+  # 
+  #   Algorithms::Sort.dualpivotquicksort [5, 4, 3, 1, 2] => [1, 2, 3, 4, 5]
+
+  def self.dualpivotquicksort(container)
+    return container if container.size <= 1
+    dualpivot(container, 0, container.size-1, 3)
+  end
+ 
+  def self.dualpivot(container, left=0, right=container.size-1, div=3)
+    length = right - left
+    if length < 27 # insertion sort for tiny array
+      container.each_with_index do |data,i|
+        j = i - 1
+        while j >= 0
+          break if container[j] <= data
+          container[j + 1] = container[j]
+          j = j - 1
+        end
+        container[j + 1] = data
+      end
+    else # full dual-pivot quicksort
+      third = length / div
+      # medians
+      m1 = left + third
+      m2 = right - third
+      if m1 <= left 
+        m1 = left + 1
+      end
+      if m2 >= right
+        m2 = right - 1
+      end
+      if container[m1] < container[m2]
+        dualpivot_swap(container, m1, left)
+        dualpivot_swap(container, m2, right)
+      else
+        dualpivot_swap(container, m1, right)
+        dualpivot_swap(container, m2, left)
+      end
+      # pivots
+      pivot1 = container[left]
+      pivot2 = container[right]
+      # pointers
+      less = left + 1
+      great = right - 1
+      # sorting
+      k = less
+      while k <= great
+        if container[k] < pivot1
+          dualpivot_swap(container, k, less += 1)
+        elsif container[k] > pivot2
+          while k < great && container[great] > pivot2
+            great -= 1
+          end
+          dualpivot_swap(container, k, great -= 1)
+          if container[k] < pivot1
+            dualpivot_swap(container, k, less += 1)
+          end
+        end
+        k += 1
+      end
+      # swaps
+      dist = great - less
+      if dist < 13
+        div += 1
+      end
+      dualpivot_swap(container, less-1, left)
+      dualpivot_swap(container, great+1, right)
+      # subarrays
+      dualpivot(container, left, less-2, div)
+      dualpivot(container, great+2, right, div)
+      # equal elements
+      if dist > length - 13 && pivot1 != pivot2
+        for k in less..great do
+          if container[k] == pivot1
+            dualpivot_swap(container, k, less)
+            less += 1
+          elsif container[k] == pivot2
+            dualpivot_swap(container, k, great)
+            great -= 1
+            if container[k] == pivot1
+              dualpivot_swap(container, k, less)
+              less += 1
+            end
+          end
+        end
+      end
+      # subarray
+      if pivot1 < pivot2
+        dualpivot(container, less, great, div)
+      end
+      container
+    end
+  end
+
+  def self.dualpivot_swap(container, i, j)
+    container[i],  container[j] = container[j],  container[i]
+  end
 end
+

data/lib/algorithms.rb

@@ -43,6 +43,7 @@
     - Shell sort            - Algorithms::Sort.shell_sort
     - Quicksort             - Algorithms::Sort.quicksort
     - Mergesort             - Algorithms::Sort.mergesort
+    - Dual-Pivot Quicksort  - Algorithms::Sort.dualpivotquicksort
   * String algorithms
     - Levenshtein distance  - Algorithms::String.levenshtein_dist
 =end

data/lib/containers/heap.rb

@@ -75,13 +75,6 @@ class Containers::Heap
     end
     @size += 1
     
-    arr = []
-    w = @next.right
-    until w == @next do
-      arr << w.value
-      w = w.right
-    end
-    arr << @next.value
     @stored[key] ||= []
     @stored[key] << node
     value

data/lib/containers/rb_tree_map.rb

@@ -15,7 +15,7 @@ require 'containers/stack'
     explicitly used as well; their functionality is identical.
     
     Most methods have O(log n) complexity.
-    
+
 =end
 class Containers::RubyRBTreeMap
   include Enumerable
@@ -160,7 +160,7 @@ class Containers::RubyRBTreeMap
     result
   end
   
-  # Deletes the item with the smallest key and returns the item. Returns nil
+  # Deletes the item with the largest key and returns the item. Returns nil
   # if key is not present.
   #
   # Complexity: O(log n)

data/lib/containers/suffix_array.rb

@@ -12,10 +12,10 @@ class Containers::SuffixArray
   #
   # Complexity: O(n^2 log n)
   #
-  #   s_array = Containers::SuffixArray("abracadabra")
+  #   s_array = Containers::SuffixArray.new("abracadabra")
   #   s_array["abra"] #=> true
   #
-  #   number = Containers::SuffixArray(1234567)
+  #   number = Containers::SuffixArray.new(1234567)
   #   number[1] #=> true
   #   number[13] #=> false 
   def initialize(string)
@@ -65,4 +65,4 @@ class Containers::SuffixArray
     return false
   end
   alias_method :[], :has_substring?
-end
+end

data/spec/deque_gc_mark_spec.rb

@@ -12,7 +12,7 @@ if defined? Containers::CDeque
       # Check if any instances were swept
       count = 0
       ObjectSpace.each_object(anon_class) { |x| count += 1 }
-      count.should eql(100)
+      expect(count).to eql(100)
     end
   end
 end

data/spec/deque_spec.rb

@@ -3,31 +3,31 @@ require 'algorithms'
 
 shared_examples "(empty deque)" do
   it "should return nil when popping objects" do
-    @deque.pop_front.should be_nil
-    @deque.pop_back.should be_nil
+    expect(@deque.pop_front).to be_nil
+    expect(@deque.pop_back).to be_nil
   end
 
   it "should return a size of 1 when sent #push_front" do
     @deque.push_front(1)
-    @deque.size.should eql(1)
+    expect(@deque.size).to eql(1)
   end
 
   it "should return a size of 1 when sent #push_back" do
     @deque.push_back(1)
-    @deque.size.should eql(1)
+    expect(@deque.size).to eql(1)
   end
 
   it "should return nil when sent #front and #back" do
-    @deque.front.should be_nil
-    @deque.back.should be_nil
+    expect(@deque.front).to be_nil
+    expect(@deque.back).to be_nil
   end
 
   it "should be empty" do
-    @deque.should be_empty
+    expect(@deque).to be_empty
   end
 
   it "should raise ArgumentError if passed more than one argument" do
-    lambda { @deque.class.send("new", Time.now, []) }.should raise_error
+    expect { @deque.class.send("new", Time.now, []) }.to raise_error(ArgumentError)
   end
 end
 
@@ -38,40 +38,40 @@ shared_examples "(non-empty deque)" do
   end
 
   it "should return last pushed object with pop_back" do
-    @deque.pop_back.should eql("10")
-    @deque.pop_back.should eql(10)
+    expect(@deque.pop_back).to eql("10")
+    expect(@deque.pop_back).to eql(10)
   end
 
   it "should return first pushed object with pop_front" do
-    @deque.pop_front.should eql(10)
-    @deque.pop_front.should eql("10")
+    expect(@deque.pop_front).to eql(10)
+    expect(@deque.pop_front).to eql("10")
   end
 
   it "should return a size greater than 0" do
-    @deque.size.should eql(2)
+    expect(@deque.size).to eql(2)
   end
 
   it "should not be empty" do
-    @deque.should_not be_empty
+    expect(@deque).not_to be_empty
   end
 
   it "should iterate in LIFO order with #each_backward" do
     arr = []
     @deque.each_backward { |obj| arr << obj }
-    arr.should eql(["10", 10])
+    expect(arr).to eql(["10", 10])
   end
 
   it "should iterate in FIFO order with #each_forward" do
     arr = []
     @deque.each_forward { |obj| arr << obj }
-    arr.should eql([10, "10"])
+    expect(arr).to eql([10, "10"])
   end
 
   it "should return nil after everything's popped" do
     @deque.pop_back
     @deque.pop_back
-    @deque.pop_back.should be_nil
-    @deque.front.should be_nil
+    expect(@deque.pop_back).to be_nil
+    expect(@deque.front).to be_nil
   end
 end
 

data/spec/heap_spec.rb

@@ -7,29 +7,29 @@ describe Containers::Heap do
   end
   
   it "should not let you merge with non-heaps" do
-    lambda { @heap.merge!(nil) }.should raise_error
-    lambda { @heap.merge!([]) }.should raise_error
+    expect { @heap.merge!(nil) }.to raise_error(ArgumentError)
+    expect { @heap.merge!([]) }.to raise_error(ArgumentError)
   end
   
   describe "(empty)" do
   
     it "should return nil when getting the maximum" do
-      @heap.max!.should be_nil
+      expect(@heap.max!).to be_nil
     end
     
     it "should let you insert and remove one item" do
-      @heap.size.should eql(0)
+      expect(@heap.size).to eql(0)
       
       @heap.push(1)
-      @heap.size.should eql(1)
+      expect(@heap.size).to eql(1)
       
-      @heap.max!.should eql(1)
-      @heap.size.should eql(0)
+      expect(@heap.max!).to eql(1)
+      expect(@heap.size).to eql(0)
     end
     
     it "should let you initialize with an array" do
       @heap = Containers::MaxHeap.new([1,2,3])
-      @heap.size.should eql(3)
+      expect(@heap.size).to eql(3)
     end
 
   end
@@ -38,25 +38,25 @@ describe Containers::Heap do
     before(:each) do
       @random_array = []
       @num_items = 100
-      @num_items.times { |x| @random_array << rand(@num_items) }
+      @num_items.times { @random_array << rand(@num_items) }
       @heap = Containers::MaxHeap.new(@random_array)
     end
     
     it "should display the correct size" do
-      @heap.size.should eql(@num_items)
+      expect(@heap.size).to eql(@num_items)
     end
     
     it "should have a next value" do
-      @heap.next.should be_true
-      @heap.next_key.should be_true
+      expect(@heap.next).to be_truthy
+      expect(@heap.next_key).to be_truthy
     end
     
     it "should delete random keys" do
-      @heap.delete(@random_array[0]).should eql(@random_array[0])
-      @heap.delete(@random_array[1]).should eql(@random_array[1])
+      expect(@heap.delete(@random_array[0])).to eql(@random_array[0])
+      expect(@heap.delete(@random_array[1])).to eql(@random_array[1])
       ordered = []
       ordered << @heap.max! until @heap.empty?
-      ordered.should eql( @random_array[2..-1].sort.reverse )
+      expect(ordered).to eql( @random_array[2..-1].sort.reverse )
     end
     
     it "should delete all keys" do
@@ -64,15 +64,15 @@ describe Containers::Heap do
       @random_array.size.times do |t|
         ordered << @heap.delete(@random_array[t])
       end
-      @heap.should be_empty
-      ordered.should eql( @random_array )
+      expect(@heap).to be_empty
+      expect(ordered).to eql( @random_array )
     end
 
     it "should be in max->min order" do
       ordered = []
       ordered << @heap.max! until @heap.empty?
       
-      ordered.should eql(@random_array.sort.reverse)
+      expect(ordered).to eql(@random_array.sort.reverse)
     end
     
     it "should change certain keys" do
@@ -84,12 +84,12 @@ describe Containers::Heap do
       heap.change_key(8, 0)
       ordered = []
       ordered << heap.min! until heap.empty?
-      ordered.should eql( [8,3,4,5,6,7,9,10,101,100] )
+      expect(ordered).to eql( [8,3,4,5,6,7,9,10,101,100] )
     end
     
     it "should not delete keys it doesn't have" do
-      @heap.delete(:nonexisting).should be_nil
-      @heap.size.should eql(@num_items)
+      expect(@heap.delete(:nonexisting)).to be_nil
+      expect(@heap.size).to eql(@num_items)
     end
     
     it "should delete certain keys" do
@@ -101,19 +101,19 @@ describe Containers::Heap do
       heap.delete(100)
       ordered = []
       ordered << heap.min! until heap.empty?
-      ordered.should eql( [3,4,6,7,8,9,10,101] )
+      expect(ordered).to eql( [3,4,6,7,8,9,10,101] )
     end
     
     it "should let you merge with another heap" do
       numbers = [1,2,3,4,5,6,7,8]
       otherheap = Containers::MaxHeap.new(numbers)
-      otherheap.size.should eql(8)
+      expect(otherheap.size).to eql(8)
       @heap.merge!(otherheap)
       
       ordered = []
       ordered << @heap.max! until @heap.empty?
       
-      ordered.should eql( (@random_array + numbers).sort.reverse)
+      expect(ordered).to eql( (@random_array + numbers).sort.reverse)
     end
     
     describe "min-heap" do
@@ -122,7 +122,7 @@ describe Containers::Heap do
         ordered = []
         ordered << @heap.min! until @heap.empty?
     
-        ordered.should eql(@random_array.sort)
+        expect(ordered).to eql(@random_array.sort)
       end
     end
     

data/spec/kd_tree_spec.rb

@@ -6,7 +6,7 @@ describe Containers::KDTree do
     kdtree = Containers::KDTree.new( {0 => [4, 3], 1 => [3, 0], 2 => [-1, 2], 3 => [6, 4],
                                      4 => [3, -5], 5 => [-2, -5] })
     closest_2 = kdtree.find_nearest([0, 0], 2)
-    closest_2.should eql([[5, 2], [9, 1]])
+    expect(closest_2).to eql([[5, 2], [9, 1]])
   end
   
   it "should work for real-life example from facebook puzzle" do
@@ -28,7 +28,7 @@ describe Containers::KDTree do
     }
     
     expected = File.read(File.join(File.dirname(__FILE__), 'kd_expected_out.txt'))
-    expected.should eql(out)
+    expect(expected).to eql(out)
   end
   
 end