ds 0.0.1

data/lib/ds/lists/list_element.rb

@@ -0,0 +1,26 @@
+module DS  
+
+  #Container for linked lists elements.
+  class ListElement
+
+    attr_accessor :data, :next
+
+    def initialize(x=nil)
+      @data = x
+      @next= nil
+    end
+    
+    #Adds new element to list.
+    def append(x)
+      elem = ListElement.new(x)
+      self.next = elem
+    end
+
+    #Checks if given element is last.
+    def tail?
+      @next.nil?
+    end
+
+  end
+end
+

data/lib/ds/lists/ring.rb

@@ -0,0 +1,42 @@
+module DS
+  
+  #Ring - represent list which head is linked with tail.
+  class Ring < CyclicList
+
+    #Creates ring from array. 
+    def self.from_array(arr)
+      list = Ring.new(arr.shift)
+      tail = list.head
+      arr.each { |e| tail = tail.append(e) }
+      tail.next = list.head
+      list
+    end
+
+    def length
+      cycle_size
+    end
+
+    #Removes ring elements by k until there is only one element in list.
+    def eliminate_by(k)
+      elem = self.head
+      prev = elem
+
+      k = k-1
+
+      while prev != elem.next 
+
+        k.times  do
+          prev = elem
+          elem = elem.next
+        end
+
+        prev.next = elem.next
+        elem = prev.next
+      end
+
+      return prev.data
+
+    end
+
+  end
+end

data/lib/ds/matrixes/array_2d.rb

@@ -0,0 +1,35 @@
+module DS
+   
+  #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)
+      @init = init
+      @store = Array.new(size){Array.new(size){init}}
+    end
+
+    
+    def [](x,y)
+      if @store[x].nil?
+        @store[x] = []
+        @init
+      elsif @store[x][y].nil?
+        @init
+      else
+        @store[x][y]
+      end
+    end
+
+    def []=(x,y,v)
+      @store[x] = [] if @store[x].nil?
+      @store[x][y] = v
+    end
+
+    def to_a
+      @store.flatten
+    end
+
+  end
+end

data/lib/ds/matrixes/expandable_array.rb

@@ -0,0 +1,37 @@
+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)
+      if x >=size
+        for i in size..x
+          self[i]=@extender
+        end
+      end
+      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)
+      max = size
+      super(x,v)
+      if size - max >1
+        (max..size-2).each do |i|
+          self[i] = @extender
+        end
+      end
+    end
+  end
+end
+
+

data/lib/ds/matrixes/tri_matrix.rb

@@ -0,0 +1,30 @@
+module DS
+  class TriMatrix
+
+    #Class implements Triangular Matrix (lower).
+
+    #Creates new triangular matrix.  
+    def initialize(init=0)
+      @store =ExpandableArray.new(0,init)
+    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
+      @store[index] = v
+    end
+
+    def to_a
+      @store
+    end
+
+  end
+end

data/lib/ds/queues/queue.rb

@@ -0,0 +1,53 @@
+module DS
+  
+  #Class implements queue data structure.
+  
+  class Queue
+
+    #Create new queue. First parameter determines how the queue will be represented internally.
+    def initialize(store = :array)
+      if store == :array 
+        @store = []
+      else
+        @store = List.new
+      end
+    end
+    
+    #Create new queue.Internaly uses list to store elements.
+    def Queue.create
+      new(:list)
+    end
+    
+    #Adds element to queue and returns queue itself.
+    def enqueue(x)
+      @store << x
+      self
+    end
+
+    alias :push :enqueue
+    
+    #Removes element from queue and returns it.
+    def dequeue
+      @store.shift
+    end
+
+    alias :shift :dequeue
+  
+    #Returns element from forehead of queue.
+    def peek
+      @store.first
+    end
+
+    #Returns length of queue. If queue is empty returns 0.
+    def length
+      @store.length
+    end
+    
+    #Checks if queue is empty.
+    def empty?
+      @store.empty?
+    end
+
+  end
+end
+

data/lib/ds/stacks/stack.rb

@@ -0,0 +1,39 @@
+module DS
+  
+  #Class implements Stack data structure.
+  #Internaly uses array to store elements.
+
+  class Stack
+    
+    def initialize
+      @store = []
+    end
+
+    #Returns the stack size.
+    def size
+      @store.size
+    end
+
+    # Removes element from stack and returns it.
+    def pop
+      @store.pop
+    end
+    
+    # Adds element to the top of the stack.
+    def push(x)
+      @store.push x
+    end
+
+    # Returns element from the top of the stack.
+    def peek
+      @store.last
+    end
+
+    # If stack is empty returns true otherwise returns false.
+    def empty?
+      @store.empty?
+    end
+  end
+end
+
+

