ds 0.0.4 → 0.0.6

data/lib/ds/lists/list_element.rb

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

data/lib/ds/pair.rb

@@ -1,14 +1,14 @@
 module DS
+  # Simple class for key, value objects
   class Pair
     attr_accessor :key, :value
 
-    alias :first :key
-    alias :second :value
+    alias first key
+    alias second value
 
-    def initialize(x,y)
+    def initialize(x, y)
       @key = x
       @value = y
     end
-
   end
 end

data/lib/ds/queues/priority_queue.rb

@@ -1,36 +1,49 @@
 module DS
-  class PriorityQueue < Queue
-
-    #Create new priority queue. Internaly uses heap to store elements.
-    def initialize
-      @store = BinaryHeap.new {|parent,child| parent.key >= child.key}
+  # Class implements Priority Queue
+  class PriorityQueue
+    # Create new priority queue. Internaly uses heap to store elements.
+    def initialize(*args)
+      @store = if block_given?
+                 BinaryHeap.new(*args) do |parent, child|
+                   yield parent.key, child.key
+                 end
+               else
+                 BinaryHeap.new(*args) { |parent, child| parent.key >= child.key }
+               end
     end
 
-
-    #Adds element to queue with given priority.
-    def enqueue x, priority
-      pair = Pair.new(priority,x)
+    # Adds element to queue with given priority.
+    def enqueue(x, priority)
+      pair = Pair.new(priority, x)
       @store.insert(pair)
       self
     end
-    
-    alias :push :enqueue
 
-    #Removes element with highest priority from queue . 
+    alias push enqueue
+
+    # Removes element with highest priority from queue.
     def dequeue
-      if x = @store.shift
-        x.value
-      else
-        x
-      end
+      x = @store.shift
+      x ? x.value : nil
     end
 
-    alias :shift :dequeue
+    alias shift dequeue
 
-    #Returns element with highest priority.
+    # Returns element with highest priority.
     def peek
-      @store.data.first.value
+      @store.top.value
     end
 
+    # Returns length of queue. If queue is empty returns 0.
+    def length
+      @store.length
+    end
+
+    alias size length
+
+    # Checks if queue is empty.
+    def empty?
+      @store.empty?
+    end
   end
 end

data/lib/ds/queues/simple_queue.rb

@@ -0,0 +1,55 @@
+module DS
+  # Class implements queue data structure.
+  class SimpleQueue
+    # Create new queue.
+    # First parameter determines how the queue will be represented internally.
+    def initialize(*args)
+      @store = if args.first.is_a? List
+                 args.first
+               else
+                 args || []
+               end
+    end
+
+    # Create new queue. Internaly uses List to store elements.
+    def self.create(*args)
+      new(List.new(*args))
+    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
+
+    alias size length
+
+    # Checks if queue is empty.
+    def empty?
+      store.empty?
+    end
+
+    protected
+
+    attr_reader :store
+  end
+end

data/lib/ds/sets/indexed_set.rb

@@ -0,0 +1,37 @@
+module DS
+  # IndexedSet Class
+  class IndexedSet
+    attr_reader :size
+
+    # Creates new Indexed Set.
+    def initialize
+      @size = 0
+      @store = {}
+      @cache = []
+    end
+
+    # Adds new element to set
+    def push(e)
+      unless @store[e]
+        index = size
+        @store[e] = index
+        @size += 1
+        @cache[index] = e
+      end
+      @store[e]
+    end
+
+    # Returns element index.
+    def index(e)
+      @store[e]
+    end
+
+    def to_a
+      @cache
+    end
+
+    def empty?
+      @size == 0
+    end
+  end
+end

data/lib/ds/stacks/stack.rb

@@ -1,39 +1,47 @@
 module DS
-  
-  #Class implements Stack data structure.
-  #Internaly uses array to store elements.
-
+  # Class implements Stack data structure.
+  # Internaly uses array or linked list to store elements.
   class Stack
