DSA 0.0.1

data/lib/DSA/list.rb

@@ -0,0 +1,183 @@
+module DSA
+  # Exception
+  class ListInsertError < StandardError
+  end
+  class ListRemovalError < StandardError
+  end
+
+  # Node
+  class ListNode
+    attr_accessor :element, :prev, :next
+    def initialize(e)
+      @element = e
+      @prev = nil
+      @next = nil
+    end
+  end
+
+  # ListIterator provides iteration on the list and constant time insertion and removal
+  class ListIterator
+    def initialize(node, list)
+      @node = node
+      @list = list
+    end
+
+    def next
+      @node = @node.next
+      raise StopIteration if @node == @list.tail || !@node
+      @node.element
+    end
+
+    def previous
+      @node = @node.prev
+      raise StopIteration if @node == @list.head || !@node
+      @node.element
+    end
+
+    def insert(e)
+      @list.insert_node_between @node.prev, @node, ListNode.new(e)
+    end
+
+    def remove
+      node = @list.remove_node(@node)
+      node.element
+    end
+
+    def update(e)
+      @node.element = e
+    end
+
+
+  end
+
+  # doubly linked list
+  class List
+    attr_reader :length
+    attr_reader :head, :tail # head and tail are two empty guards
+    include Enumerable
+
+    def initialize
+      @head = ListNode.new nil
+      @tail = ListNode.new nil
+      @head.next = @tail
+      @tail.prev = @head
+      @length = 0
+    end
+
+    def push(e)
+      insert_node_between @tail.prev, @tail, ListNode.new(e)
+    end
+
+    def pop
+      node = remove_node @tail.prev
+      node.element
+    end
+
+    def unshift(e)
+      insert_node_between @head, @head.next, ListNode.new(e)
+    end
+
+    def shift
+      node = remove_node @head.next
+      node.element
+    end
+
+    def first
+      self[0]
+    end
+
+    def last
+      self[@length-1]
+    end
+
+    def empty?
+      @length == 0
+    end
+
+    # insert an element at position index(0 based), linear time cost, use with caution, iterator preferred
+    def insert_at(index, e)
+      push e if index > @length - 1
+      node = get_node index
+      insert_node_between node.prev, node, ListNode.new(e)
+    end
+
+    # remove an element at position index(0 based), linear time cost, use with caution, iterator preferred
+    def remove_at(index)
+      node = get_node index
+      remove_node node
+      node.element
+    end
+
+    # access an element at position index(0 based), linear time cost, use with caution
+    def [](index)
+      get_node(index).element
+    end
+
+    def each
+      node = @head.next
+      while 1
+        break if node == @tail
+        yield node.element
+        node = node.next
+      end
+    end
+
+    # an iterator starting from head
+    def begin_iterator
+      ListIterator.new @head, self
+    end
+
+    # an iterator starting from end
+    def end_iterator
+      ListIterator.new @tail, self
+    end
+
+    # the following methods are used to process nodes, user usually does not need to use them
+    # insert node between two nodes
+    def insert_node_between(a, b, new_one)
+      a.next = new_one
+      new_one.prev = a
+      new_one.next = b
+      b.prev = new_one
+      @length += 1
+    end
+
+    # remove a node
+    def remove_node(node)
+      raise( ListRemovalError, 'List is empty' ) if @length == 0
+      before = node.prev
+      after = node.next
+      before.next = after
+      after.prev = before
+      @length -= 1
+      node
+    end
+
+    private
+    def get_node(index)
+      index += @length if index < 0
+      raise(ListInsertError, 'Index out of bound: ' + index.to_s) if index > @length - 1 || index < 0
+      if index > @length / 2
+        node = @tail.prev
+        current_index = @length - 1
+        while 1
+          return node if index == current_index
+          node = node.prev
+          current_index -= 1
+        end
+      else
+        node = @head.next
+        current_index = 0
+        while 1
+          return node if index == current_index
+          node = node.next
+          current_index += 1
+        end
+      end
+    end
+  end
+
+
+
+
+end

data/lib/DSA/priority_queue.rb

