ralgorithms 0.2.1 → 0.3.0

data/lib/searching/skip_list.rb

@@ -0,0 +1,135 @@
+module Searching
+  class SkipList
+
+    class Node
+      attr_accessor :key
+      attr_accessor :value
+      attr_reader :forward
+      def initialize(max_level, key, value)
+        self.key = key
+        self.value = value
+        @forward = Array.new max_level
+        @forward.map!{|e| NIL_NODE}
+      end
+    end
+
+    class NilKey
+      def <(*args)
+        false
+      end
+    end
+
+    DEFAULT_MAX_LEVEL = 32
+    DEFAULT_PROBABILITY = 0.5
+    NIL_NODE = Node.new 0, NilKey.new, nil
+    attr_reader :size
+    attr_reader :current_level
+
+    def initialize(max_level=DEFAULT_MAX_LEVEL, probability=DEFAULT_PROBABILITY)
+      @max_level = max_level - 1
+      @probability = probability
+      @current_level = 0
+      @header = Node.new @max_level, nil, nil
+      @size = 0
+    end
+
+    def <<(value)
+      self[value] = value
+    end
+
+    def [](key)
+      element = find key
+      element.key == key ? element.value : nil
+    end
+
+    def []=(key, value)
+      update = []
+      element = find key, update
+      if element.key == key
+        element.value = value 
+      else
+        target_level = random_level
+        if target_level > @current_level
+          ((@current_level+1)..target_level).each do |level|
+            update[level] = @header
+          end
+          @current_level = target_level
+        end
+        target_element = Node.new @max_level, key, value
+        (0..target_level).each do |level|
+          target_element.forward[level] = update[level].forward[level]
+          update[level].forward[level] = target_element
+        end
+        @size += 1
+      end
+    end
+
+    def delete(key)
+      update = []
+      element = find key, update
+      if element.key == key
+        (1..@current_level).each do |level|
+          update[level].forward[level] = element.forward[level] if update[level].forward[level] == element
+          @current_level -= 1 if @header.forward[level] == NIL_NODE
+        end
+        @size -= 1
+      end
+    end
+
+    def to_s
+      str = ""
+      @current_level.downto(0).each do |level|
+        str << "(#{level}): #{to_a(level).inspect}"
+      end
+      str
+    end
+
+    def to_a(level=0)
+      element = @header
+      result = []
+      while (forward = element.forward[level]) != NIL_NODE
+        element = forward
+        result << [element.key, element.value]
+      end
+      result
+    end
+
+    protected
+    def random_level
+      [(Math.log(1-rand)/Math.log(@probability)).to_i, @max_level].min
+    end
+
+    def find(key, update=nil)
+      element = @header
+      @current_level.downto(0).each do |level|
+        while (forward = element.forward[level]).key < key
+          element = forward
+        end
+        update[level] = element if update
+      end
+      element.forward[0]
+    end
+
+  end
+end
+if __FILE__ == $0
+  COUNT = 100_000
+  SEARCH_COUNT = 10000
+  s = Searching::SkipList.new
+  now = Time.now
+  COUNT.times{rand}
+  rand_cost = Time.now - now
+  now = Time.now
+  COUNT.times{s << rand}
+  insert_cost = Time.now - now - rand_cost
+  puts "SkipList: time cost for inserting #{COUNT} items: #{insert_cost.to_f*1000}ms"
+  samples = s.to_a.sample SEARCH_COUNT
+  now = Time.now
+  samples.each {|x| s[x[0]]}
+  search_cost = Time.now - now
+  puts "SkipList: time cost for searching #{SEARCH_COUNT} items from #{COUNT} items: #{search_cost.to_f*1000}ms"
+  now = Time.now
+  samples.each {|x| s.delete x[0]}
+  delete_cost = Time.now - now
+  puts "SkipList: time cost for deleting #{SEARCH_COUNT} items from #{COUNT} items: #{delete_cost.to_f*1000}ms"
+end

data/lib/sorting/bubble_sort.rb