data/lib/ds/trees/binary_heap.rb

@@ -0,0 +1,71 @@
+module DS
+  class BinaryHeap < CompleteBinaryTree
+    attr_accessor :data
+    
+    #Create new Heap from args.
+    #Given block sets the heap relation. Default heap relation is Max Heap.
+    def initialize(*args, &block)
+      if block_given?
+        @relation = block
+      else
+        @relation = Proc.new{|parent,child| parent >= child}
+      end
+      @data = args.to_a
+      heapify!
+    end
+
+    def set_relation(&relation)
+      @relation = relation
+    end
+
+    def relation(parent,child)
+      @relation.call(@data[parent],@data[child])
+    end
+
+    #Arranges data in heap.
+    #O(n)
+    def heapify!
+      (@data.size/2).downto(0) do |i|
+        heapify(i)
+      end
+    end
+
+    #Inserts new value to heap maintaining the heap relation.
+    #Returns heap itself.
+    #O(log)
+    def insert(value)
+      @data.push value
+      child = @data.size-1
+      parent = parent_index(child)
+
+      while parent >= 0 and !relation(parent,child)
+        @data[child], @data[parent] = @data[parent], @data[child]
+        child = parent
+        parent = parent_index(child)
+      end
+      self
+    end
+
+    #Maintain heap condition for i node.
+    #O(log)
+    def heapify(i)
+      left =  left_index(i)
+      left = nil if left >= @data.size
+
+      right = right_index(i)
+      right = nil if right >= @data.size
+
+      largest = [i,left,right].compact.sort{|x,y| relation(x,y)?-1:1}.first
+
+      if largest != i
+        @data[i], @data[largest] = @data[largest], @data[i]
+        heapify(largest)
+      end
+    end
+
+    def to_a
+      @data
+    end
+
+  end
+end

data/lib/ds/trees/binary_search_tree.rb

@@ -0,0 +1,32 @@
+module DS
+  class BinarySearchTree < BinaryTree
+
+    def self.from_array(arr)
+      tree = BinarySearchTree.new(arr.shift)
+      arr.each do |e|
+        tree.insert e
+      end
+      tree
+    end
+
+    def insert x
+      if x > @data and right.nil?
+        self.right = BinarySearchTree.new(x)
+      elsif x <= @data and left.nil?
+        self.left = BinarySearchTree.new(x)
+      elsif x > @data
+        right.insert x
+      else
+        left.insert x
+      end
+    end
+
+
+    def BinarySearchTree.valid?(other)
+      walker = TreeWalker.new(other)
+      walker.traverse(:inorder)
+      walker.visited.sorted?
+    end
+
+  end
+end

data/lib/ds/trees/binary_tree.rb

@@ -0,0 +1,65 @@
+module DS
+  class BinaryTree < Tree
+
+    def left
+      if @children.empty?
+        nil
+      else
+        @children[0]
+      end
+    end
+
+    def left=(value)
+      @children[0] = value
+    end
+
+    def right
+      if @children.empty?
+        nil
+      else
+        @children[1]
+      end
+    end
+
+    def right=(value)
+      @children[1] = value
+    end
+
+    def << (value)
+      subtree = BinaryTree.new(value)
+      @children << subtree
+      return subtree
+    end
+
+    #Inserts new element in BSF order
+    def insert(x)
+      q = Queue.new
+      if @data == nil
+        @data = x
+      elsif self.left == nil
+        self.left = BinaryTree.new(x)
+      elsif self.right == nil
+        self.right = BinaryTree.new(x)
+      else
+        q.push self.left
+        q.push self.right
+        loop do
+          node = q.shift
+          if node.left == nil
+            node.insert(x)
+            break
+          else 
+            q.push node.left
+          end
+          if node.right == nil
+            node.insert(x)
+            break
+          else
+            q.push node.right
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/ds/trees/complete_binary_tree.rb

@@ -0,0 +1,52 @@
+module DS
+  class CompleteBinaryTree
+    
+    def initialize(*args)
+      if args.empty? 
+        @data = []
+      else
+        @data = args.to_a
+      end
+    end
+
+    def << (value)
+      @data.push value
+    end
+
+    def root
+      @data.first
+    end
+
+    def children(value)
+      i = @data.index(value) 
+      return [@data[2*i+1], @data[2*i+2]]
+    end
+
+    def right value
+      children(value)[1]
+    end
+
+    def left value
+      children(value).first
+    end
+
+    def left_index(i)
+      2*i+1  
+    end
+
+    def right_index(i)
+      2*i+2
+    end
+
+    def parent_index(i)
+      (i+1)/2 - 1
+    end
+
+    def parent value
+      i = @data.index(value)
+      @data[parent_index(i)]
+    end
+
+  end
+end
+