@@ -0,0 +1,70 @@
+module DSA
+  class PriorityQueueNode
+    attr_accessor :priority, :element
+    def initialize( priority, element )
+      @priority = priority
+      @element = element
+    end
+  end
+  # priority queue built on top of array based heap
+  class PriorityQueue
+    def initialize
+      @data = Array.new
+    end
+
+    def length
+      @data.length
+    end
+
+    # get the value of the top without removing it
+    def top
+      return nil if length == 0
+      @data.first.element
+    end
+
+    # priority is a number, the smaller it is, higher it has a priority
+    def add(priority, element)
+      @data.push PriorityQueueNode.new(priority,element)
+      up_heap_bubbling length-1
+    end
+
+    # remove the top and return the element
+    def pop
+      value = top
+      @data[0] = @data.pop # move the rightmost node to the top
+      down_heap_sinking 0
+      value
+    end
+
+    private
+    def up_heap_bubbling(index)
+      parent_index = (index - 1) / 2
+      return if parent_index < 0
+      if @data[index].priority < @data[parent_index].priority
+        swap index, parent_index
+        up_heap_bubbling parent_index
+      end
+    end
+
+    def swap(index_a, index_b)
+      @data[index_a], @data[index_b] = @data[index_b], @data[index_a]
+    end
+
+    def down_heap_sinking(index)
+      left_child_index = 2*index + 1
+      right_child_index = 2*index + 2
+      small_child_index = index
+      if left_child_index < length
+        small_child_index = left_child_index if @data[left_child_index].priority < @data[small_child_index].priority
+      end
+      if right_child_index < length
+        small_child_index = right_child_index if @data[right_child_index].priority < @data[small_child_index].priority
+      end
+      if small_child_index != index
+        swap small_child_index, index
+        down_heap_sinking small_child_index
+      end
+    end
+
+  end
+end

data/lib/DSA/stack_and_queue.rb

@@ -0,0 +1,151 @@
+require_relative 'list'
+
+module DSA
+  # The stack data structure
+  # Delegate the job to ruby Array, no need to worry about its growing and shrinking.
+  class ArrayStack
+    def initialize
+      @data = Array.new
+    end
+
+    def push(e)
+      @data.push e
+    end
+
+    def pop
+      @data.pop
+    end
+
+    def top
+      @data.last
+    end
+
+    def empty?
+      @data.empty?
+    end
+
+    def length
+      @data.length
+    end
+
+  end
+
+  # Stack built on top of list
+  class ListStack
+    def initialize
+      @data = DSA::List.new
+    end
+
+    def push(e)
+      @data.push e
+    end
+
+    def pop
+      @data.pop
+    end
+
+    def top
+      @data.last
+    end
+
+    def empty?
+      @data.empty?
+    end
+
+    def length
+      @data.length
+    end
+
+  end
+
+  # Typically, array is not a good idea to implement a queue, as it requires linear time to shift other elements after dequeue
+  # We can try to avoid the shifting by keep track of the index of the front queue element and make the array circular
+  class ArrayQueue
+    attr_reader :length
+
+    def initialize(initial_capacity = 10)
+      @data = Array.new initial_capacity
+      @front_index = 0
+      @length = 0
+    end
+
+    def enqueue(e)
+      grow if @length+1 == capacity
+      @length += 1
+      index = (@front_index + @length - 1 ) % capacity
+      @data[index] = e
+    end
+
+    def dequeue
+      shrink if @length - 1 < capacity / 2 and capacity / 2 >= 10
+      return nil if @length == 0
+      next_front = (@front_index + 1 ) % capacity
+      value = @data[@front_index]
+      @data[@front_index] = nil
+      @front_index = next_front
+      @length -= 1
+      value
+    end
+
+    def first
+      @data[@front_index]
+    end
+
+    def empty?
+      @length == 0
+    end
+
+    private
+    def capacity
+      @data.length
+    end
+
+    def grow
+      new_data = Array.new capacity * 2
+      copy_to new_data
+    end
+
+    def shrink
+      new_data = Array.new capacity / 2
+      copy_to new_data
+    end
+
+    def copy_to(new_data)
+      (0..@length-1).each do |i|
+        old_index = (@front_index + i) % capacity
+        new_data[i] = @data[old_index]
+      end
+      @data = new_data
+      @front_index = 0
+    end
+
+  end
+
+  # FIFO queue built on top of linked list
+  class ListQueue
+    def initialize
+      @data = DSA::List.new
+    end
+
+    def enqueue(e)
+      @data.push e
+    end
+
+    def dequeue
+      @data.shift
+    end
+
+    def first
+      @data.first
+    end
+
+    def empty?
+      @data.empty?
+    end
+
+    def length
+      @data.length
+    end
+  end
+
+end

