stakach-algorithms 1.0.6 → 1.0.7

data/lib/algorithms.rb

@@ -1,69 +1,69 @@
-=begin rdoc
-  The 'Algorithms and Containers' library is an effort to provide a set of commonly used
-  algorithms and containers to Ruby programmers.
-
-  This is a Google Summer of Code 2008 project
-
-  Written by Kanwei Li, mentored by Austin Ziegler
-
-  To avoid typing Algorithms::Containers::xxx to initialize containers, include the Algorithms namespace and Containers module.
-
-    require 'algorithms'
-    include Algorithms
-    include Containers
-
-    tree = RBTreeMap.new
-
-  instead of:
-
-    require 'algorithms'
-
-    tree = Algorithms::Containers::RBTreeMap.new
-
-  Done so far:
-  * Heaps           - Algorithms::Containers::Heap, Algorithms::Containers::MaxHeap, Algorithms::Containers::MinHeap
-  * Priority Queue  - Algorithms::Containers::PriorityQueue
-  * Stack           - Algorithms::Containers::Stack
-  * Queue           - Algorithms::Containers::Queue
-  * Deque           - Algorithms::Containers::Deque, Algorithms::Containers::CDeque (C extension), Algorithms::Containers::RubyDeque
-  * Red-Black Trees - Algorithms::Containers::RBTreeMap, Algorithms::Containers::CRBTreeMap (C extension), Algorithms::Containers::RubyRBTreeMap
-  * Splay Trees     - Algorithms::Containers::SplayTreeMap
-  * Tries           - Algorithms::Containers::Trie
-  * Suffix Array    - Algorithms::Containers::SuffixArray
-  * kd Tree         - Algorithms::Containers::KDTree
-
-  * Search algorithms
-    - Binary Search         - Algorithms::Algorithms::Search.binary_search
-    - Knuth-Morris-Pratt    - Algorithms::Algorithms::Search.kmp_search
-  * Sort algorithms
-    - Bubble sort           - Algorithms::Algorithms::Sort.bubble_sort
-    - Comb sort             - Algorithms::Algorithms::Sort.comb_sort
-    - Selection sort        - Algorithms::Algorithms::Sort.selection_sort
-    - Heapsort              - Algorithms::Algorithms::Sort.heapsort
-    - Insertion sort        - Algorithms::Algorithms::Sort.insertion_sort
-    - Shell sort            - Algorithms::Algorithms::Sort.shell_sort
-    - Quicksort             - Algorithms::Algorithms::Sort.quicksort
-    - Mergesort             - Algorithms::Algorithms::Sort.mergesort
-  * String algorithms
-    - Levenshtein distance  - Algorithms::Algorithms::String.levenshtein_dist
-=end
-
-module Algorithms
-  module Algorithms; end
-  module Containers; end
-end
-
-require 'algorithms/search'
-require 'algorithms/sort'
-require 'algorithms/string'
-require 'containers/heap'
-require 'containers/stack'
-require 'containers/deque'
-require 'containers/queue'
-require 'containers/priority_queue'
-require 'containers/rb_tree_map'
-require 'containers/splay_tree_map'
-require 'containers/suffix_array'
-require 'containers/trie'
-require 'containers/kd_tree'
-
+=begin rdoc
+  The 'Algorithms and Containers' library is an effort to provide a set of commonly used
+  algorithms and containers to Ruby programmers.
+
+  This is a Google Summer of Code 2008 project
+
+  Written by Kanwei Li, mentored by Austin Ziegler
+
+  To avoid typing Algorithms::Containers::xxx to initialize containers, include the Algorithms namespace and Containers module.
+
+    require 'algorithms'
+    include Algorithms
+    include Containers
+
+    tree = RBTreeMap.new
+
+  instead of:
+
+    require 'algorithms'
+
+    tree = Algorithms::Containers::RBTreeMap.new
+
+  Done so far:
+  * Heaps           - Algorithms::Containers::Heap, Algorithms::Containers::MaxHeap, Algorithms::Containers::MinHeap
+  * Priority Queue  - Algorithms::Containers::PriorityQueue
+  * Stack           - Algorithms::Containers::Stack
+  * Queue           - Algorithms::Containers::Queue
+  * Deque           - Algorithms::Containers::Deque, Algorithms::Containers::CDeque (C extension), Algorithms::Containers::RubyDeque
+  * Red-Black Trees - Algorithms::Containers::RBTreeMap, Algorithms::Containers::CRBTreeMap (C extension), Algorithms::Containers::RubyRBTreeMap
+  * Splay Trees     - Algorithms::Containers::SplayTreeMap
+  * Tries           - Algorithms::Containers::Trie
+  * Suffix Array    - Algorithms::Containers::SuffixArray
+  * kd Tree         - Algorithms::Containers::KDTree
+
+  * Search algorithms
+    - Binary Search         - Algorithms::Algorithms::Search.binary_search
+    - Knuth-Morris-Pratt    - Algorithms::Algorithms::Search.kmp_search
+  * Sort algorithms
+    - Bubble sort           - Algorithms::Algorithms::Sort.bubble_sort
+    - Comb sort             - Algorithms::Algorithms::Sort.comb_sort
+    - Selection sort        - Algorithms::Algorithms::Sort.selection_sort
+    - Heapsort              - Algorithms::Algorithms::Sort.heapsort
+    - Insertion sort        - Algorithms::Algorithms::Sort.insertion_sort
+    - Shell sort            - Algorithms::Algorithms::Sort.shell_sort
+    - Quicksort             - Algorithms::Algorithms::Sort.quicksort
+    - Mergesort             - Algorithms::Algorithms::Sort.mergesort
+  * String algorithms
+    - Levenshtein distance  - Algorithms::Algorithms::String.levenshtein_dist
+=end
+
+module Algorithms
+  module Algorithms; end
+  module Containers; end
+end
+
+require 'algorithms/search'
+require 'algorithms/sort'
+require 'algorithms/string'
+require 'containers/heap'
+require 'containers/stack'
+require 'containers/deque'
+require 'containers/queue'
+require 'containers/priority_queue'
+require 'containers/rb_tree_map'
+require 'containers/splay_tree_map'
+require 'containers/suffix_array'
+require 'containers/trie'
+require 'containers/kd_tree'
+