@@ -0,0 +1,36 @@
+require File.join(File.dirname(File.realpath(__FILE__)), "helper")
+module Sorting
+  class BubbleSort
+    extend Helper
+    TEST_DATA_SIZE=1000
+
+    # Bubble Sort
+    # Comparison sort
+    # Exchanging
+    # Stable
+    # Time complexity: Ω(n), Ө(n2), O(n2)
+    # Space complexity: O(n) total, O(1) auxiliary
+    # Tiny code size
+    def self.sort!(data)
+      max_i = data.size - 1
+      (0...max_i).each do |i|
+        swapped = false
+        (0...(max_i-i)).each do |j|
+          if data[j] > data[j+1]
+            data[j], data[j+1] = data[j+1], data[j] 
+            swapped = true
+          end
+        end
+        break if !swapped
+      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/heap_sort.rb

@@ -0,0 +1,65 @@
+require File.join(File.dirname(File.realpath(__FILE__)), "helper")
+module Sorting
+  class HeapSort
+    extend Helper
+    TEST_DATA_SIZE=100_000
+
+    class << self
+
+      # Heap sort
+      # Comparison sort
+      # Selection
+      # Unstable
+      # Time complexity: Ω(nlogn), Ө(nlogn), O(nlogn)
+      # Space complexity: O(n) total, O(1) auxiliary
+      # Strongly random access, poor locality of reference
+      def sort!(data, l=0, r=data.size-1)
+        build_max_heap data
+        r.downto(l).each do |i|
+          data[l], data[i] = data[i], data[l]
+          rebalance_max_heap data, l, l, i - 1
+        end
+        nil
+      end
+
+      protected
+
+      def build_max_heap(data, l=0, r=data.size-1)
+        get_parent(l, r).downto(l).each do |i|
+          rebalance_max_heap data, l, i, r
+        end
+      end
+
+      def rebalance_max_heap(data, start, i, last_i)
+        while (child = get_left_child(start, i)) <= last_i
+          if child < last_i #has two children
+            right_sibling = child + 1
+            child = right_sibling if data[right_sibling] > data[child]
+          end
+          if data[i] > data[child]
+            break
+          else
+            data[i], data[child] = data[child], data[i]
+            i = child
+          end
+        end
+      end
+
+      def get_parent(start, i)
+        i == start ? start : (i - start) / 2
+      end
+
+      def get_left_child(start, i)
+        (i-start)*2 + 1
+      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/helper.rb

@@ -0,0 +1,11 @@
+module Sorting
+  module Helper
+
+    def sort(data)
+      data = data.dup
+      self.sort! data
+      data
+    end
+
+  end
+end

data/lib/sorting/insertion_sort.rb

@@ -0,0 +1,73 @@
+require File.join(File.dirname(File.realpath(__FILE__)), "helper")
+module Sorting
+  class InsertionSort
+    extend Helper
+    TEST_DATA_SIZE=1000
+    BINARY_SEARCH_THRESHOLD=80
+    BINARY_SEARCH_TEST_DISTANCE=[5, BINARY_SEARCH_THRESHOLD].min
+
+    # Insertion sort
+    # Comparison sort
+    # Insertion
+    # Stable
+    # Time complexity: Ω(n), Ө(n2), O(n2)
+    # Space complexity: O(n) total, O(1) auxiliary
+    # Simple, Adaptive, Online
+    # More efficient in practice than bubble sort or selection sort
+    # Write O(n2) times
+    def self.sort!(data, l=0, r=data.size-1, start=l+1)
+      (start..r).each do |i|
+        value = data[i]
+        j = i
+        while j > l && value < (previous = data[j-1])
+          data[j] = previous
+          j -= 1
+        end
+        data[j] = value
+      end
+      nil
+    end
+
+    def self.binary_sort!(data, l=0, r=data.size-1, start=l+1)
+      (start..r).each do |i|
+        value = data[i]
+        if (distance = i - l) > BINARY_SEARCH_THRESHOLD  && value < data[i-BINARY_SEARCH_TEST_DISTANCE]
+          low = l
+          high = i-1
+          found = nil
+          while low <= high
+            mid = low +  (high-low)/2
+            if data[mid] < value
+              low = mid + 1
+            else
+              found = mid
+              high = mid - 1
+            end
+          end
+          if found
+            length = i-found
+            data[found+1, length] = data[found,length]
+            data[found] = value
+          end
+        else
+          j = i
+          while j > l && value < (previous = data[j-1])
+            data[j] = previous
+            j -= 1
+          end
+          data[j] = value
+        end
+      end
+      nil
+    end
+
+
+  end
+end
+
+require File.join(File.dirname(File.realpath(__FILE__)), "load_ext.rb")
+
+if __FILE__ == $0
+  require File.join(File.dirname(File.realpath(__FILE__)), "test_helper")
+  Sorting::TestHelper.test __FILE__
+end

