ralgorithms 0.2.1 → 0.3.0

data/lib/sorting/load_ext.rb

@@ -0,0 +1,5 @@
+begin
+  require 'sorting_ext' unless ENV["RA_PURE"]
+rescue Exception => e
+  #ignore
+end

data/lib/sorting/merge_sort.rb

@@ -0,0 +1,74 @@
+require File.join(File.dirname(File.realpath(__FILE__)), "insertion_sort")
+require File.join(File.dirname(File.realpath(__FILE__)), "helper")
+module Sorting
+  class MergeSort
+    extend Helper
+    TEST_DATA_SIZE=100_000
+    SIZE_FOR_INSERTION=15
+
+    # Merge sort
+    # Comparison sort
+    # Merging
+    # Stable
+    # Time complexity: O(nlogn), Ө(nlogn), O(nlogn)
+    # Space complexity: O(n)
+    # Support parallelization
+    # Better for linked list
+    # Efficient at handling slow-to-access sequential media
+    def self.sort(data)
+      if data.size < SIZE_FOR_INSERTION
+        data = Sorting::InsertionSort.sort(data) 
+        return data
+      end
+      mid   = data.size / 2
+      left  = data[0...mid]
+      right = data[mid...data.size]
+      merge(sort(left), sort(right))
+    end
+
+    protected
+
+    def self.merge(left, right)
+      if left.empty? || right.empty?
+        return left.empty? ? right : left
+      end
+      left_size = left.size
+      right_size = right.size
+      sorted = []
+      left_i = right_i = 0
+      while true
+        if (left_value = left[left_i]) > (right_value = right[right_i])
+          value = right_value
+          right_i += 1
+        else
+          value = left_value
+          left_i += 1
+        end
+        sorted << value
+        if left_i == left_size
+          sorted += right[right_i..-1]
+          break
+        elsif right_i == right_size
+          sorted += left[left_i..-1]
+          break
+        end
+      end
+      sorted
+    end
+    
+    #def self.merge(left, right)
+    #  sorted = []
+    #  until left.empty? or right.empty?
+    #    left.first <= right.first ? sorted << left.shift : sorted << right.shift
+    #  end
+    #  sorted + left + right
+    #end
+
+
+  end
+end
+
+if __FILE__ == $0
+  require File.join(File.dirname(File.realpath(__FILE__)), "test_helper")
+  Sorting::TestHelper.test __FILE__
+end

data/lib/sorting/quick_sort.rb

@@ -0,0 +1,67 @@
+require File.join(File.dirname(File.realpath(__FILE__)), "insertion_sort")
+require File.join(File.dirname(File.realpath(__FILE__)), "helper")
+module Sorting
+  class QuickSort
+    extend Helper
+    TEST_DATA_SIZE=100_000
+    SIZE_FOR_INSERTION=12
+
+    # Quick sort
+    # Comparison sort
+    # Partitioning
+    # Unstable(in efficient implementations)
+    # Time complexity: O(nlogn), Ө(nlogn), O(n2)
+    # Space complexity: O(logn)
+    # Support parallelization
+    # Median-of-3 killer
+    def self.sort!(data)
+      quicksort(data)
+      nil
+    end
+
+    protected
+
+    def self.quicksort(data, p=0, r=data.size-1)
+      while (distance = (r - p)) > 0
+        #optimization by insertion sort
+        if distance < SIZE_FOR_INSERTION
+          Sorting::InsertionSort.sort!(data, p, r)
+          return
+        end
+        q = partition(data, p, r)
+        quicksort(data, q+1, r)
+        r = q - 1
+      end
+    end
+
+    def self.partition(data, p, r)
+      median_of_3 data, p, r
+      pivot = data[r]
+      i = p - 1
+      p.upto(r-1) do |j|
+        if data[j] <= pivot
+          i = i+1
+          data[i], data[j] = data[j],data[i]
+        end        
+      end
+      data[i+1],data[r] = data[r],data[i+1]
+      return i + 1
+    end
+
+    def self.median_of_3(data, p, r)
+      m = p + (r-p)/2
+      pivot_candidates_hash = {data[p] => p, data[m] => m, data[r] => r}
+      pivot_candidates = pivot_candidates_hash.keys
+      pivot = (pivot_candidates - pivot_candidates.minmax)[0] || pivot_candidates.last
+      pivot_index = pivot_candidates_hash[pivot]
+      data[pivot_index], data[r] = data[r], pivot if pivot_index != r
+    end
+
+  end
+end
+
+if __FILE__ == $0
+  require File.join(File.dirname(File.realpath(__FILE__)), "test_helper")
+  Sorting::TestHelper.test __FILE__
+end
+

