ds 0.0.1

data/ds.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ds/version"
+
+Gem::Specification.new do |s|
+  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.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"]
+end

data/lib/ds.rb

@@ -0,0 +1,38 @@
+require "ds/version"
+
+require "ext/ext"
+
+require "ds/matrixes/expandable_array"
+require "ds/matrixes/array_2d"
+require "ds/matrixes/tri_matrix"
+
+require "ds/graphs/edge"
+require "ds/graphs/graph_as_list"
+require "ds/graphs/graph_as_matrix"
+require "ds/graphs/graph_as_tri_matrix"
+require "ds/graphs/graph"
+require "ds/graphs/digraph"
+
+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/lists/list_element"
+require "ds/lists/list"
+require "ds/lists/cyclic_list"
+require "ds/lists/ring"
+
+require "ds/stacks/stack"
+require "ds/queues/queue"
+
+
+
+
+
+
+
+
+

data/lib/ds/graphs/digraph.rb

@@ -0,0 +1,20 @@
+module DS
+  class Digraph < Graph
+
+    def self.create(args)
+      new(args,:matrix)
+    end
+
+
+    #Returns number of incoming edges to given vertex.
+    def in_degree x
+      @g.degree x, :in
+    end
+
+    #Returns number of outcoming edges to given vertex.
+    def out_degree x
+      @g.degree x, :out
+    end
+
+  end
+end

data/lib/ds/graphs/edge.rb

@@ -0,0 +1,15 @@
+module DS
+  class Edge
+
+    attr_accessor :from, :to, :weight
+    
+    #Create new edge.
+    def initialize(from,to,weight=1)
+      @from =  from
+      @to  =  to
+      @weight = weight
+    end
+
+  end
+end
+

data/lib/ds/graphs/graph.rb

@@ -0,0 +1,107 @@
+module DS
+  class Graph
+
+    Infinity = 1 << 64
+
+    #Create new graph from array of edges. Second parameter determines
+    #graph internal implementation: :list (Adjency List), :tri_matrix (Triangular
+    #Matrix), :matrix (Matrix).
+    def initialize(edges,store = :list)
+      case store
+      when :matrix
+        @g = GraphAsMatrix.new(edges)
+      when :tri_matrix
+        @g = GraphAsTriMatrix.new(edges)
+      else
+        @g = GraphAsList.new(edges)
+      end
+    end
+
+    #Create new graph from array of edges. Internally graph will be represented
+    #by Triangular Matrix.
+    def self.create(edges)
+      new(edges,:tri_matrix) 
+    end
+
+    def add(x,y)
+      @g.add(x,y)
+    end
+
+    def remove(x,y)
+      @g.remove(x,y) 
+    end
+
+    def each_vertex &block
+      @g.each_vertex &block
+    end
+
+    def each_edge &block
+      @g.each_edge &block
+    end
+
+    def neighbors v
+      @g.neighbors v
+    end
+
+    def bfs s
+      colors = {}
+      parents =  {}
+      res = []
+      d = {}
+      q = Queue.new
+
+      @g.each_vertex do |v|
+        colors[v] = :white
+        parents[v] = nil
+        d[v] = Infinity
+      end
+
+      colors[s] = :white
+      parents[s] = nil
+      d[s] = 0
+
+      q.enqueue s
+
+      while !q.empty?
+        u = q.dequeue 
+        @g.neighbors(u).each do |v|
+          if colors[v] === :white
+            colors[v] = :grey
+            d[v] = d[u] + 1
+            parents[v] = u
+            q.enqueue v
+          end
+        end
+        colors[u] = :black
+        res << u
+      end
+      res
+    end
+
+    def add_edges(edges)
+      @g.add_edges(edges)
+    end
+    
+    #Returns vertex degree. Second parameter determines direction - :in incoming
+    #edges, :out - outcoming edges, :all - incoming and outcoming edges.
+    def degree x
+      @g.degree x
+    end
+
+    def edge? x,y
+      @g.edge? x,y
+    end
+
+    def get_edge x, y
+      @g.get_edge x,y
+    end
+
+    def vertex_size
+      @g.vertex_size
+    end
+
+    def edge_size
+      @g.vmax+1
+    end
+  end
+end

data/lib/ds/graphs/graph_as_list.rb

