algorithmable 0.13.0 → 0.14.0

data/lib/algorithmable/data_structs/linked_list/doubly.rb

@@ -3,7 +3,7 @@ module Algorithmable
     module LinkedList
       class Doubly < Base
         class Node
-          attr_accessor :item, :prev, :next
+          attr_accessor :item, :prev, :next, :front
 
           def initialize(item, prev_pointer = nil, next_pointer = nil)
             @item = item

data/lib/algorithmable/data_structs/linked_list/singly.rb

@@ -3,7 +3,7 @@ module Algorithmable
     module LinkedList
       class Singly < Base
         class Node
-          attr_accessor :item, :next
+          attr_accessor :item, :next, :front
 
           def initialize(item, next_pointer = nil)
             @item = item
@@ -93,8 +93,69 @@ module Algorithmable
           end
         end
 
+        def merge(other)
+          front = recursive_merge_imp self.front, other.front
+          list = self.class.new
+          while front
+            list.push_back front.item
+            front = front.next
+          end
+          list
+        end
+
+        def reverse!
+          @back = @front
+          @front = reverse_imp @front
+          self
+        end
+
+        def sort!
+          sort_linked_list @front
+        end
+
         private
 
+        def sort_linked_list(node)
+          return unless node || node.empty?
+          swapped = false
+          prev = nil
+
+          begin
+            swapped = false
+            current = node
+
+            until current.next == prev
+              if current.item > current.next.item
+                swap_nodes current, current.next
+                swapped = true
+              end
+              current = current.next
+            end
+
+            prev = current
+          end while swapped
+        end
+
+        def swap_nodes(node1, node2)
+          tmp = node1.item
+          node1.item = node2.item
+          node2.item = tmp
+        end
+
+        def recursive_merge_imp(node1, node2)
+          return node2 if node1.nil?
+          return node1 if node2.nil?
+          node1 = node1.dup
+          node2 = node2.dup
+          if node1.item < node2.item
+            node1.next = recursive_merge_imp(node1.next, node2)
+            node1
+          else
+            node2.next = recursive_merge_imp(node2.next, node1)
+            node2
+          end
+        end
+
         def reverse_imp(root)
           return root if root.nil? || root.next.nil?
           node = reverse_imp(root.next)

data/lib/algorithmable/data_structs/queue.rb

@@ -23,6 +23,10 @@ module Algorithmable
       def dequeue
         @imp.pop_front
       end
+
+      def to_s
+        to_a.join('->')
+      end
     end
   end
 end

data/lib/algorithmable/data_structs/stack.rb

@@ -24,6 +24,10 @@ module Algorithmable
       def pop
         @imp.pop_front
       end
+
+      def to_s
+        to_a.join '->'
+      end
     end
   end
 end

data/lib/algorithmable/data_structs/tree/binary.rb

@@ -0,0 +1,10 @@
+module Algorithmable
+  module DataStructs
+    module Tree
+      class Binary
+        include Enumerable
+        include Algorithmable::DataStructs
+      end
+    end
+  end
+end

data/lib/algorithmable/data_structs/tree/binary_search.rb

@@ -0,0 +1,206 @@
+module Algorithmable
+  module DataStructs
+    module Tree
+      class BinarySearch
+        include Enumerable
+        include Algorithmable::DataStructs
+
+        def initialize(collection = [])
+          @root = nil
+          collection.each { |item| put item }
+        end
+
+        def max_depth
+          max_height_of @root
+        end
+
+        alias_method :height, :max_depth
+
+        def min_depth
+          min_height_of @root
+        end
+
+        def size
+          size_of @root
+        end
+
+        def empty?
+          0 == size
+        end
+
+        def put(object)
+          @root = put_impl @root, object
+        end
+
+        def min
+          return if empty?
+          min_impl(@root).item
+        end
+
+        def max
+          return if empty?
+          max_impl(@root).item
+        end
+
+        def each(&block)
+          each_with_dfs(&block)
+        end
+
+        def each_with_dfs(&block)
+          tmp = collect_nodes_with_dfs(@root).to_a
+          block_given? ? tmp.each(&block) : tmp
+        end
+
+        def each_with_bfs(&block)
+          tmp = collect_nodes_with_bfs(@root).to_a
+          block_given? ? tmp.each(&block) : tmp
+        end
+
+        def to_print
+          return if empty?
+          queue = new_fifo_queue
+          level = 0
+          next_level = 1
+          out = []
+          queue.enqueue @root
+          until queue.empty?
+            level += 1
+            node = queue.dequeue
+            out << node.item << ' '
+            queue.enqueue node.left if node.left
+            queue.enqueue node.right if node.right
+
+            if level == next_level
+              next_level += queue.size
+              out << "\n"
+            end
+          end
+          out.join
+        end
+
+        def reverse!
+          @root = reverse_bang_impl @root
+        end
+
+        def flip!
+          @root = flip_bang_imp! @root, 0
+        end
+
+        def flip_bang_imp!(n, count)
+          return unless n
+          return n unless n.left && n.right
+          new_head = flip_bang_imp! n.left, count + 1
+          n.left.left = n.right
+          n.left.right = n
+          if count == 0
+            n.left = nil
+            n.right = nil
+          end
+          new_head
+        end
+
+        def balanced?(diff = 1)
+          (max_depth - min_depth) <= diff
+        end
+
+        private
+
+        def max_height_of(node)
+          return 0 unless node
+          1 + [max_height_of(node.left), max_height_of(node.right)].max
+        end
+
+        def min_height_of(node)
+          return 0 unless node
+          1 + [min_height_of(node.left), min_height_of(node.right)].min
+        end
+
+        def reverse_bang_impl(root)
+          return unless root
+          reverse_bang_impl root.left
+          reverse_bang_impl root.right
+          tmp = root.left
+          root.left = root.right
+          root.right = tmp
+          root
+        end
+
+        def collect_nodes_with_bfs(root)
+          queue = new_fifo_queue
+          stack = new_lifo_queue
+          queue.enqueue root
+          until queue.empty?
+            node = queue.dequeue
+            stack.push node.item
+            queue.enqueue node.left if node.left
+            queue.enqueue node.right if node.right
+          end
+          stack
+        end
+
+        def collect_nodes_with_dfs(node)
+          stack = []
+          dfs_impl node, stack
+          stack
+        end
+
+        # in-order traversal
+        def dfs_impl(node, stack)
+          dfs_impl node.left, stack if node.left
+          stack.push node.item
+          dfs_impl node.right, stack if node.right
+        end
+
+        def max_impl(node)
+          return node if node.right.nil?
+          max_impl(node.right)
+        end
+
+        def min_impl(node)
+          return node if node.left.nil?
+          min_impl(node.left)
+        end
+
+        def put_impl(node, object)
+          return make_node(object, 1) unless node
+          case object <=> node.item
+          when -1
+            node.left = put_impl(node.left, object)
+          when 1
+            node.right = put_impl(node.right, object)
+          else
+            node.item = object
+          end
+          node.size = 1 + size_of(node.left) + size_of(node.right)
+          node
+        end
+
+        def size_of(node)
+          return 0 if node.nil?
+          node.size
+        end
+
+        def make_node(object, size)
+          Node.new object, size
+        end
+
+        class Node
+          attr_accessor :item, :left, :right, :size
+
+          def initialize(value, size)
+            @item = value
+            @size = size
+            @left = nil
+            @right = nil
+          end
+
+          def <=>(other)
+            @item <=> other.item
+          end
+        end
+
+        private_constant :Node
+      end
+    end
+  end
+end

