algorithms 0.6.1-java

data/lib/containers/splay_tree_map.rb

@@ -0,0 +1,269 @@
+require 'containers/stack'
+=begin rdoc
+    A SplayTreeMap is a map that is stored in ascending order of its keys, determined by applying
+    the function <=> to compare keys. No duplicate values for keys are allowed, so new values of a key
+    overwrites the old value of the key.
+    
+    A major advantage of SplayTreeMap over a Hash is the fact that keys are stored in order and can thus be
+    iterated over in order. Also, Splay Trees are self-optimizing as recently accessed nodes stay near
+    the root and are easily re-accessed later. Splay Trees are also more simply implemented than Red-Black
+    trees.
+    
+    Splay trees have amortized O(log n) performance for most methods, but are O(n) worst case. This happens
+    when keys are added in sorted order, causing the tree to have a height of the number of items added.
+    
+=end
+class Containers::RubySplayTreeMap
+  include Enumerable
+  
+  Node = Struct.new(:key, :value, :left, :right)
+  
+  # Create and initialize a new empty SplayTreeMap.
+  def initialize
+    @size = 0
+    clear
+  end
+  
+  # Insert an item with an associated key into the SplayTreeMap, and returns the item inserted
+  #
+  # Complexity: amortized O(log n)
+  #
+  #   map = Containers::SplayTreeMap.new
+  #   map.push("MA", "Massachusetts") #=> "Massachusetts"
+  #   map.get("MA") #=> "Massachusetts"
+  def push(key, value)
+    if @root.nil?
+      @root = Node.new(key, value, nil, nil)
+      @size = 1
+      return value
+    end
+    splay(key)
+    
+    cmp = (key <=> @root.key)
+    if cmp == 0
+      @root.value = value
+      return value
+    end
+    node = Node.new(key, value, nil, nil)
+    if cmp < 1
+      node.left = @root.left
+      node.right = @root
+      @root.left = nil
+    else
+      node.right = @root.right
+      node.left = @root
+      @root.right = nil
+    end
+    @root = node
+    @size += 1
+    value
+  end
+  alias_method :[]=, :push
+  
+  # Return the number of items in the SplayTreeMap.
+  #
+  #   map = Containers::SplayTreeMap.new
+  #   map.push("MA", "Massachusetts")
+  #   map.push("GA", "Georgia")
+  #   map.size #=> 2
+  def size
+    @size
+  end
+  
+  # Remove all elements from the SplayTreeMap
+  #
+  # Complexity: O(1)
+  #
+  def clear
+    @root = nil
+    @size = 0
+    @header = Node.new(nil, nil, nil, nil)
+  end
+  
+  # Return the height of the tree structure in the SplayTreeMap.
+  #
+  # Complexity: O(log n)
+  #
+  #   map = Containers::SplayTreeMap.new
+  #   map.push("MA", "Massachusetts")
+  #   map.push("GA", "Georgia")
+  #   map.height #=> 2
+  def height
+    height_recursive(@root)
+  end
+  
+  # Return true if key is found in the SplayTreeMap, false otherwise.
+  #
+  # Complexity: amortized O(log n)
+  #
+  #   map = Containers::SplayTreeMap.new
+  #   map["MA"] = "Massachusetts"
+  #   map["GA"] = "Georgia"
+  #   map.has_key?("GA") #=> true
+  #   map.has_key?("DE") #=> false
+  def has_key?(key)
+    !get(key).nil?
+  end
+  
+  # Return the item associated with the key, or nil if none found.
+  #
+  # Complexity: amortized O(log n)
+  #
+  #   map = Containers::SplayTreeMap.new
+  #   map.push("MA", "Massachusetts")
+  #   map.push("GA", "Georgia")
+  #   map.get("GA") #=> "Georgia"
+  def get(key)
+    return nil if @root.nil?
+    
+    splay(key)
+    (@root.key <=> key) == 0 ? @root.value : nil
+  end
+  alias_method :[], :get
+  
+  # Return the smallest [key, value] pair in the SplayTreeMap, or nil if the tree is empty.
+  #
+  # Complexity: amortized O(log n)
+  #
+  #   map = Containers::SplayTreeMap.new
+  #   map["MA"] = "Massachusetts"
+  #   map["GA"] = "Georgia"
+  #   map.min #=> ["GA", "Georgia"]
+  def min
+    return nil if @root.nil?
+    n = @root
+    while n.left
+      n = n.left
+    end
+    splay(n.key)
+    return [n.key, n.value]
+  end
+  
+  # Return the largest [key, value] pair in the SplayTreeMap, or nil if the tree is empty.
+  #
+  # Complexity: amortized O(log n)
+  #
+  #   map = Containers::SplayTreeMap.new
+  #   map["MA"] = "Massachusetts"
+  #   map["GA"] = "Georgia"
+  #   map.max #=> ["MA", "Massachusetts"]
+  def max
+    return nil if @root.nil?
+    n = @root
+    while n.right
+      n = n.right
+    end
+    splay(n.key)
+    return [n.key, n.value]
+  end
+  
+  # Deletes the item and key if it's found, and returns the item. Returns nil
+  # if key is not present.
+  #
+  # Complexity: amortized O(log n)
+  #
+  #   map = Containers::SplayTreeMap.new
+  #   map["MA"] = "Massachusetts"
+  #   map["GA"] = "Georgia"
+  #   map.delete("GA") #=> "Georgia"
+  #   map.delete("DE") #=> nil
+  def delete(key)
+    return nil if @root.nil?
+    deleted = nil
+    splay(key)
+    if (key <=> @root.key) == 0 # The key exists
+      deleted = @root.value
+      if @root.left.nil?
+        @root = @root.right
+      else
+        x = @root.right
+        @root = @root.left
+        splay(key)
+        @root.right = x
+      end
+    end
+    deleted
+  end
+  
+  # Iterates over the SplayTreeMap in ascending order. Uses an iterative, not recursive, approach.
+  def each
+    return nil unless @root
+    stack = Containers::Stack.new
+    cursor = @root
+    loop do
+      if cursor
+        stack.push(cursor)
+        cursor = cursor.left
+      else
+        unless stack.empty?
+          cursor = stack.pop
+          yield(cursor.key, cursor.value)
+          cursor = cursor.right
+        else
+          break
+        end
+      end
+    end
+  end
+  
+  # Moves a key to the root, updating the structure in each step.
+  def splay(key)
+    l, r = @header, @header
+    t = @root
+    @header.left, @header.right = nil, nil
+    
+    loop do
+      if (key <=> t.key) == -1
+        break unless t.left
+        if (key <=> t.left.key) == -1
+          y = t.left
+          t.left = y.right
+          y.right = t
+          t = y
+          break unless t.left
+        end
+        r.left = t
+        r = t
+        t = t.left
+      elsif (key <=> t.key) == 1
+        break unless t.right
+        if (key <=> t.right.key) == 1
+          y = t.right
+          t.right = y.left
+          y.left = t
+          t = y
+          break unless t.right
+        end
+        l.right = t
+        l = t
+        t = t.right
+      else
+        break
+	    end
+    end
+    l.right = t.left
+    r.left = t.right
+    t.left = @header.right
+    t.right = @header.left
+    @root = t
+  end
+  private :splay
+  
+  # Recursively determine height
+  def height_recursive(node)
+    return 0 if node.nil?
+    
+    left_height   = 1 + height_recursive(node.left)
+    right_height  = 1 + height_recursive(node.right)
+    
+    left_height > right_height ? left_height : right_height
+  end
+  private :height_recursive
+end
+
+begin
+  require 'CSplayTreeMap'
+  Containers::SplayTreeMap = Containers::CSplayTreeMap
+rescue LoadError # C Version could not be found, try ruby version
+  Containers::SplayTreeMap = Containers::RubySplayTreeMap
+end