@@ -0,0 +1,48 @@
+module DS
+  class GraphAsList
+
+    def initialize
+      @store = {}	 # the graph // {node => { edge1 => weight, edge2 => weight}, node2 => ...
+      @nodes = Array.new		 
+      @INFINITY = 1 << 64 	 
+    end
+
+    def add_edge(x,y,w=nil) 		# s= source, t= target, w= weight
+      if (not @store.has_key?(x))	 
+        @store[x] = {y=>w}		 
+      else
+        @store[x][y] = w         
+      end
+
+      # Begin code for non directed graph (inserts the other edge too)
+
+      if (not @store.has_key?(y))
+        @store[y] = {x=>w}
+      else
+        @store[y][x] = w
+      end
+
+      # End code for non directed graph (ie. deleteme if you want it directed)
+
+      if (not @nodes.include?(x))	
+        @nodes << x
+      end
+      if (not @nodes.include?(y))
+        @nodes << y
+      end	
+    end
+
+    def add_edges(edges)
+      for e in edges
+        add(e.from,e.to)   
+      end    
+    end
+
+    def each_vertex
+      @adj_matrix.keys.each do |vertex|
+        yield vertex
+      end
+    end
+
+  end
+end

data/lib/ds/graphs/graph_as_matrix.rb

@@ -0,0 +1,114 @@
+module DS
+  class GraphAsMatrix
+
+    def initialize(edges)
+      @store = Array2D.new
+      @max = 0
+
+      @v = 0 #vertex count
+       
+      @map = [] #maps objects to matrix indexes.
+
+      add_edges(edges)
+    end
+
+    #Checks if two elements are connected.
+    def edge? x,y
+      v1 = @map.index(x)
+      v2 = @map.index(y)
+      @store[v1,v2] > 0
+    end
+
+    #Adds new edges to graph.
+    def add_edges(edges)
+      for e in edges
+        x = @map.push_uniq e.from
+        y = @map.push_uniq e.to
+
+        @store[x,y] = e.weight
+        @max = [@max, x, y].max
+        @v = @v +  1
+      end
+    end
+
+    #Returns all neighbors for given vertex.
+    def neighbors(v)
+      n = []
+      v = @map.index(v)
+      0.upto @max do |i|
+        n << @map[i] if @store[v,i] > 0
+      end
+      n
+    end
+
+    #Removes conection between vertex x and y.
+    def remove(x,y)
+      v1 = @map.index(x)
+      v2 = @map.index(y)
+
+      @store[v1,v2] = 0
+      if (degree @map[@max]) == 0
+        @max -= 1
+      end
+      @v -= 1
+    end
+
+    #Returns Edge(x,y) if exist.
+    def get_edge x,y
+      s = @map.index x
+      t = @map.index y
+      if @store[s,t] > 0
+        Edge.new(@map[s], @map[t], @store[s,t])
+      else
+        nil
+      end
+    end
+
+    def vmax
+      @max
+    end
+
+    #Returns vertex counter.
+    def vertex_size
+      @v
+    end
+
+
+    #Returns vertex degree. Second parameter determines direction - :in incoming
+    #edges, :out - outcoming edges, :all - incoming and outcoming edges.
+    def degree(x,direction=:all)
+      x = @map.index(x)
+      sum_in = 0
+      sum_out = 0
+      0.upto @max do |i|
+        sum_in += 1 if @store[i,x] and @store[i,x] > 0
+        sum_out += 1 if @store[x,i]  and @store[x,i] > 0
+      end
+
+      case direction
+      when :all
+        sum_in+sum_out
+      when :in
+        sum_in
+      when :out
+        sum_out
+      end
+    end
+
+
+    #Vertex iterator
+    def each_vertex
+      (0..@max).each {|v| yield @map[v]}
+    end
+
+    #Edge iterator
+    def each_edge
+      for v0 in 0..@max
+        for v1 in 0..v0-1
+          yield Edge.new(@map[v0],@map[v1],@store[v0,v1]) if @store[v0,v1] > 0
+        end    
+      end    
+    end
+
+  end
+end

data/lib/ds/graphs/graph_as_tri_matrix.rb

@@ -0,0 +1,25 @@
+module DS
+  class GraphAsTriMatrix < GraphAsMatrix
+
+    def initialize(edges)
+      @store = TriMatrix.new(0)
+      @max = 0
+      @map = []
+      @v = 0
+
+      add_edges(edges)
+    end
+
+    #Returns vertex degree.  
+    def degree(x)
+      x = @map.index(x)
+      sum = 0
+      0.upto @max do |i|
+        sum += @store[x,i] if @store[x,i] 
+      end
+      sum
+    end
+
+  end
+end
+

data/lib/ds/lists/cyclic_list.rb