data/lib/sorting/selection_sort.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(File.realpath(__FILE__)), "helper")
+module Sorting
+  class SelectionSort
+    extend Helper
+    TEST_DATA_SIZE=1000
+
+    # Selection sort
+    # Comparison sort
+    # Selection
+    # Unstable
+    # Time complexity: Ω(n2), Ө(n2), O(n2)
+    # Space complexity: O(n) total, O(1) auxiliary
+    # Suitable for small arrays (10-20) or write heavy situation
+    # Family: Heap sort, Smooth sort
+    def self.sort!(data)
+      max_i = data.size - 1
+      (0...max_i).each do |i|
+        min_index = i
+        ((i+1)..max_i).each do |j|
+          min_index = j if data[j] < data[min_index]
+        end
+        data[i], data[min_index] = data[min_index], data[i]
+      end
+      nil
+    end
+
+  end
+end
+
+if __FILE__ == $0
+  require File.join(File.dirname(File.realpath(__FILE__)), "test_helper")
+  Sorting::TestHelper.test __FILE__
+end

data/lib/sorting/shell_sort.rb

@@ -0,0 +1,45 @@
+require File.join(File.dirname(File.realpath(__FILE__)), "helper")
+module Sorting
+  class ShellSort
+    extend Helper
+    TEST_DATA_SIZE=100_000
+    GAP_FACTOR = 2.35
+    GAP_REQUIRED_THRESHOLD = 10
+
+    # Shell sort
+    # Comparison sort
+    # Insertion
+    # Unstable
+    # Time complexity: depends on gap sequence, best known is O(n(logn)2)
+    # Space complexity: O(1)
+    # Simple, fast
+    # Empirical gap [1750, 701, 301, 132, 57, 23, 10, 4, 1]
+    def self.sort!(data)
+      #see http://oeis.org/A102549
+      gaps = [1, 4, 10, 23, 57, 132, 301, 701, 1750].reverse
+      data_size = data.size
+      expect_gap = data_size / GAP_REQUIRED_THRESHOLD
+      while expect_gap > gaps.first
+        gaps.unshift (gaps.first*GAP_FACTOR).to_i
+      end
+      gaps.each do |gap|
+        (gap...data_size).each do |i|
+          value = data[i]
+          j = i
+          while j >= gap && value < (previous = data[j-gap])
+            data[j] = previous
+            j -= gap
+          end
+          data[j] = value
+        end
+      end
+      nil
+    end
+
+  end
+end
+
+if __FILE__ == $0
+  require File.join(File.dirname(File.realpath(__FILE__)), "test_helper")
+  Sorting::TestHelper.test __FILE__
+end

data/lib/sorting/smooth_sort.rb