data/lib/sorting/intro_sort.rb

@@ -0,0 +1,72 @@
+require File.join(File.dirname(File.realpath(__FILE__)), "heap_sort")
+require File.join(File.dirname(File.realpath(__FILE__)), "insertion_sort")
+require File.join(File.dirname(File.realpath(__FILE__)), "helper")
+module Sorting
+  class IntroSort
+    extend Helper
+    TEST_DATA_SIZE=100_000
+    SIZE_FOR_INSERTION=12
+
+    # Introsort or introspective sort 
+    # Comparison sort
+    # Partitioning & Selection
+    # Unstable
+    # Time complexity: O(nlogn), Ө(nlogn), O(nlogn)
+    # Space complexity: O(logn)
+    # Support parallelization
+    # Better to median-of-3 killer
+    def self.sort!(data)
+      introsort(data)
+      nil
+    end
+
+    protected
+
+    def self.introsort(data, l=0, r=data.size-1, depth_limit=2*Math.log((r-l), 2).to_i)
+      while (distance = (r - l)) > 0
+        if distance < SIZE_FOR_INSERTION
+          Sorting::InsertionSort.sort! data, l, r
+          return
+        elsif depth_limit == 0
+          Sorting::HeapSort.sort! data, l, r
+          return
+        else
+          depth_limit -= 1
+          q = partition(data, l, r)
+          introsort(data, q+1, r, depth_limit)
+          r = q - 1
+        end
+      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/library_sort.rb

@@ -0,0 +1,80 @@
+require File.join(File.dirname(File.realpath(__FILE__)), "helper")
+require File.join(File.dirname(File.realpath(__FILE__)), "insertion_sort")
+module Sorting
+  class LibrarySort
+    extend Helper
+    TEST_DATA_SIZE=100_000
+
+    GAP = 8
+
+    # Library sort
+    # Comparison sort
+    # Insertion
+    # Stable
+    # Time complexity: Ω(n), Ө(nlogn), O(n2)
+    # Space complexity: O(n)
+    # Very fast, Adaptive, Online
+    # Requires extra space
+    def self.sort(data)
+      sorting_data = Array.new data.size
+      steps = build_steps data
+      step_counts = {}
+      data.each do |e|
+        step = binary_search_first_bigger_value steps, e
+        step_counts[step] = (step_counts[step] || 0) + 1
+      end
+      step_locations = {}
+      last_location = 0
+      last_step_item_count = 0 
+      steps.each do |step|
+        last_location += last_step_item_count
+        step_locations[step] = last_location
+        last_step_item_count = step_counts[step]
+      end
+      data.each do |e|
+        step = binary_search_first_bigger_value steps, e
+        sorting_data[step_locations[step]] = e
+        step_locations[step] += 1
+      end
+      InsertionSort.sort! sorting_data
+      sorting_data
+    end
+
+    protected
+
+    def self.build_steps(data)
+      min, max = data.minmax
+      gap = (GAP * (max - min + 1).to_f/data.size).to_i
+      steps = []
+      step = min - 1
+      while step < max
+        step += gap
+        steps << step
+      end
+      steps
+    end
+
+    def self.binary_search_first_bigger_value(data, item)
+      low = 0
+      high = data.size - 1
+      found = nil
+      while low <= high
+        mid = low +  (high-low)/2
+        value = data[mid]
+        if value < item
+          low = mid + 1
+        else
+          found = value
+          high = mid - 1
+        end
+      end
+      found
+    end
+
+  end
+end
+
+if __FILE__ == $0
+  require File.join(File.dirname(File.realpath(__FILE__)), "test_helper")
+  Sorting::TestHelper.test __FILE__
+end