data/lib/containers/stack.rb

@@ -0,0 +1,67 @@
+require 'containers/deque'
+=begin rdoc
+    A Stack is a container that keeps elements in a last-in first-out (LIFO) order. There are many
+    uses for stacks, including prefix-infix-postfix conversion and backtracking problems.
+
+    This implementation uses a doubly-linked list, guaranteeing O(1) complexity for all operations.
+
+=end
+class Containers::Stack
+  include Enumerable
+  # Create a new stack. Takes an optional array argument to initialize the stack.
+  #
+  #   s = Containers::Stack.new([1, 2, 3])
+  #   s.pop #=> 3
+  #   s.pop #=> 2
+  def initialize(ary=[])
+    @container = Containers::Deque.new(ary)
+  end
+  
+  # Returns the next item from the stack but does not remove it.
+  #
+  #   s = Containers::Stack.new([1, 2, 3])
+  #   s.next #=> 3
+  #   s.size #=> 3
+  def next
+    @container.back
+  end
+  
+  # Adds an item to the stack.
+  #
+  #   s = Containers::Stack.new([1])
+  #   s.push(2)
+  #   s.pop #=> 2
+  #   s.pop #=> 1
+  def push(obj)
+    @container.push_back(obj)
+  end
+  alias_method :<<, :push
+  
+  # Removes the next item from the stack and returns it.
+  #
+  #   s = Containers::Stack.new([1, 2, 3])
+  #   s.pop #=> 3
+  #   s.size #=> 2
+  def pop
+    @container.pop_back
+  end
+  
+  # Return the number of items in the stack.
+  #
+  #   s = Containers::Stack.new([1, 2, 3])
+  #   s.size #=> 3
+  def size
+    @container.size
+  end
+  
+  # Returns true if the stack is empty, false otherwise.
+  def empty?
+    @container.empty?
+  end
+  
+  # Iterate over the Stack in LIFO order.
+  def each(&block)
+    @container.each_backward(&block)
+  end
+
+end