data/lib/DSA/version.rb

@@ -0,0 +1,3 @@
+module DSA
+  VERSION = "0.0.1"
+end

data/test/algorithms_test.rb

@@ -0,0 +1,91 @@
+require 'test/unit'
+require 'benchmark'
+require 'DSA'
+
+class MyTest < Test::Unit::TestCase
+
+  # Called before every test method runs. Can be used
+  # to set up fixture information.
+  def setup
+    # Do nothing
+  end
+
+  # Called after every test method runs. Can be used to tear
+  # down fixture information.
+
+  def teardown
+    # Do nothing
+  end
+
+  def test_function
+    assert_equal 120, DSA::Algorithm::factorial(5), 'factorial function is wrong'
+    assert DSA::Algorithm::binary_search((1..9).to_a, 2, 0, 8), 'binary search failed'
+  end
+
+  def test_performance
+    puts
+
+    value = 10**7
+    target = value/3
+    data = (0..value).to_a
+    puts 'testing performance'
+    Benchmark.bm(20) do |x|
+      x.report('binary search') { DSA::Algorithm::binary_search(data, target, 0, value-1) }
+      x.report('linear search') { data.each do |a| break if a == target end  }
+    end
+  end
+
+
+  def test_sort
+    original = [3,6,7,8,2,4,7,8,1,5,9,6]
+    expect =   [1,2,3,4,5,6,6,7,7,8,8,9]
+    DSA::Algorithm::insertion_sort!(original)
+    assert_equal expect, original, 'sort failed'
+
+    original = [3,6,7,8,2,4,7,8,1,5,9,6]
+    expect =   [1,2,3,4,5,6,6,7,7,8,8,9]
+    DSA::Algorithm::quick_sort!(original, 0, original.length-1)
+    assert_equal expect, original, 'sort failed'
+
+    puts
+    puts 'insertion sort vs built in'
+    value = 10**3
+    sorted_a = (0..value).to_a
+    sorted_b = (0..value).to_a
+    sorted_c = (0..value).to_a
+
+
+    puts 'sort on already sorted'
+    Benchmark.bm(20) do |x|
+      x.report('insertion sort') { DSA::Algorithm::insertion_sort! sorted_a }
+      x.report('quick sort') { DSA::Algorithm::quick_sort! sorted_c, 0, sorted_c.length-1 }
+      x.report('built in sort') { sorted_b.sort!  }
+    end
+
+
+    puts 'sort on not sorted'
+    value = 10**4
+    not_sorted_a = value.times.map { Random.rand(value) }
+    not_sorted_b = value.times.map { Random.rand(value) }
+    not_sorted_c = value.times.map { Random.rand(value) }
+    Benchmark.bm(20) do |x|
+      x.report('insertion sort') { DSA::Algorithm::insertion_sort! not_sorted_a }
+      x.report('quick sort') { DSA::Algorithm::quick_sort! not_sorted_c, 0, not_sorted_c.length-1 }
+      x.report('built in sort') { not_sorted_b.sort!  }
+    end
+
+    puts 'sort on not sorted'
+    value = 10**6
+    not_sorted_b = value.times.map { Random.rand(value) }
+    not_sorted_c = value.times.map { Random.rand(value) }
+    Benchmark.bm(20) do |x|
+      x.report('quick sort') { DSA::Algorithm::quick_sort! not_sorted_c, 0, not_sorted_c.length-1 }
+      x.report('built in sort') { not_sorted_b.sort!  }
+    end
+
+
+  end
+
+
+
+end