@@ -0,0 +1,172 @@
+#http://www.keithschwarz.com/smoothsort/
+#http://www.keithschwarz.com/interesting/code/?dir=smoothsort
+require File.join(File.dirname(File.realpath(__FILE__)), "helper")
+module Sorting
+  class SmoothSort
+    extend Helper
+    TEST_DATA_SIZE=100_000
+    LEONARDO_NUMBERS = [
+      1, 1, 3, 5, 9, 15, 25, 41, 67, 109, 177, 287, 465, 753, 
+      1219, 1973, 3193, 5167, 8361, 13529, 21891, 35421, 57313, 92735,
+      150049, 242785, 392835, 635621, 1028457, 1664079, 2692537, 
+      4356617, 7049155, 11405773, 18454929, 29860703, 48315633, 78176337,
+      126491971, 204668309, 331160281, 535828591, 866988873, 1402817465,
+      2269806339, 3672623805
+    ]
+    LEONARDO_MAPPING = Hash[LEONARDO_NUMBERS.each_with_index.to_a]
+    LAST_ZERO = 2**32 - 2
+
+    class HeapHelper
+      attr_accessor :bit_trees
+      attr_accessor :smallest_heap_size
+      def initialize
+        @bit_trees = 0
+        @smallest_heap_size = 0
+      end
+    end
+
+    class << self
+
+      # Smooth sort
+      # Comparison sort
+      # Selection
+      # Unstable
+      # Time complexity: Ω(n), Ө(nlogn), O(nlogn)
+      # Space complexity: O(n) total, O(1) auxiliary
+      # Complicated, slow than heap sort in average and worse case
+      def sort!(data)
+        max_i = data.size - 1
+        helper = HeapHelper.new
+        build_leonardo_heap data, max_i, helper
+        max_i.downto(1) do |i|
+          leonardo_heap_remove(data, i, helper)
+        end
+        nil
+      end
+
+      protected
+      def build_leonardo_heap(data, last_i, helper)
+        (0..last_i).each do |i|
+          if helper.bit_trees == 0 #init
+            helper.smallest_heap_size = 1
+            helper.bit_trees = 1
+          elsif helper.bit_trees & 0b11 == 0b11 #The last two trees have adjacent order
+            helper.bit_trees >>= 2
+            helper.smallest_heap_size += 2
+            helper.bit_trees |= 1
+          elsif helper.smallest_heap_size == 1
+            helper.bit_trees <<= 1
+            helper.smallest_heap_size = 0
+            helper.bit_trees |= 1
+          else
+            helper.bit_trees <<= (helper.smallest_heap_size - 1)
+            helper.smallest_heap_size = 1
+            helper.bit_trees |= 1
+          end
+          is_last = case helper.smallest_heap_size
+                    when 0
+                      i == last_i
+                    when 1
+                      (i == last_i) || (i + 1 == last_i && helper.bit_trees & 0b10 == 0)
+                    else
+                      last_i - i < LEONARDO_NUMBERS[helper.smallest_heap_size-1] + 1
+                    end
+          if is_last
+            rectify_heaps data, i, helper.dup
+          else
+            rebalance_single_heap data, i, helper.smallest_heap_size
+          end 
+        end
+      end
+
+      def leonardo_heap_remove(data, i, helper)
+        if helper.smallest_heap_size <= 1
+          begin
+            helper.bit_trees >>= 1
+            helper.smallest_heap_size += 1
+          end while helper.bit_trees > 0 && helper.bit_trees & 1 == 0
+          return
+        end
+        heap_size = helper.smallest_heap_size
+        helper.bit_trees &= LAST_ZERO
+        helper.bit_trees <<= 2
+        helper.bit_trees |= 0b11
+        helper.smallest_heap_size -= 2
+        left_child = left_child(i, heap_size)
+        right_child = right_child(i)
+
+        all_but_last_helper = helper.dup
+        all_but_last_helper.smallest_heap_size += 1
+        all_but_last_helper.bit_trees >>= 1
+        rectify_heaps data, left_child, all_but_last_helper
+        rectify_heaps data, right_child, helper.dup
+      end
+
+      def rebalance_single_heap(data, root, size)
+        while size > 1
+          left_child = left_child root, size
+          right_child = right_child root
+          larger_child = nil
+          child_size = nil
+          if data[left_child] > data[right_child]
+            larger_child = left_child
+            child_size = size - 1
+          else
+            larger_child = right_child
+            child_size = size - 2
+          end
+          if data[root] < data[larger_child]
+            data[root], data[larger_child] = data[larger_child], data[root]
+            root = larger_child
+            size = child_size
+          else
+            break
+          end
+        end
+      end
+
+      def rectify_heaps(data, i, helper)
+        j = i
+        while true
+          last_heap_size = helper.smallest_heap_size
+          break if j == LEONARDO_NUMBERS[last_heap_size] - 1
+          to_compare = j
+          if last_heap_size > 1
+            larger_child = larger_child(data, j, last_heap_size)
+            to_compare = larger_child if data[larger_child] > to_compare
+          end
+          prior_heap =  j - LEONARDO_NUMBERS[last_heap_size]
+          break if data[to_compare] > data[prior_heap]
+          data[prior_heap], data[j] = data[j], data[prior_heap] if data[j] < data[prior_heap]
+          j = prior_heap
+          begin
+            helper.bit_trees >>= 1
+            helper.smallest_heap_size += 1
+          end while helper.bit_trees & 1 == 0
+        end
+        rebalance_single_heap data, j, last_heap_size
+      end
+
+      def left_child(root, size)
+        right_child(root) - LEONARDO_NUMBERS[size-2]
+      end
+
+      def right_child(root)
+        root - 1
+      end
+
+      def larger_child(data, root, size)
+        left_child = left_child(root, size)
+        right_child = right_child(root)
+        data[left_child] > data[right_child] ? left_child : right_child
+      end
+
+    end
+
+  end
+end
+
+if __FILE__ == $0
+  require File.join(File.dirname(File.realpath(__FILE__)), "test_helper")
+  Sorting::TestHelper.test __FILE__
+end