data/lib/algorithms/search.rb

@@ -1,86 +1,86 @@
-=begin rdoc
-    This module implements search algorithms. Documentation is provided for each algorithm.
-    
-=end
-module Algorithms
-  module Algorithms::Search
-    # Binary Search: This search finds an item in log(n) time provided that the container is already sorted.
-    # The method returns the item if it is found, or nil if it is not. If there are duplicates, the first one
-    # found is returned, and this is not guaranteed to be the smallest or largest item.
-    #
-    # Complexity: O(lg N)
-    # 
-    #   Algorithms::Search.binary_search([1, 2, 3], 1) #=> 1
-    #   Algorithms::Search.binary_search([1, 2, 3], 4) #=> nil
-    def self.binary_search(container, item)
-      return nil if item.nil?
-      low = 0
-      high = container.size - 1
-      while low <= high
-        mid = (low + high) / 2
-        val = container[mid]
-        if val > item
-          high = mid - 1
-        elsif val < item
-          low = mid + 1
-        else
-          return val
-        end
-      end
-      nil
-    end
-  
-    # Knuth-Morris-Pratt Algorithm substring search algorithm: Efficiently finds the starting position of a 
-    # substring in a string. The algorithm calculates the best position to resume searching from if a failure
-    # occurs.
-    # 
-    # The method returns the index of the starting position in the string where the substring is found. If there
-    # is no match, nil is returned.
-    #
-    # Complexity: O(n + k), where n is the length of the string and k is the length of the substring.
-    #
-    #   Algorithms::Search.kmp_search("ABC ABCDAB ABCDABCDABDE", "ABCDABD") #=> 15
-    #   Algorithms::Search.kmp_search("ABC ABCDAB ABCDABCDABDE", "ABCDEF") #=> nil
-    def self.kmp_search(string, substring)
-      return nil if string.nil? or substring.nil?
-    
-      # create failure function table
-      pos = 2
-      cnd = 0
-      failure_table = [-1, 0]
-      while pos < substring.length
-        if substring[pos - 1] == substring[cnd]
-          failure_table[pos] = cnd + 1
-          pos += 1
-          cnd += 1
-        elsif cnd > 0
-          cnd = failure_table[cnd]
-        else
-          failure_table[pos] = 0
-          pos += 1
-        end
-      end
-
-      m = i = 0
-      while m + i < string.length
-        if substring[i] == string[m + i]
-          i += 1
-          return m if i == substring.length
-        else
-          m = m + i - failure_table[i]
-          i = failure_table[i] if i > 0
-        end
-      end
-      return nil
-    end
-  
-    # Allows kmp_search to be called as an instance method in classes that include the Search module.
-    #
-    #   class String; include Algorithms::Search; end
-    #   "ABC ABCDAB ABCDABCDABDE".kmp_search("ABCDABD") #=> 15
-    def kmp_search(substring)
-      Algorithms::Search.kmp_search(self, substring)
-    end
-  
-  end
+=begin rdoc
+    This module implements search algorithms. Documentation is provided for each algorithm.
+    
+=end
+module Algorithms
+  module Algorithms::Search
+    # Binary Search: This search finds an item in log(n) time provided that the container is already sorted.
+    # The method returns the item if it is found, or nil if it is not. If there are duplicates, the first one
+    # found is returned, and this is not guaranteed to be the smallest or largest item.
+    #
+    # Complexity: O(lg N)
+    # 
+    #   Algorithms::Search.binary_search([1, 2, 3], 1) #=> 1
+    #   Algorithms::Search.binary_search([1, 2, 3], 4) #=> nil
+    def self.binary_search(container, item)
+      return nil if item.nil?
+      low = 0
+      high = container.size - 1
+      while low <= high
+        mid = (low + high) / 2
+        val = container[mid]
+        if val > item
+          high = mid - 1
+        elsif val < item
+          low = mid + 1
+        else
+          return val
+        end
+      end
+      nil
+    end
+  
+    # Knuth-Morris-Pratt Algorithm substring search algorithm: Efficiently finds the starting position of a 
+    # substring in a string. The algorithm calculates the best position to resume searching from if a failure
+    # occurs.
+    # 
+    # The method returns the index of the starting position in the string where the substring is found. If there
+    # is no match, nil is returned.
+    #
+    # Complexity: O(n + k), where n is the length of the string and k is the length of the substring.
+    #
+    #   Algorithms::Search.kmp_search("ABC ABCDAB ABCDABCDABDE", "ABCDABD") #=> 15
+    #   Algorithms::Search.kmp_search("ABC ABCDAB ABCDABCDABDE", "ABCDEF") #=> nil
+    def self.kmp_search(string, substring)
+      return nil if string.nil? or substring.nil?
+    
+      # create failure function table
+      pos = 2
+      cnd = 0
+      failure_table = [-1, 0]
+      while pos < substring.length
+        if substring[pos - 1] == substring[cnd]
+          failure_table[pos] = cnd + 1
+          pos += 1
+          cnd += 1
+        elsif cnd > 0
+          cnd = failure_table[cnd]
+        else
+          failure_table[pos] = 0
+          pos += 1
+        end
+      end
+
+      m = i = 0
+      while m + i < string.length
+        if substring[i] == string[m + i]
+          i += 1
+          return m if i == substring.length
+        else
+          m = m + i - failure_table[i]
+          i = failure_table[i] if i > 0
+        end
+      end
+      return nil
+    end
+  
+    # Allows kmp_search to be called as an instance method in classes that include the Search module.
+    #
+    #   class String; include Algorithms::Search; end
+    #   "ABC ABCDAB ABCDABCDABDE".kmp_search("ABCDABD") #=> 15
+    def kmp_search(substring)
+      Algorithms::Search.kmp_search(self, substring)
+    end
+  
+  end
 end