@@ -0,0 +1,21 @@
+module DS
+
+  #Class represent list with cycle.
+  class CyclicList < List
+
+    #Returns cycle size. If list has no cycles returns 0.
+    def cycle_size
+      counter = 0
+      if start = self.joint
+        counter = 1
+        elem = joint.next
+        while elem != start
+          elem = elem.next
+          counter += 1
+        end
+      end
+      counter
+    end
+
+  end
+end

data/lib/ds/lists/list.rb

@@ -0,0 +1,303 @@
+module DS
+
+  #Implements simple list data structure. 
+  class List
+
+    include Enumerable
+
+    attr_accessor :head, :tail
+
+    #Creates new list. 
+    def initialize(x=nil)
+      @head = ListElement.new(x)
+      @tail = @head
+    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
+      list
+    end
+
+    #Appends new element to list. 
+    def append(x)
+      last_elem = self.tail
+      if !empty?
+        @tail = last_elem.append(x)
+      else
+        @head = ListElement.new(x)
+        @tail = @head
+      end
+    end
+
+    alias :<< :append
+
+    #Prepends new element to list.
+    def prepend(x)
+      el = ListElement.new(x)
+      el.next = @head
+      @head = el
+    end
+
+    #Removes element x from list.
+    def remove(x)
+      if x == head
+        self.head = head.next
+        x.next = nil
+      else
+
+        el = head
+        while el and el != x
+          prev = el 
+          el = el.next
+        end
+
+        raise "Element not found" unless el
+
+        prev.next = el.next
+        el.next = nil
+      end
+      x
+    end
+
+    #Removes list head.
+    def shift
+      remove(head).data
+    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
+      end
+
+      raise "Element not found" unless el
+
+      x.next = el.next
+      el.next = x
+
+      if x.tail?
+        self.tail = x
+      end
+    end
+
+    #Inserts element x before another element.
+    def insert_before(x,rel)
+      x = ListElement.new(x)  
+
+      #inserting at the beginnig of the list 
+      if rel == head
+        x.next = head
+        self.head = x
+
+      #inserting in the tail of the list
+      else
+        el = head
+        prev = head
+        while el and el != rel
+          prev = el
+          el = el.next
+        end
+
+        if el.nil?
+          raise "List element not found"
+        else
+          prev.next = x
+          x.next = el
+        end
+      end
+    end
+
+
+    #Checks if list is empty.
+    def empty?
+      head.data.nil?
+    end
+
+    #Returns last element of the list.
+    def last
+      tail.data
+    end
+
+    def first
+      head.data
+    end
+
+    #Returns length of the list.
+    def length
+      count
+    end
+
+    #Checks if list is linked at the end with other list.
+    def zip?(other)
+      tail.equal? other.tail 
+    end
+
+    #Returns joint element if exists, otherwise returns nil.
+    def joint
+      elem = head
+      elem2 = elem.next
+
+      while elem and elem2
+
+        #traversing by 1
+        elem = elem.next
+
+        #traversing by 2
+        elem2 = elem2.next
+        elem2 = elem2.next if elem2
+
+        if elem2.equal? elem
+          return elem
+        end
+      end
+
+      nil
+    end
+
+    #Returns true if list has cycle.
+    def looped?
+      !!joint
+    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
+
+      el = self.head
+
+      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
+
+        el = el.next
+      end
+
+      minus_tail.next = zero.head
+      zero_tail.next = plus.head
+      return minus
+    end
+
+
+    # Removes elements that exists on the other list.
+    def remove!(other)
+      a = head
+      b = other.head
+
+      while a and b
+
+        while a.data < b.data
+          prev = a
+          a = a.next
+        end
+
+        while b.data < a.data
+          b = b.next
+        end
+
+        a = a.next
+        prev.next = a
+        b = b.next
+      end
+      self
+    end
+
+    # Merge list with other list.
+    def merge(other)
+
+      a = self.head
+      b = other.head
+
+      if a.data < b.data
+        result = List.new(a.data)
+        a = a.next
+      else
+        result = List.new(b.data)
+        b = b.next
+      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
+    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
+      end
+
+      @head = prev
+      self
+
+    end
+
+    #Prints list.
+    def print
+      each { |e| p }
+    end
+
+    #Converts list to array.
+    def to_a
+      map { |e| e}
+    end
+
+    #Default list iterator.
+    def each
+      elem = @head
+      while elem
+        yield elem.data
+        elem = elem.next
+      end
+    end
+
+    def each_with_index
+      elem = @head
+      i = 0
+      while elem
+        yield elem,i
+        elem = elem.next
+        i = i + 1
+      end
+    end
+
+  end
+end