data/lib/containers/suffix_array.rb

@@ -0,0 +1,68 @@
+=begin rdoc
+    A suffix array enables fast substring search of a given string. An array of all possible substrings
+    is constructed and stored, and a binary search is then done to find a desired substring among those
+    stored. While more storage (and thus memory) is needed to create the SuffixArray, the advantage is
+    that substrings can be found in O(m log n) time, where m is the length of the substring to search for
+    and n is the total number of substrings.
+
+=end
+class Containers::SuffixArray
+  # Creates a new SuffixArray with a given string. Object of any class implementing a #to_s method can
+  # be passed in, such as integers.
+  #
+  # Complexity: O(n^2 log n)
+  #
+  #   s_array = Containers::SuffixArray("abracadabra")
+  #   s_array["abra"] #=> true
+  #
+  #   number = Containers::SuffixArray(1234567)
+  #   number[1] #=> true
+  #   number[13] #=> false 
+  def initialize(string)
+    string = string.to_s
+    raise ArgumentError, "SuffixArray needs to be initialized with a non-empty string" if string.empty?
+    @original_string = string
+    @suffixes = []
+    string.length.times do |i|
+      @suffixes << string[i..-1]
+    end
+
+    # Sort the suffixes in ascending order
+    @suffixes.sort! { |x, y| x <=> y }
+  end
+  
+  # Returns true if the substring occurs in the string, false otherwise.
+  #
+  # Complexity: O(m + log n)
+  #
+  #   s_array = Containers::SuffixArray.new("abracadabra")
+  #   s_array.has_substring?("a") #=> true
+  #   s_array.has_substring?("abra") #=> true
+  #   s_array.has_substring?("abracadabra") #=> true
+  #   s_array.has_substring?("acadabra") #=> true
+  #   s_array.has_substring?("adabra") #=> true
+  #   s_array.has_substring?("bra") #=> true
+  #   s_array.has_substring?("bracadabra") #=> true
+  #   s_array.has_substring?("cadabra") #=> true
+  #   s_array.has_substring?("dabra") #=> true
+  #   s_array.has_substring?("ra") #=> true
+  #   s_array.has_substring?("racadabra") #=> true
+  #   s_array.has_substring?("nope") #=> false
+  def has_substring?(substring)
+    substring = substring.to_s
+    return false if substring.empty?
+    substring_length = substring.length-1
+    l, r = 0, @suffixes.size-1
+    while(l <= r)
+      mid = (l + r) / 2
+      suffix = @suffixes[mid][0..substring_length]
+      case substring <=> suffix
+      when 0 then return true
+      when 1 then l = mid + 1
+      when -1 then r = mid - 1
+      end
+    end
+    return false
+  end
+  alias_method :[], :has_substring?
+end

data/lib/containers/trie.rb