data/lib/algorithms/sort.rb

@@ -1,243 +1,243 @@
-require 'containers/heap' # for heapsort
-
-=begin rdoc
-    This module implements sorting algorithms. Documentation is provided for each algorithm.
-    
-=end
-module Algorithms
-  module Algorithms
-    module Sort
-  
-      # Bubble sort: A very naive sort that keeps swapping elements until the container is sorted.
-      # Requirements: Needs to be able to compare elements with <=>, and the [] []= methods should
-      # be implemented for the container.
-      # Time Complexity: О(n^2)
-      # Space Complexity: О(n) total, O(1) auxiliary
-      # Stable: Yes
-      # 
-      #   Algorithms::Sort.bubble_sort [5, 4, 3, 1, 2] => [1, 2, 3, 4, 5]
-      def self.bubble_sort(container)
-        loop do
-          swapped = false
-          (container.size-1).times do |i|
-            if (container[i] <=> container[i+1]) == 1
-              container[i], container[i+1] = container[i+1], container[i] # Swap
-              swapped = true
-            end
-          end
-          break unless swapped
-        end
-        container
-      end
-  
-      # Comb sort: A variation on bubble sort that dramatically improves performance.
-      # Source: http://yagni.com/combsort/
-      # Requirements: Needs to be able to compare elements with <=>, and the [] []= methods should
-      # be implemented for the container.
-      # Time Complexity: О(n^2)
-      # Space Complexity: О(n) total, O(1) auxiliary
-      # Stable: Yes
-      # 
-      #   Algorithms::Sort.comb_sort [5, 4, 3, 1, 2] => [1, 2, 3, 4, 5]
-      def self.comb_sort(container)
-        container
-        gap = container.size
-        loop do
-          gap = gap * 10/13
-          gap = 11 if gap == 9 || gap == 10
-          gap = 1 if gap < 1
-          swapped = false
-          (container.size - gap).times do |i|
-            if (container[i] <=> container[i + gap]) == 1
-              container[i], container[i+gap] = container[i+gap], container[i] # Swap
-              swapped = true
-            end
-          end
-          break if !swapped && gap == 1
-        end
-        container
-      end
-  
-      # Selection sort: A naive sort that goes through the container and selects the smallest element,
-      # putting it at the beginning. Repeat until the end is reached.
-      # Requirements: Needs to be able to compare elements with <=>, and the [] []= methods should
-      # be implemented for the container.
-      # Time Complexity: О(n^2)
-      # Space Complexity: О(n) total, O(1) auxiliary
-      # Stable: Yes
-      # 
-      #   Algorithms::Sort.selection_sort [5, 4, 3, 1, 2] => [1, 2, 3, 4, 5]
-      def self.selection_sort(container)
-        0.upto(container.size-1) do |i|
-          min = i
-          (i+1).upto(container.size-1) do |j|
-            min = j if (container[j] <=> container[min]) == -1
-          end
-          container[i], container[min] = container[min], container[i] # Swap
-        end
-        container
-      end
-  
-      # Heap sort: Uses a heap (implemented by the Containers module) to sort the collection.
-      # Requirements: Needs to be able to compare elements with <=>
-      # Time Complexity: О(n^2)
-      # Space Complexity: О(n) total, O(1) auxiliary
-      # Stable: Yes
-      # 
-      #   Algorithms::Sort.heapsort [5, 4, 3, 1, 2] => [1, 2, 3, 4, 5]
-      def self.heapsort(container)
-        heap = ::Algorithms::Containers::Heap.new(container)
-        ary = []
-        ary << heap.pop until heap.empty?
-        ary
-      end
-  
-      # Insertion sort: Elements are inserted sequentially into the right position.
-      # Requirements: Needs to be able to compare elements with <=>, and the [] []= methods should
-      # be implemented for the container.
-      # Time Complexity: О(n^2)
-      # Space Complexity: О(n) total, O(1) auxiliary
-      # Stable: Yes
-      # 
-      #   Algorithms::Sort.insertion_sort [5, 4, 3, 1, 2] => [1, 2, 3, 4, 5]
-      def self.insertion_sort(container)
-        return container if container.size < 2
-        (1..container.size-1).each do |i|
-          value = container[i]
-          j = i-1
-          while j >= 0 and container[j] > value do
-            container[j+1] = container[j]
-            j = j-1
-          end
-          container[j+1] = value
-        end
-        container
-      end
-  
-      # Shell sort: Similar approach as insertion sort but slightly better.
-      # Requirements: Needs to be able to compare elements with <=>, and the [] []= methods should
-      # be implemented for the container.
-      # Time Complexity: О(n^2)
-      # Space Complexity: О(n) total, O(1) auxiliary
-      # Stable: Yes
-      # 
-      #   Algorithms::Sort.shell_sort [5, 4, 3, 1, 2] => [1, 2, 3, 4, 5]
-      def self.shell_sort(container)
-        increment = container.size/2
-        while increment > 0 do
-          (increment..container.size-1).each do |i|
-            temp = container[i]
-            j = i
-            while j >= increment && container[j - increment] > temp do
-              container[j] = container[j-increment]
-              j -= increment
-            end
-            container[j] = temp
-          end
-          increment = (increment == 2 ? 1 : (increment / 2.2).round)
-        end
-        container
-      end
-  
-      # Quicksort: A divide-and-conquer sort that recursively partitions a container until it is sorted.
-      # Requirements: Container should implement #pop and include the Enumerable module.
-      # Time Complexity: О(n log n) average, O(n^2) worst-case
-      # Space Complexity: О(n) auxiliary
-      # Stable: No
-      # 
-      #   Algorithms::Sort.quicksort [5, 4, 3, 1, 2] => [1, 2, 3, 4, 5]
-      # def self.quicksort(container)
-      #   return [] if container.empty?
-      #   
-      #   x, *xs = container
-      # 
-      #   quicksort(xs.select { |i| i <  x }) + [x] + quicksort(xs.select { |i| i >= x })
-      # end
-  
-      def self.partition(data, left, right)
-        pivot = data[front]
-        left += 1
-
-        while left <= right do
-          if data[frontUnknown] < pivot
-            back += 1
-            data[frontUnknown], data[back] = data[back], data[frontUnknown] # Swap
-          end
-
-          frontUnknown += 1
-        end
-
-        data[front], data[back] = data[back], data[front] # Swap
-        back
-      end
-
-
-      # def self.quicksort(container, left = 0, right = container.size - 1)
-      #   if left < right 
-      #     middle = partition(container, left, right)
-      #     quicksort(container, left, middle - 1)
-      #     quicksort(container, middle + 1, right)
-      #   end
-      # end
-  
-      def self.quicksort(container)
-        bottom, top = [], []
-        top[0] = 0
-        bottom[0] = container.size
-        i = 0
-        while i >= 0 do
-          l = top[i]
-          r = bottom[i] - 1;
-          if l < r
-            pivot = container[l]
-            while l < r do
-              r -= 1 while (container[r] >= pivot  && l < r)
-              if (l < r)
-                container[l] = container[r]
-                l += 1
-              end
-              l += 1 while (container[l] <= pivot  && l < r)
-              if (l < r)
-                container[r] = container[l]
-                r -= 1
-              end
-            end
-            container[l] = pivot
-            top[i+1] = l + 1
-            bottom[i+1] = bottom[i]
-            bottom[i] = l
-            i += 1
-          else
-            i -= 1
-          end
-        end
-        container    
-      end
-
-      # Mergesort: A stable divide-and-conquer sort that sorts small chunks of the container and then merges them together.
-      # Returns an array of the sorted elements.
-      # Requirements: Container should implement []
-      # Time Complexity: О(n log n) average and worst-case
-      # Space Complexity: О(n) auxiliary
-      # Stable: Yes
-      # 
-      #   Algorithms::Sort.mergesort [5, 4, 3, 1, 2] => [1, 2, 3, 4, 5]
-      def self.mergesort(container)
-        return container if container.size <= 1
-        mid   = container.size / 2
-        left  = container[0...mid]
-        right = container[mid...container.size]
-        merge(mergesort(left), mergesort(right))
-      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
+require 'containers/heap' # for heapsort
+
+=begin rdoc
+    This module implements sorting algorithms. Documentation is provided for each algorithm.
+    
+=end
+module Algorithms
+  module Algorithms
+    module Sort
+  
+      # Bubble sort: A very naive sort that keeps swapping elements until the container is sorted.
+      # Requirements: Needs to be able to compare elements with <=>, and the [] []= methods should
+      # be implemented for the container.
+      # Time Complexity: О(n^2)
+      # Space Complexity: О(n) total, O(1) auxiliary
+      # Stable: Yes
+      # 
+      #   Algorithms::Sort.bubble_sort [5, 4, 3, 1, 2] => [1, 2, 3, 4, 5]
+      def self.bubble_sort(container)
+        loop do
+          swapped = false
+          (container.size-1).times do |i|
+            if (container[i] <=> container[i+1]) == 1
+              container[i], container[i+1] = container[i+1], container[i] # Swap
+              swapped = true
+            end
+          end
+          break unless swapped
+        end
+        container
+      end
+  
+      # Comb sort: A variation on bubble sort that dramatically improves performance.
+      # Source: http://yagni.com/combsort/
+      # Requirements: Needs to be able to compare elements with <=>, and the [] []= methods should
+      # be implemented for the container.
+      # Time Complexity: О(n^2)
+      # Space Complexity: О(n) total, O(1) auxiliary
+      # Stable: Yes
+      # 
+      #   Algorithms::Sort.comb_sort [5, 4, 3, 1, 2] => [1, 2, 3, 4, 5]
+      def self.comb_sort(container)
+        container
+        gap = container.size
+        loop do
+          gap = gap * 10/13
+          gap = 11 if gap == 9 || gap == 10
+          gap = 1 if gap < 1
+          swapped = false
+          (container.size - gap).times do |i|
+            if (container[i] <=> container[i + gap]) == 1
+              container[i], container[i+gap] = container[i+gap], container[i] # Swap
+              swapped = true
+            end
+          end
+          break if !swapped && gap == 1
+        end
+        container
+      end
+  
+      # Selection sort: A naive sort that goes through the container and selects the smallest element,
+      # putting it at the beginning. Repeat until the end is reached.
+      # Requirements: Needs to be able to compare elements with <=>, and the [] []= methods should
+      # be implemented for the container.
+      # Time Complexity: О(n^2)
+      # Space Complexity: О(n) total, O(1) auxiliary
+      # Stable: Yes
+      # 
+      #   Algorithms::Sort.selection_sort [5, 4, 3, 1, 2] => [1, 2, 3, 4, 5]
+      def self.selection_sort(container)
+        0.upto(container.size-1) do |i|
+          min = i
+          (i+1).upto(container.size-1) do |j|
+            min = j if (container[j] <=> container[min]) == -1
+          end
+          container[i], container[min] = container[min], container[i] # Swap
+        end
+        container
+      end
+  
+      # Heap sort: Uses a heap (implemented by the Containers module) to sort the collection.
+      # Requirements: Needs to be able to compare elements with <=>
+      # Time Complexity: О(n^2)
+      # Space Complexity: О(n) total, O(1) auxiliary
+      # Stable: Yes
+      # 
+      #   Algorithms::Sort.heapsort [5, 4, 3, 1, 2] => [1, 2, 3, 4, 5]
+      def self.heapsort(container)
+        heap = ::Algorithms::Containers::Heap.new(container)
+        ary = []
+        ary << heap.pop until heap.empty?
+        ary
+      end
+  
+      # Insertion sort: Elements are inserted sequentially into the right position.
+      # Requirements: Needs to be able to compare elements with <=>, and the [] []= methods should
+      # be implemented for the container.
+      # Time Complexity: О(n^2)
+      # Space Complexity: О(n) total, O(1) auxiliary
+      # Stable: Yes
+      # 
+      #   Algorithms::Sort.insertion_sort [5, 4, 3, 1, 2] => [1, 2, 3, 4, 5]
+      def self.insertion_sort(container)
+        return container if container.size < 2
+        (1..container.size-1).each do |i|
+          value = container[i]
+          j = i-1
+          while j >= 0 and container[j] > value do
+            container[j+1] = container[j]
+            j = j-1
+          end
+          container[j+1] = value
+        end
+        container
+      end
+  
+      # Shell sort: Similar approach as insertion sort but slightly better.
+      # Requirements: Needs to be able to compare elements with <=>, and the [] []= methods should
+      # be implemented for the container.
+      # Time Complexity: О(n^2)
+      # Space Complexity: О(n) total, O(1) auxiliary
+      # Stable: Yes
+      # 
+      #   Algorithms::Sort.shell_sort [5, 4, 3, 1, 2] => [1, 2, 3, 4, 5]
+      def self.shell_sort(container)
+        increment = container.size/2
+        while increment > 0 do
+          (increment..container.size-1).each do |i|
+            temp = container[i]
+            j = i
+            while j >= increment && container[j - increment] > temp do
+              container[j] = container[j-increment]
+              j -= increment
+            end
+            container[j] = temp
+          end
+          increment = (increment == 2 ? 1 : (increment / 2.2).round)
+        end
+        container
+      end
+  
+      # Quicksort: A divide-and-conquer sort that recursively partitions a container until it is sorted.
+      # Requirements: Container should implement #pop and include the Enumerable module.
+      # Time Complexity: О(n log n) average, O(n^2) worst-case
+      # Space Complexity: О(n) auxiliary
+      # Stable: No
+      # 
+      #   Algorithms::Sort.quicksort [5, 4, 3, 1, 2] => [1, 2, 3, 4, 5]
+      # def self.quicksort(container)
+      #   return [] if container.empty?
+      #   
+      #   x, *xs = container
+      # 
+      #   quicksort(xs.select { |i| i <  x }) + [x] + quicksort(xs.select { |i| i >= x })
+      # end
+  
+      def self.partition(data, left, right)
+        pivot = data[front]
+        left += 1
+
+        while left <= right do
+          if data[frontUnknown] < pivot
+            back += 1
+            data[frontUnknown], data[back] = data[back], data[frontUnknown] # Swap
+          end
+
+          frontUnknown += 1
+        end
+
+        data[front], data[back] = data[back], data[front] # Swap
+        back
+      end
+
+
+      # def self.quicksort(container, left = 0, right = container.size - 1)
+      #   if left < right 
+      #     middle = partition(container, left, right)
+      #     quicksort(container, left, middle - 1)
+      #     quicksort(container, middle + 1, right)
+      #   end
+      # end
+  
+      def self.quicksort(container)
+        bottom, top = [], []
+        top[0] = 0
+        bottom[0] = container.size
+        i = 0
+        while i >= 0 do
+          l = top[i]
+          r = bottom[i] - 1;
+          if l < r
+            pivot = container[l]
+            while l < r do
+              r -= 1 while (container[r] >= pivot  && l < r)
+              if (l < r)
+                container[l] = container[r]
+                l += 1
+              end
+              l += 1 while (container[l] <= pivot  && l < r)
+              if (l < r)
+                container[r] = container[l]
+                r -= 1
+              end
+            end
+            container[l] = pivot
+            top[i+1] = l + 1
+            bottom[i+1] = bottom[i]
+            bottom[i] = l
+            i += 1
+          else
+            i -= 1
+          end
+        end
+        container    
+      end
+
+      # Mergesort: A stable divide-and-conquer sort that sorts small chunks of the container and then merges them together.
+      # Returns an array of the sorted elements.
+      # Requirements: Container should implement []
+      # Time Complexity: О(n log n) average and worst-case
+      # Space Complexity: О(n) auxiliary
+      # Stable: Yes
+      # 
+      #   Algorithms::Sort.mergesort [5, 4, 3, 1, 2] => [1, 2, 3, 4, 5]
+      def self.mergesort(container)
+        return container if container.size <= 1
+        mid   = container.size / 2
+        left  = container[0...mid]
+        right = container[mid...container.size]
+        merge(mergesort(left), mergesort(right))
+      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
 end