grosser-algorithms 0.4.0

data/lib/containers/splay_tree_map.rb

@@ -0,0 +1,273 @@
+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
+module Algorithms
+  module Containers
+    class 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 = Algorithms::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 = Algorithms::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 = Algorithms::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 = Algorithms::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 = Algorithms::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 = Algorithms::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 = Algorithms::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 = Algorithms::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 = 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
+  end
+
+  begin
+    require 'CSplayTreeMap'
+    Containers::SplayTreeMap = Containers::CSplayTreeMap
+  rescue LoadError # C Version could not be found, try ruby version
+    Containers::SplayTreeMap = Containers::RubySplayTreeMap
+  end
+end

data/lib/containers/stack.rb

@@ -0,0 +1,71 @@
+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
+module Algorithms
+  module Containers
+    class Stack
+      include Enumerable
+      # Create a new stack. Takes an optional array argument to initialize the stack.
+      #
+      #   s = Algorithms::Containers::Stack.new([1, 2, 3])
+      #   s.pop #=> 3
+      #   s.pop #=> 2
+      def initialize(ary=[])
+        @container = Deque.new(ary)
+      end
+  
+      # Returns the next item from the stack but does not remove it.
+      #
+      #   s = Algorithms::Containers::Stack.new([1, 2, 3])
+      #   s.next #=> 3
+      #   s.size #=> 3
+      def next
+        @container.back
+      end
+  
+      # Adds an item to the stack.
+      #
+      #   s = Algorithms::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 = Algorithms::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 = Algorithms::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
+  end
+end

data/lib/containers/suffix_array.rb

@@ -0,0 +1,72 @@
+=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
+module Algorithms
+  module Containers
+    class 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 = Algorithms::Containers::SuffixArray.new("abracadabra")
+      #   s_array["abra"] #=> true
+      #
+      #   number = Algorithms::Containers::SuffixArray.new(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 = Algorithms::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
+  end
+end

data/lib/containers/trie.rb

@@ -0,0 +1,188 @@
+=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
+module Algorithms
+  module Containers
+    class Trie  
+      # Create a new, empty Trie.
+      #
+      #   t = 
+      # 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 = Algorithms::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
+      alias_method :include?, :has_key?
+  
+      # Returns the value of the desired key, or nil if the key doesn't exist.
+      #
+      # Complexity: O(m) worst case
+      #
+      #   t = Algorithms::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 = Algorithms::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 = Algorithms::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
+  end
+end