@@ -0,0 +1,182 @@
+=begin rdoc
+    A Trie is a data structure that stores key value pairs in a tree-like fashion. It allows
+    O(m) lookup speed, where m is the length of the key searched, and has no chance of collisions,
+    unlike hash tables. Because of its nature, search misses are quickly detected.
+    
+    Tries are often used for longest prefix algorithms, wildcard matching, and can be used to
+    implement a radix sort.
+
+    This implemention is based on a Ternary Search Tree.
+=end
+class Containers::Trie  
+  # Create a new, empty Trie.
+  #
+  #   t = Containers::Trie.new
+  #   t["hello"] = "world"
+  #   t["hello"] #=> "world"
+  def initialize
+    @root = nil
+  end
+  
+  # Adds a key, value pair to the Trie, and returns the value if successful. The to_s method is
+  # called on the parameter to turn it into a string.
+  #
+  # Complexity: O(m)
+  #
+  #   t = Containers::Trie.new
+  #   t["hello"] = "world"
+  #   t.push("hello", "world") # does the same thing
+  #   t["hello"] #=> "world"
+  #   t[1] = 1
+  #   t[1] #=> 1
+  def push(key, value)
+    key = key.to_s
+    return nil if key.empty?
+    @root = push_recursive(@root, key, 0, value)
+    value
+  end
+  alias_method :[]=, :push
+  
+  # Returns true if the key is contained in the Trie.
+  #
+  # Complexity: O(m) worst case
+  #
+  def has_key?(key)
+    key = key.to_s
+    return false if key.empty?
+    !(get_recursive(@root, key, 0).nil?)
+  end
+  
+  # Returns the value of the desired key, or nil if the key doesn't exist.
+  #
+  # Complexity: O(m) worst case
+  #
+  #   t = Containers::Trie.new
+  #   t.get("hello") = "world"
+  #   t.get("non-existant") #=> nil
+  def get(key)
+    key = key.to_s
+    return nil if key.empty?
+    node = get_recursive(@root, key, 0)
+    node ? node.last : nil
+  end
+  alias_method :[], :get
+  
+  # Returns the longest key that has a prefix in common with the parameter string. If
+  # no match is found, the blank string "" is returned.
+  #
+  # Complexity: O(m) worst case
+  #
+  #   t = Containers::Trie.new
+  #   t.push("Hello", "World")
+  #   t.push("Hello, brother", "World")
+  #   t.push("Hello, bob", "World")
+  #   t.longest_prefix("Hello, brandon") #=> "Hello"
+  #   t.longest_prefix("Hel") #=> ""
+  #   t.longest_prefix("Hello") #=> "Hello"
+  def longest_prefix(string)
+    string = string.to_s
+    return nil if string.empty?
+    len = prefix_recursive(@root, string, 0)
+    string[0...len]
+  end
+  
+  # Returns a sorted array containing strings that match the parameter string. The wildcard
+  # characters that match any character are '*' and '.' If no match is found, an empty
+  # array is returned.
+  #
+  # Complexity: O(n) worst case
+  #
+  #   t = Containers::Trie.new
+  #   t.push("Hello", "World")
+  #   t.push("Hilly", "World")
+  #   t.push("Hello, bob", "World")
+  #   t.wildcard("H*ll.") #=> ["Hello", "Hilly"]
+  #   t.wildcard("Hel") #=> []
+  def wildcard(string)
+    string = string.to_s
+    return nil if string.empty?
+    ary = [] 
+    ary << wildcard_recursive(@root, string, 0, "")
+    ary.flatten.compact.sort
+  end
+
+  class Node # :nodoc: all
+    attr_accessor :left, :mid, :right, :char, :value, :end
+    
+    def initialize(char, value)
+      @char = char
+      @value = value
+      @left = @mid = @right = nil
+      @end = false
+    end
+    
+    def last?
+      @end == true
+    end
+  end
+  
+  def wildcard_recursive(node, string, index, prefix)
+    return nil if node.nil? || index == string.length
+    arr = []
+    char = string[index]
+    if (char.chr == "*" || char.chr == "." || char < node.char)
+      arr << wildcard_recursive(node.left, string, index, prefix)
+    end
+    if (char.chr == "*" || char.chr == "." || char > node.char)
+      arr << wildcard_recursive(node.right, string, index, prefix)
+    end
+    if (char.chr == "*" || char.chr == "." || char == node.char)
+      arr << "#{prefix}#{node.char.chr}" if node.last?
+      arr << wildcard_recursive(node.mid, string, index+1, prefix + node.char.chr)
+    end
+    arr
+  end
+  
+  def prefix_recursive(node, string, index)
+    return 0 if node.nil? || index == string.length
+    len = 0
+    rec_len = 0
+    char = string[index]
+    if (char < node.char)
+      rec_len = prefix_recursive(node.left, string, index)
+    elsif (char > node.char)
+      rec_len = prefix_recursive(node.right, string, index)
+    else
+      len = index+1 if node.last?
+      rec_len = prefix_recursive(node.mid, string, index+1)
+    end
+    len > rec_len ? len : rec_len
+  end
+  
+  def push_recursive(node, string, index, value)
+    char = string[index]
+    node = Node.new(char, value) if node.nil?
+    if (char < node.char)
+      node.left = push_recursive(node.left, string, index, value)
+    elsif (char > node.char)
+      node.right = push_recursive(node.right, string, index, value)
+    elsif (index < string.length-1) # We're not at the end of the input string; add next char
+      node.mid = push_recursive(node.mid, string, index+1, value)
+    else
+      node.end = true
+      node.value = value
+    end
+    node
+  end
+  
+  # Returns [char, value] if found
+  def get_recursive(node, string, index)
+    return nil if node.nil?
+    char = string[index]
+    if (char < node.char)
+      return get_recursive(node.left, string, index)
+    elsif (char > node.char)
+      return get_recursive(node.right, string, index)
+    elsif (index < string.length-1) # We're not at the end of the input string; add next char
+      return get_recursive(node.mid, string, index+1)
+    else
+      return node.last? ? [node.char, node.value] : nil
+    end
+  end
+end