-    
-    def initialize
-      @store = []
+    def initialize(*args)
+      @store = if args.first.is_a? List
+                 args.first
+               else
+                 args || []
+               end
+    end
+
+    # Creates stack internally implemented as List
+    def self.create(*args)
+      new(List.new(*args))
     end
 
-    #Returns the stack size.
+    # Returns the stack size.
     def size
-      @store.size
+      store.size
     end
 
     # Removes element from stack and returns it.
     def pop
-      @store.pop
+      store.pop unless empty?
     end
-    
-    # Adds element to the top of the stack.
+
+    # Adds element on the top of the stack.
     def push(x)
-      @store.push x
+      store.push x
     end
 
     # Returns element from the top of the stack.
     def peek
-      @store.last
+      store.last
     end
 
     # If stack is empty returns true otherwise returns false.
     def empty?
-      @store.empty?
+      store.empty?
     end
-  end
-end
 
+    protected
 
+    attr_reader :store
+  end
+end

data/lib/ds/trees/binary_heap.rb

@@ -1,102 +1,107 @@
 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.
+  # Create new Heap from args.
+  class BinaryHeap
+    attr_reader :store
+
+    # 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
+      @relation = if block_given?
+                    block
+                  else
+                    -> (parent, child) { parent >= child }
+                  end
+      @store = HeapStore.new(*args)
       heapify!
     end
 
-    #Create new Maximum Heap from args.
-    def BinaryHeap.max(*args)
-      new(*args){|parent,child| parent >= child}
+    # Create new Maximum Heap from args.
+    def self.max(*args)
+      new(*args) { |parent, child| parent >= child }
     end
 
-    #Create new Minimum Heap from args.
-    def BinaryHeap.min(*args)
-      new(*args){|parent,child| parent < child}
+    # Create new Minimum Heap from args.
+    def self.min(*args)
+      new(*args) { |parent, child| parent < child }
     end
 
-
-    #Evaluates Heap relation.
-    def relation(parent,child)
-      @relation.call(@data[parent],@data[child])
+    # Evaluates Heap relation.
+    def relation(parent, child)
+      @relation.call(store[parent], store[child])
     end
 
-    #Arranges data in heap.
-    #O(n)
+    # Arranges data in heap.
+    # O(n)
     def heapify!
-      (@data.size/2).downto(0) do |i|
-        heapify(i)
-      end
-    end
-
-    #Maintains 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
+      (length / 2).downto(1) { |i| sink(i) }
     end
 
-    #Removes element from heap maintaining heap relation.
+    # Removes element from heap maintaining heap relation.
     def shift
-      if @data.size > 0
-        result = @data.shift
-        return result if @data.size.zero?
-        @data.unshift @data.pop
-        heapify(0)
+      unless empty?
+        result = store.first
+        swap(1, length)
+        store.pop
+        sink(1)
       end
       result
     end
 
-    #Inserts new value to heap maintaining the heap relation.
-    #Returns heap itself.
-    #O(log)
+    # 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
+      store.push value
+      swim(length)
       self
     end
 
-
+    def top
+      store.first
+    end
 
     def length
-      @data.size 
+      store.length
     end
 
-    alias :size :length
+    alias size length
 
     def empty?
-      @data.empty?
+      store.empty?
     end
 
     def to_a
-      @data
+      store.to_a
+    end
+
+    private
+
+    def swim(k)
+      while k > 1 && less(k / 2, k)
+        swap(k, k / 2)
+        k /= 2
+      end
     end
 
+    def sink(k)
+      n = length
+      while 2 * k <= n
+        j = 2 * k
+        j += 1 if j < n && less(j, j + 1)
+        break unless less(k, j)
+        swap(k, j)
+        k = j
+      end
+    end
+
+    def less(x, y)
+      !relation(x, y)
+    end
+
+    def swap(x, y)
+      temp = store[y]
+      store[y] = store[x]
+      store[x] = temp
+    end
   end
 end