data/lib/sorting/test_helper.rb

@@ -0,0 +1,90 @@
+require 'benchmark'
+module Sorting
+  class TestHelper
+
+    def self.get_sample_data(size=10, shuffle=true)
+      data = (1..size).to_a
+      shuffle ? data.shuffle : data
+    end
+
+    def self.sort(clazz, data)
+      if clazz.respond_to? :sort!
+        clazz.sort! data
+      else
+        data = clazz.sort data
+      end
+      data
+    end
+
+    def self.test(filename, benchmark_data_size=nil)
+      data = get_sample_data
+      clazz = eval("Sorting::#{File.basename(filename).split("_")[0].capitalize}Sort")
+      benchmark_data_size ||= clazz::TEST_DATA_SIZE
+      return if benchmark_data_size.nil?
+      is_ext = clazz.const_defined?("IS_EXT") && clazz::IS_EXT ? "(C ext)" : ""
+      puts "#{clazz}#{is_ext} - before sort: #{data.inspect}"
+      data = sort(clazz, data)
+      puts "#{clazz}#{is_ext} - after  sort: #{data.inspect}"
+
+      sample_data = get_sample_data benchmark_data_size, false
+      benchmark_data = sample_data.dup
+      result = Benchmark.measure do
+        benchmark_data = sort(clazz, benchmark_data)
+        #10.times {sort(clazz, benchmark_data.dup)} #notice, you should dup sample data for multiple test
+      end
+      diff = diff(benchmark_data, sample_data.sort)
+      raise "sort wrong for #{sample_data.inspect}, diff: #{diff.inspect}" unless diff.empty?
+      puts "#{sample_data.size} ordered number cost"
+      puts result
+
+      sample_data = get_sample_data benchmark_data_size
+      benchmark_data = sample_data.dup
+      result = Benchmark.measure do
+        benchmark_data = sort(clazz, benchmark_data)
+        #10.times {sort(clazz, benchmark_data.dup)} #notice, you should dup sample data for multiple test
+      end
+      diff = diff(benchmark_data, sample_data.sort)
+      raise "sort wrong for #{sample_data.inspect}, diff: #{diff.inspect}" unless diff.empty?
+      puts "#{sample_data.size} ordered number cost"
+      puts result
+    end
+
+    def self.test_original_sort(benchmark_data_size=nil)
+      benchmark_data_size ||= 100_000
+      sample_data = get_sample_data benchmark_data_size, false
+      benchmark_data = sample_data.dup
+      result = Benchmark.measure do
+        benchmark_data.sort!
+      end
+      puts "Array.sort: #{sample_data.size} ordered number cost"
+      puts result
+
+      sample_data = get_sample_data benchmark_data_size
+      benchmark_data = sample_data.dup
+      result = Benchmark.measure do
+        benchmark_data.sort!
+      end
+      puts "Array.sort: #{sample_data.size} ordered number cost"
+      puts result
+    end
+
+    def self.diff(a, b)
+      diff = {}
+      a.each_with_index do |x, i|
+        y = b[i]
+        diff[i] = [x, y] if x != y
+      end
+      diff
+    end
+
+  end
+end
+if __FILE__ == $0
+  Sorting::TestHelper.test_original_sort 100_000
+  dir = File.dirname(File.realpath(__FILE__))
+  Dir.foreach(dir).grep /sort/ do |file|
+    require File.join(dir, file)
+    Sorting::TestHelper.test file
+    puts "\n"
+  end
+end