ds 0.0.4 → 0.0.6

data/Rakefile

@@ -4,10 +4,15 @@ require 'rake/testtask'
 Rake::TestTask.new do |t|
   t.libs << 'test'
   t.test_files = FileList['test/test*.rb']
-  #t.pattern = "test/test_*.rb"
   t.verbose = true
 end
 
-desc "Run tests"
-task :default => :test
+Rake::TestTask.new do |t|
+  t.name = 'test:performance'
+  t.libs << 'test'
+  t.test_files = FileList['test/performance/*test.rb']
+  t.verbose = true
+end
 
+desc 'Run tests'
+task default: :test

data/ds.gemspec

@@ -1,20 +1,23 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "ds/version"
+$:.push File.expand_path('../lib', __FILE__)
+require 'ds/version'
 
 Gem::Specification.new do |s|
-  s.name        = "ds"
+  s.name        = 'ds'
   s.version     = DS::VERSION
-  s.authors     = ["knife"]
-  s.email       = ["satre@o2.pl"]
-  s.homepage    = ""
-  s.summary     = %q{Some common data structures.}
-  s.description = %q{Data structures (lists,stacks, trees, heaps, graphs..) in pure Ruby.}
-
-  s.rubyforge_project = "ds"
+  s.authors     = ['knife']
+  s.email       = ['satre@o2.pl']
+  s.homepage    = ''
+  s.summary     = 'Some common data structures.'
+  s.description = 'Data structures (lists, stacks, trees, heaps, graphs..) in pure Ruby.'
+  s.rubyforge_project = 'ds'
 
   s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+  s.test_files    = `git ls-files -- test/**/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'minitest'
 end

data/lib/ds.rb

@@ -1,36 +1,26 @@
-require "ds/version"
+require 'ds/version'
 
-require "ds/ext/array_x"
-require "ds/pair"
+require 'ds/pair'
 
-require "ds/matrixes/expandable_array"
-require "ds/matrixes/array_2d"
-require "ds/matrixes/tri_matrix"
+require 'ds/arrays/expandable_array'
+require 'ds/arrays/array_2d'
+require 'ds/arrays/tri_matrix'
+require 'ds/arrays/heap_store'
 
-require "ds/sets/ordered_set"
-
-require "ds/lists/list_element"
-require "ds/lists/list"
-require "ds/lists/cyclic_list"
-require "ds/lists/ring"
-
-require "ds/stacks/stack"
-require "ds/queues/queue"
-require "ds/queues/priority_queue"
-
-require "ds/trees/tree"
-require "ds/trees/tree_walker"
-require "ds/trees/binary_tree"
-require "ds/trees/binary_search_tree"
-require "ds/trees/complete_binary_tree"
-require "ds/trees/binary_heap"
-require "ds/trees/trie"
-
-require "ds/graphs/edge"
-require "ds/graphs/graph_as_matrix"
-require "ds/graphs/graph_as_tri_matrix"
-require "ds/graphs/graph"
-require "ds/graphs/digraph"
+require 'ds/sets/indexed_set'
 
+require 'ds/lists/list_element'
+require 'ds/lists/list'
 
+require 'ds/stacks/stack'
+require 'ds/queues/simple_queue'
+require 'ds/queues/priority_queue'
 
+require 'ds/trees/tree'
+require 'ds/trees/tree_walker'
+require 'ds/trees/binary_tree'
+require 'ds/trees/binary_heap'
+require 'ds/trees/red_black_tree'
+require 'ds/trees/red_black_tree/node'
+require 'ds/trees/trie'
+require 'ds/trees/trie/node'

data/lib/ds/{matrixes → arrays}/array_2d.rb

@@ -1,17 +1,13 @@
 module DS
-   
-  #Implements two dimensional array.  
+  # Implements two dimensional array.
   class Array2D
-
-
-    #Creates new two dimensional array. Init is the default value of the array.
-    def initialize(size=1,init=0)
+    # Creates new two dimensional array. Init is the default value of the array.
+    def initialize(size = 1, init = 0)
       @init = init
-      @store = Array.new(size){Array.new(size){init}}
+      @store = Array.new(size) { Array.new(size) { init } }
     end
 
-    
-    def [](x,y)
+    def [](x, y)
       if @store[x].nil?
         @store[x] = []
         @init
@@ -22,7 +18,7 @@ module DS
       end
     end
 
-    def []=(x,y,v)
+    def []=(x, y, v)
       @store[x] = [] if @store[x].nil?
       @store[x][y] = v
     end
@@ -35,5 +31,8 @@ module DS
       @store.flatten
     end
 
+    def size
+      @store.size
+    end
   end
 end

data/lib/ds/arrays/expandable_array.rb

@@ -0,0 +1,34 @@
+module DS
+  # Class provides access to any element in array. If index i
+  # is greter than array size then elements from size to i are
+  # filled with extender.
+  class ExpandableArray < Array
+    def initialize(size = 0, extender = 0)
+      @extender = extender
+      super(size, extender)
+    end
+
+    # Returns element at index. If index is greater than size of array then
+    # elements from size to index are filled with extender.
+    def [](x)
+      expand(size, x) if x >= size
+      super(x)
+    end
+
+    # Sets the element at index. If index is greater than size of array then
+    # elements from size to index are filled with extender.
+    def []=(x, v)
+      old_size = size
+      super(x, v)
+      expand(old_size, size - 2) if size - old_size > 1
+    end
+
+    private
+
+    def expand(from, to)
+      (from..to).each do |i|
+        self[i] = @extender
+      end
+    end
+  end
+end

data/lib/ds/arrays/heap_store.rb

@@ -0,0 +1,32 @@
+require 'forwardable'
+
+module DS
+  # Simple Array-like data structure with indexing starting from one.
+  class HeapStore
+    extend Forwardable
+
+    def_delegators :@store, :push, :pop, :[], :[]=
+
+    def initialize(*args)
+      @store = [nil] + args.to_a
+    end
+
+    def length
+      @store.size - 1
+    end
+
+    def first
+      @store[1]
+    end
+
+    alias size length
+
+    def empty?
+      length <= 0
+    end
+
+    def to_a
+      @store[1..-1]
+    end
+  end
+end

data/lib/ds/arrays/tri_matrix.rb

@@ -0,0 +1,33 @@
+module DS
+  # Class implements Triangular Matrix (lower).
+  class TriMatrix
+    # Creates new triangular matrix.
+    def initialize(init = 0)
+      @store = ExpandableArray.new(0, init)
+      @max = 0
+    end
+
+    # Returns element at index x,y (or y,x).
+    def [](x, y)
+      x, y = y, x if y > x
+      index = (x * x + x) / 2 + y
+      @store[index]
+    end
+
+    # Sets the element at index x,y (or y,x).
+    def []=(x, y, v)
+      x, y = y, x if y > x
+      index = (x * x + x) / 2 + y
+      @max = x if x > @max
+      @store[index] = v
+    end
+
+    def to_a
+      @store
+    end
+
+    def size
+      @max
+    end
+  end
+end

data/lib/ds/lists/list.rb

@@ -1,300 +1,424 @@
 module DS
+  class ListError < StandardError; end
 
-  #Implements simple list data structure. 
+  # Implements simple list data structure.
   class List
-
     include Enumerable
+    include Comparable
 
     attr_accessor :head, :tail
 
-    #Creates new list. 
-    def initialize(x=nil)
-      @head = ListElement.new(x)
-      @tail = @head
+    # Creates new list.
+    def initialize(*arr)
+      @size = 0
+      @head = nil
+      @tail = nil
+      from_array(arr) if arr.any?
     end
 
-    #Creates list from array.
-    def self.from_array(arr)
-      list = new(arr.shift)
-      tail = list.head
-      arr.each{ |e| tail = tail.append(e) }
-      list.tail = tail
+    # Clones list
+    def clone
+      list = self.class.new
+      each { |e| list.append(e.data) }
       list
     end
 
-    #Appends new element to list. 
+    # Clears list by reseting head and tail to nil
+    def clear
+      @size = 0
+      @head = nil
+      @tail = nil
+    end
+
+    # Appends new element to list. Returns list tail
     def append(x)
-      last_elem = self.tail
       if !empty?
-        @tail = last_elem.append(x)
+        @tail = tail.append(x)
+        increment_size
       else
-        @head = ListElement.new(x)
-        @tail = @head
+        create_first(x)
       end
+      @tail
     end
 
-    alias :<< :append
+    alias << append
+    alias push append
 
-    #Prepends new element to list.
-    def prepend(x)
+    # Prepends new element to list. Returns list head
+    def unshift(x)
       el = ListElement.new(x)
       el.next = @head
+      @head.prev = el if @head
+
+      increment_size
       @head = el
     end
 
-    #Removes element x from list.
-    def remove(x)
-      if x == head
-        self.head = head.next
-        x.next = nil
-      else
+    # Removes list head.
+    def shift
+      raise ListError, 'List already empty' if empty?
+      remove(head).data
+    end
 
-        el = head
-        while el and el != x
-          prev = el 
-          el = el.next
-        end
+    # Return ListElement if it is on list otherwise returns nil
+    def get(x)
+      el = head
+      el = el.next while el && el != x
+      el
+    end
 
-        raise ListError, "Element not found" unless el
+    # Return ListElement if it is on list or raises error
+    def get!(x)
+      found = get(x)
+      raise ListError, 'Element not found' unless found
+    end
 
-        prev.next = el.next
-        el.next = nil
+    # Returns list element on given index.
+    def at(index)
+      found = nil
+      find_index = lambda do |element, i|
+        if i == index
+          found = element
+          break
+        end
       end
-      x
+      if index >= 0
+        each_with_index(&find_index)
+      else
+        reverse_each(&find_index)
+      end
+      found
     end
 
-    #Removes list head.
-    def shift
-      remove(head).data
+    # Returns list element on given index.
+    def [](i, count = nil)
+      return [] if count && count < 0
+      i = (i...i + count) if count && count > 0
+      case i
+      when Integer
+        at(i)
+      when Range
+        elements_in_range(i)
+      end
     end
 
-    #Inserts element x after another element.
-    def insert_after(x,rel)
-      x = ListElement.new(x)
-
-      el = head
-      while el and el != rel
-        el = el.next
+    # Sets list element on given index.
+    def []=(i, count = 1, val)
+      if i.is_a? Range
+        index = i.first
+        count = i.size
+      else
+        index = i
       end
 
-      raise "Element not found" unless el
+      raise ListError, 'Ivalid count parameter' unless valid_count?(count, index)
 
-      x.next = el.next
-      el.next = x
+      el = at(index)
+      raise ListError, 'Element not found' unless el
+      if val.is_a? Array
+        replace(el, List.new(*val), count)
+      else
+        el.data = val
+      end
+    end
 
-      if x.tail?
-        self.tail = x
+    # Replaces list elements with other list
+    def replace(el, list, count = 1)
+      if el.head?
+        replace_head(el, list, count)
+      elsif el.tail?
+        replace_tail(el, list, count)
+      else
+        replace_inside(el, list, count)
       end
     end
 
-    #Inserts element x before another element.
-    def insert_before(x,rel)
-      x = ListElement.new(x)  
+    # Checks if two lists are equal
+    def <=>(other)
+      a = head
+      b = other.head
+      while a && b && a.data == b.data
+        a = a.next
+        b = b.next
+      end
+      compare_list_elements(a, b)
+    end
 
-      #inserting at the beginnig of the list 
+    # Appends one list to other
+    def concat(other)
+      other.head.prev = tail
+      tail.next = other.head
+      self.tail = other.tail
+      @size += other.size
+      self
+    end
+
+    # Inserts element x after another element.
+    def insert_after(x, rel)
+      x = ListElement.new(x)
+
+      el = rel
+      nxt = el.next
+      x.next = nxt
+      nxt.prev = x if nxt
+      el.next = x
+      x.prev = el
+      self.tail = x if x.nil?
+
+      increment_size
+
+      self
+    end
+
+    # Inserts element x before another element.
+    def insert_before(x, rel)
       if rel == head
-        x.next = head
-        self.head = x
+        unshift(x)
+      else
+        x = ListElement.new(x)
+
+        prev = rel.prev
+        prev.next = x
+        x.prev = prev
+        x.next = rel
+        rel.prev = x
+      end
+      increment_size
+      self
+    end
 
-      #inserting in the tail of the list
+    # Removes element x from list.
+    def remove(x)
+      if x == head
+        self.head = head.next
+        x.next = nil
+        head.prev = nil if head
       else
-        el = head
-        prev = head
-        while el and el != rel
-          prev = el
-          el = el.next
-        end
+        nxt = x.next
+        prev = x.prev
+        prev.next = nxt
+        nxt.prev = prev if nxt
+        x.next = nil
+        x.prev = nil
 
-        if el.nil?
-          raise ListError, "List element not found"
-        else
-          prev.next = x
-          x.next = el
-        end
+        self.tail = prev if nxt.nil?
       end
+      decrement_size
+      x
     end
 
+    # Removes last element from list.
+    def pop
+      remove(tail).data
+    end
 
-    #Checks if list is empty.
+    # Checks if list is empty.
     def empty?
-      head.data.nil?
+      @size.zero?
     end
 
-    #Returns last element of the list.
+    # Returns last element of the list.
     def last
       tail.data
     end
 
+    # Returns first element of the list.
     def first
       head.data
     end
 
-    #Returns length of the list.
+    # Returns length of the list.
     def length
-      count
+      @size
     end
 
-    #Checks if list is linked at the end with other list.
+    alias size length
+
+    # Checks if list is linked at the end with other list.
     def zip?(other)
-      tail.equal? other.tail 
+      tail.equal? other.tail
     end
 
-    #Returns joint element if exists, otherwise returns nil.
+    # Returns joint element if exists, otherwise returns nil.
     def joint
       elem = head
       elem2 = elem.next
 
-      while elem and elem2
+      while elem && elem2
 
-        #traversing by 1
+        # traversing by 1
         elem = elem.next
 
-        #traversing by 2
+        # traversing by 2
         elem2 = elem2.next
         elem2 = elem2.next if elem2
 
-        if elem2.equal? elem
-          return elem
-        end
+        return elem if elem2.equal? elem
       end
-
       nil
     end
 
-    #Returns true if list has cycle.
+    # Returns true if list has cycle.
     def looped?
-      !!joint
+      !joint.nil?
     end
 
+    # Returns cycle size or nil if list has no cycles
+    def cycle_size
+      return unless looped?
+      counter = 0
+      start = joint
+      if start
+        counter = 1
+        elem = start.next
+        while elem != start
+          elem = elem.next
+          counter += 1
+        end
+      end
+      counter
+    end
 
-    #Orderize list by evaluating block. Block should evaluate to one of these
-    #values: 1,0,-1 (same as Comparable).
-    def orderize
-
-      zero = List.new
-      plus = List.new
-      minus = List.new
+    # Reverses list.
+    def reverse!
+      @tail = head
+      prev = head
+      elem = prev.next
+      prev.next = nil
+      while elem
+        nxt = elem.next
+        elem.next = prev
+        prev.prev = elem
+        prev = elem
+        elem = nxt
+      end
 
-      el = self.head
+      @head = prev
+      self
+    end
 
-      while el
-        case yield el.data
-        when 0
-          zero_tail = zero.append(el.data)
-        when 1
-          plus_tail = plus.append(el.data)
-        when -1
-          minus_tail = minus.append(el.data)
-        end
+    # Converts list to array.
+    def to_a
+      map(&:data)
+    end
 
-        el = el.next
+    # Default list iterator.
+    def each
+      elem = head
+      while elem
+        yield elem
+        elem = elem.next
       end
-
-      minus_tail.next = zero.head
-      zero_tail.next = plus.head
-      return minus
     end
 
+    # Reverse list iterator.
+    def reverse_each
+      elem = tail
+      i = 0
+      while elem
+        i -= 1
+        yield elem, i
+        elem = elem.prev
+      end
+    end
 
-    # Removes elements that exists on the other list.
-    def remove!(other)
-      a = head
-      b = other.head
+    def to_s
+      to_a.join('=')
+    end
 
-      while a and b
+    private
 
-        while a.data < b.data
-          prev = a
-          a = a.next
-        end
+    def from_array(arr)
+      create_first(arr.shift)
+      arr.each { |e| append(e) }
+    end
 
-        while b.data < a.data
-          b = b.next
-        end
+    # Creates first element in list.
+    def create_first(x)
+      first = unshift(x)
+      self.head = first
+      self.tail = first
+      self
+    end
 
-        if prev.nil?
-          prev =  a
-          a = a.next
-          prev.next = nil
-          self.head = a 
-          b = b.next
-        else
-          a = a.next
-          prev.next = a
-          b = b.next
-        end
+    def elements_in_range(range)
+      arr = []
+      each_with_index do |e, i|
+        arr << e if range.include?(i)
       end
-      self
+      arr
     end
 
-    # Merge list with other list.
-    def merge(other)
+    def increment_size
+      @size += 1
+    end
 
-      a = self.head
-      b = other.head
+    def decrement_size
+      @size -= 1
+    end
 
-      if a.data < b.data
-        result = List.new(a.data)
-        a = a.next
+    def compare_list_elements(a, b)
+      if a.nil? && b.nil?
+        0
+      elsif a && b
+        a.data <=> b.data
+      elsif a.nil?
+        -1
       else
-        result = List.new(b.data)
-        b = b.next
+        1
       end
+    end
 
-      while a and b
-        if a.data < b.data
-          result.append(a.data)
-          a = a.next
-        else
-          result.append(b.data)
-          b = b.next
-        end
-      end
-      if !b
-        result.tail.next = a
-        result.tail = self.tail
-      elsif !a
-        result.tail.next = b
-        result.tail = other.tail
-      end
-      result
+    def valid_count?(count, index)
+      return true if count.nil?
+      !(count < 1 || count + index > size)
     end
 
-    #Reverses list.
-    def reverse!
-      @tail = self.head
-      prev = self.head
-      elem = prev.next
-      prev.next = nil
-      while elem
-        nxt = elem.next
-        elem.next = prev
-        prev = elem
-        elem = nxt
+    def replace_head(el, list, count)
+      count.times do
+        temp = el.next
+        remove(el)
+        el = temp
       end
-
-      @head = prev
-      self
+      list.concat self
+      @size = list.size
+      self.head = list.head
     end
 
-
-    #Converts list to array.
-    def to_a
-      map { |e| e.data}
+    def replace_tail(el, list, count)
+      count.times do
+        temp = el.next
+        remove(el)
+        el = temp
+      end
+      concat list
     end
 
-    #Default list iterator.
-    def each
-      elem = @head
-      while elem
-        yield elem
-        elem = elem.next
+    def replace_inside(el, list, count)
+      first = el
+      last = find_last_element(el, count)
+      if last.tail?
+        self.tail = list.tail
+      else
+        nxt = last.next
+        nxt.prev = list.tail
+        list.tail.next = nxt
+        last.next = nil
       end
+      prev = first.prev
+      list.head.prev = prev
+      prev.next = list.head
+      first.prev = nil
+      @size = @size - count + list.size
     end
 
+    def find_last_element(el, count)
+      last = el
+      (count - 1).times do
+        temp = last.next if last.next
+        last = temp
+      end
+      last
+    end
   end
-
-  class ListError < StandardError
-  end
-
 end