data/lib/algorithmable/data_structs/tree.rb

@@ -0,0 +1,13 @@
+module Algorithmable
+  module DataStructs
+    module Tree
+      autoload :Binary, 'algorithmable/data_structs/tree/binary'
+      autoload :BinarySearch, 'algorithmable/data_structs/tree/binary_search'
+      autoload :Node, 'algorithmable/data_structs/tree/node'
+
+      def new_ordered_binary_tree(collection = [])
+        BinarySearch.new(collection)
+      end
+    end
+  end
+end

data/lib/algorithmable/data_structs.rb

@@ -7,8 +7,10 @@ module Algorithmable
     autoload :Stack, 'algorithmable/data_structs/stack'
     autoload :OrderedSymbolTable, 'algorithmable/data_structs/ordered_symbol_table'
     autoload :Heap, 'algorithmable/data_structs/heap'
+    autoload :Tree, 'algorithmable/data_structs/tree'
 
     include LinkedList
+    include Tree
 
     def new_bag
       Bag.new
@@ -22,6 +24,10 @@ module Algorithmable
       Stack.new
     end
 
+    def new_deque_queue
+      Deque.new
+    end
+
     def new_ordered_symbol_table(key_type, value_type)
       OrderedSymbolTable.new(key_type, value_type)
     end

data/lib/algorithmable/sort/bubble.rb

@@ -1,16 +1,18 @@
 module Algorithmable
   module Sort
     class Bubble
+      extend Algorithmable::Sort::Utils
+      #
+      # Time О(N^2), stable and slow
+      # Space О(N)
+      #
       def self.sort(collection)
-        new.sort(collection)
-      end
-
-      def sort(collection)
+        length = collection.length - 1
         loop do
           swapped = false
-          (collection.size.pred).times do |index|
-            if (collection[index] <=> collection[index.next]) == 1
-              collection = swap(index, collection)
+          0.upto(length).each do |i|
+            if 1 == (collection[i] <=> collection[i + 1])
+              swap(collection, i)
               swapped = true
             end
           end
@@ -18,15 +20,6 @@ module Algorithmable
         end
         collection
       end
-
-      private
-
-      def swap(index, collection)
-        current = collection[index]
-        collection[index] = collection[index.next]
-        collection[index.next] = current
-        collection
-      end
     end
   end
 end

data/lib/algorithmable/sort/insertion.rb

@@ -0,0 +1,24 @@
+module Algorithmable
+  module Sort
+    class Insertion
+      extend Algorithmable::Sort::Utils
+      #
+      # Time О(N^2), stable and slow
+      # Space Complexity: О(N)
+      #
+      def self.sort(collection)
+        return collection if 2 > collection.length
+        1.upto(collection.length - 1).each do |i|
+          curr_char = collection[i]
+          j = i - 1
+          while 0 <= j && collection[j] > curr_char
+            collection[j + 1] = collection[j]
+            j -= 1
+          end
+          collection[j + 1] = curr_char
+        end
+        collection
+      end
+    end
+  end
+end

data/lib/algorithmable/sort/merge.rb

@@ -2,20 +2,16 @@ module Algorithmable
   module Sort
     class Merge
       def self.sort(collection)
-        new.sort(collection)
-      end
-
-      def sort(collection)
-        return collection if collection.size <= 1
-        mid = collection.size / 2
+        return collection if collection.length <= 1
+        mid = collection.length / 2
         left = collection[0...mid]
-        right = collection[mid...collection.size]
+        right = collection[mid...collection.length]
         merge(sort(left), sort(right))
       end
 
       private
 
-      def merge(left, right)
+      def self.merge(left, right)
         sorted = []
         until left.empty? || right.empty?
           left.first <= right.first ? sorted << left.shift : sorted << right.shift