DSA 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8b389b9d9e679bc3e426a95abfc2f103c93596a8
-  data.tar.gz: d44481bab4cc8cf982623829d822f91193880f3e
+  metadata.gz: 1cf45aaf41acd85971600055fd5dfac1825e539b
+  data.tar.gz: 8ab7c55725ae11725a9e9ef7bff86c6d9416a1a0
 SHA512:
-  metadata.gz: 284aba1b513d954e3a87033ae58b3c4bb9b3123f9f1c49e028e310e0c2f36a6f79d9c5468f17564808e75fa83cc9c0a7736a0623128b3e863d1c49c671614312
-  data.tar.gz: ff67a7432ac7656b1a7697f11448c1148fcc1034c4d5dcc4107a4f560abf33529354149c19aafa6289d8115d8c802146b5f5f47b85ab4cbecaadc22746d1092c
+  metadata.gz: 1085cb96b51a4b9dd4f168454cb9218bfa8cc473c2050a8cf662cfecc6feabd002876da7a6005bc28db323bd6a8f9f9a338dff5e6930cd20b4044b11a51051d1
+  data.tar.gz: bd64fc623b6c397346f355cc8b6e7cf289e7bc3e4e69138313c985cfb17830f7b2d466eec48df623f5cd217ac07ad771b611412803e6509523c952e954465845

data/README.md

@@ -87,6 +87,34 @@ A help method tried to print a tree, not quite pretty, but may helps test
 Enumerable is included, all those method such as 'each' are all available, since other methods are based on each,
 the performance might not be the best, use only when a full traversal is inevitable.
 
+### SkipList
+An ordered map, storing key/value pairs, duplicate keys are allowed, value can be omitted, preserves an order and provides range search, implemented as a skip list.
+
+```ruby
+    sl = DSA::SkipList.new
+    sl.add key, value
+    sl.add key # value will be nil
+    sl.delete key # all those pairs with the key will be deleted
+    sl.delete key, value # the pair has same key/value pair will be deleted
+```
+
+And special methods related to orders, those methods yield key/value pairs to block, if no block, enumerator is returned.
+```ruby
+    sl.find key
+    sl.each # in-order traversal
+    sl.gt(key) # key/value pairs for keys greater than key
+    sl.ge(key)
+    sl.lt(key)
+    sl.le(key)
+```
+A help method prints the skip list
+```ruby
+    sl.print_me
+    sl.print_me width # width, the length of evert key/value pair, default to 10
+```
+Enumerable is included, all those method such as 'each' are all available, since other methods are based on each,
+the performance might not be the best, use only when a full traversal is inevitable.
+
 
 ### PriorityQueue
 An array based heap, priority is a number, the smaller it is, higher priority it has

data/lib/DSA.rb

@@ -4,6 +4,7 @@ require_relative 'DSA/stack_and_queue'
 require_relative 'DSA/list'
 require_relative 'DSA/priority_queue'
 require_relative 'DSA/binary_search_tree'
+require_relative 'DSA/skip_list'
 
 module DSA
   # Your code goes here...

data/lib/DSA/binary_search_tree.rb

@@ -3,6 +3,7 @@ module DSA
   class BasicBinarySearchTreeNode
     attr_accessor :key, :value, :parent, :left, :right
     def initialize(key, value)
+      raise KeyError, 'Key cannot be nil' if key.nil?
       @key = key
       @value = value
       @parent = nil

data/lib/DSA/list.rb

@@ -1,6 +1,6 @@
 module DSA
   # Exception
-  class ListInsertError < StandardError
+  class ListIndexError < StandardError
   end
   class ListRemovalError < StandardError
   end
@@ -156,7 +156,7 @@ module DSA
     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
+      raise(ListIndexError, 'Index out of bound: ' + index.to_s) if index > @length - 1 || index < 0
       if index > @length / 2
         node = @tail.prev
         current_index = @length - 1

data/lib/DSA/skip_list.rb

@@ -0,0 +1,358 @@
+module DSA
+  class SkipListNode
+    attr_accessor :key, :value, :prev, :next, :up, :down
+    def initialize(key, value = nil)
+      @key = key
+      @value = value
+      @prev = nil
+      @next = nil
+      @up = nil
+      @down = nil
+    end
+
+    def is_sentinel?
+      @key.equal? SkipListLevel::SENTINEL
+    end
+  end
+
+  class SkipListLevel
+    attr_accessor :head, :tail
+    SENTINEL = Object.new
+    def initialize
+      @head = SkipListNode.new(SENTINEL, 'Sentinel')
+      @tail = SkipListNode.new(SENTINEL, 'Sentinel')
+      @head.next = @tail
+      @tail.prev = @head
+    end
+  end
+
+  class SkipList
+    attr_reader :length, :height
+    include Enumerable
+    def initialize
+      @levels = [SkipListLevel.new]
+      @length = 0
+      @height = 0
+    end
+
+    def find(key)
+      nodes = find_nodes key
+
+      if block_given?
+        return unless nodes
+        nodes.each do |node|
+          yield [node.key, node.value]
+        end
+      else
+        Enumerator.new do |y|
+          find(key) do |key, value|
+            y << [key, value]
+          end
+        end
+      end
+
+    end
+
+    def each
+      walk = @levels.first.head
+      if block_given?
+        walk = walk.next
+        until walk.is_sentinel?
+          yield [ walk.key, walk.value ]
+          walk = walk.next
+        end
+      else
+        Enumerator.new do |y|
+          each do |key, value|
+            y << [key, value]
+          end
+        end
+      end
+    end
+
+    def gt(key)
+      nodes = find_nodes(key, true, false)
+
+      if block_given?
+        return unless nodes
+        walk = nodes.last.next
+        until walk.is_sentinel?
+          yield [ walk.key, walk.value ]
+          walk = walk.next
+        end
+      else
+        Enumerator.new do |y|
+          gt(key) do |key, value|
+            y << [key, value]
+          end
+        end
+      end
+    end
+
+    def ge(key)
+      nodes = find_nodes(key, true, false)
+
+      if block_given?
+        return unless nodes
+        if nodes.first.key == key
+          walk = nodes.first
+        else
+          walk = nodes.first.next
+        end
+        until walk.is_sentinel?
+          yield [ walk.key, walk.value ]
+          walk = walk.next
+        end
+      else
+        Enumerator.new do |y|
+          ge(key) do |key, value|
+            y << [key, value]
+          end
+        end
+      end
+    end
+
+    def lt(key)
+      nodes = find_nodes(key, false, true)
+
+      if block_given?
+        return unless nodes
+        walk = nodes.first.prev
+        until walk.is_sentinel?
+          yield [ walk.key, walk.value ]
+          walk = walk.prev
+        end
+      else
+        Enumerator.new do |y|
+          lt(key) do |key, value|
+            y << [key, value]
+          end
+        end
+      end
+    end
+
+    def le(key)
+      nodes = find_nodes(key, false, true)
+
+      if block_given?
+        return unless nodes
+        if nodes.first.key == key
+          walk = nodes.last
+        else
+          walk = nodes.last.prev
+        end
+        until walk.is_sentinel?
+          yield [ walk.key, walk.value ]
+          walk = walk.prev
+        end
+      else
+        Enumerator.new do |y|
+          le(key) do |key, value|
+            y << [key, value]
+          end
+        end
+      end
+    end
+
+
+    # if value provided, the nodes have the same key/value pairs will be deleted,
+    # otherwise, all nodes have the same key are deleted
+    # return the value of last deleted node
+    def delete(key, value = nil)
+      nodes = find_nodes(key)
+      return false unless nodes
+
+      return_value = false
+      nodes.each do |node|
+        if !value || value == node.value
+          return_value = remove_tower node
+          @length -= 1
+          remove_empty_level
+        end
+      end
+
+      return_value
+    end
+
+    def add(key, value = nil)
+      potential_place = []
+      walk = start_node
+      while 1
+        if walk.next.is_sentinel? || key <= walk.next.key
+          if walk.down
+            potential_place.push walk
+            walk = walk.down
+            next
+          else
+            insert_node_between walk, walk.next, SkipListNode.new(key, value)
+            @length += 1
+            build_tower walk.next, potential_place, key, value
+            break
+          end
+        else
+          walk = walk.next
+          next
+        end
+      end
+    end
+
+    def print_me(width = 10)
+      rec = Hash.new
+      walk = @levels.first.head
+      i = 0
+      j = 0
+      walk = walk.next
+      while ! walk.is_sentinel?
+        rec[ [i, j] ] = "#{walk.key},#{walk.value}"
+        up_walk = walk
+        while up_walk.up
+          up_walk = up_walk.up
+          j += 1
+          rec[ [i, j] ] ="#{up_walk.key},#{up_walk.value}"
+        end
+        walk = walk.next
+        i += 1
+        j = 0
+      end
+
+      # print
+      puts '=' * 100
+      (height+1).times.reverse_each do |j|
+        printf 'Sentinel--'
+        (length).times do |i|
+          if rec[ [i, j] ]
+            printf ">%#{width+2}s", "#{rec[ [i, j] ]}--"
+          else
+            printf '-' + '-' * width + '--'
+          end
+        end
+        puts '>Sentinel'
+      end
+      puts '=' * 100
+    end
+
+    private
+    def remove_empty_level
+      return if @length < 2
+      one_to_last = @levels[-2]
+      if one_to_last.head.next.is_sentinel?
+        @levels.pop
+        @height -= 1
+      end
+    end
+
+    # if not found, two more options are provided
+    def find_nodes(key, return_previous = false, return_next = false )
+      walk = start_node
+      while 1
+        if !walk.is_sentinel? && key == walk.key
+          break
+        elsif walk.next.is_sentinel? || key < walk.next.key
+          if walk.down
+            walk = walk.down
+            next
+          else
+            if return_previous
+              return [walk]
+            elsif return_next
+              return [walk.next]
+            else
+              return nil
+            end
+          end
+        else
+          walk = walk.next
+          next
+        end
+      end
+
+      nodes = []
+      while !walk.is_sentinel? && walk.down
+        walk = walk.down
+      end
+
+      nodes.push walk
+
+      # to find the duplicates
+      other_node = walk.next
+      while !other_node.is_sentinel? && other_node.key == key
+        nodes.push other_node
+        other_node = other_node.next
+      end
+
+      other_node = walk.prev
+      while !other_node.is_sentinel? && other_node.key == key
+        nodes.unshift other_node
+        other_node = other_node.prev
+      end
+
+      nodes
+    end
+
+    def remove_tower(base)
+      remove_node base
+      remove_tower base.up if base.up
+      base.value
+    end
+
+    def build_tower(base, tower, key, value)
+      up_stair_previous = nil
+      tower.reverse_each do |node|
+        return unless go_up?
+        up_stair_previous = node
+        new_node = SkipListNode.new(key, value)
+        insert_node_between up_stair_previous, up_stair_previous.next, new_node
+        vertical_link_node new_node, base
+        base = new_node
+      end
+      # add new level
+      if go_up?
+        add_level
+        @height += 1
+      end
+
+    end
+
+    def add_level
+      new_level = SkipListLevel.new
+      vertical_link_node  new_level.head, @levels.last.head
+      vertical_link_node  new_level.tail, @levels.last.tail
+      @levels.push new_level
+    end
+
+    def vertical_link_node(above, below)
+      above.down = below
+      below.up = above
+    end
+
+    def go_up?
+      [true, false].sample
+    end
+
+    def insert_node_between(a, b, new_one)
+      a.next = new_one
+      new_one.prev = a
+      new_one.next = b
+      b.prev = new_one
+    end
+
+    # remove a node
+    def remove_node(node)
+      before = node.prev
+      after = node.next
+      before.next = after
+      after.prev = before
+      node
+    end
+
+    def start_node
+      @levels.last.head
+    end
+
+    def end_node
+      @levels.first.tail
+    end
+
+
+  end
+end

data/lib/DSA/version.rb

@@ -1,3 +1,3 @@
 module DSA
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/test/binary_search_tree_test.rb

@@ -270,6 +270,7 @@ class MyTest < Test::Unit::TestCase
   def test_performance
     puts
     rb = DSA::RedBlackTree.new
+    sl = DSA::SkipList.new
     hash = Hash.new
     value = 10**5
     Benchmark.bm(20) do |x|
@@ -277,6 +278,10 @@ class MyTest < Test::Unit::TestCase
       x.report('RedBlack Find') { value.times { rb[Random.rand(value)] } }
       x.report('RedBlack Find gt') { value.times { rb.gt(Random.rand(value)) } }
       x.report('RedBlack Deletion') { (value/2).times { rb.delete Random.rand(value) } }
+      x.report('SkipList') { value.times { sl.add Random.rand(value), 'whatever' } }
+      x.report('SkipList Find') { value.times { sl.find Random.rand(value) } }
+      x.report('SkipList Find gt') { value.times { sl.gt Random.rand(value) } }
+      x.report('SkipList Deletion') { (value/2).times { sl.delete Random.rand(value) } }
       x.report('Built-In Hash') { value.times { hash[Random.rand(value)] = 'whatever' } }
       x.report('Built-In Hash Find') { value.times { hash[Random.rand(value)] } }
       x.report('Built-In Hash Deletion') { (value/2).times { hash.delete Random.rand(value) } }

data/test/skip_list_test.rb

@@ -0,0 +1,115 @@
+require 'test/unit'
+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_skip_list
+    sl = DSA::SkipList.new
+    value = 20
+    value.times { sl.add Random.rand(value/3), Random.rand(value*2) }
+
+    sl.print_me
+
+    sl.find 5 do |key, value|
+      puts "(#{key}, #{value})"
+    end
+
+    e = sl.find 5
+    loop do
+      key, value = e.next
+      puts "(#{key}, #{value})"
+    end
+
+    sl.add 5, 100
+    sl.add 5, 200
+    sl.print_me
+    assert_equal 200, sl.delete(5, 200), 'delete failed'
+    sl.print_me
+    puts sl.delete 5
+    sl.print_me
+
+    value = 20
+    value.times { sl.add Random.rand(value), Random.rand(value*2) }
+    sl.print_me
+    value.times { sl.delete Random.rand(value) }
+    sl.print_me 5
+
+    sl.each do |key, value|
+      printf "(#{key}, #{value})"
+    end
+    puts
+
+    e = sl.each
+    loop do
+      key, value = e.next
+      printf "(#{key}, #{value})"
+    end
+    puts
+
+    sl.gt(10) do |key, value|
+      printf "(#{key}, #{value})"
+    end
+    puts
+
+    e = sl.gt(10)
+    loop do
+      key, value = e.next
+      printf "(#{key}, #{value})"
+    end
+    puts
+
+    sl.ge(10) do |key, value|
+      printf "(#{key}, #{value})"
+    end
+    puts
+
+    e = sl.ge(10)
+    loop do
+      key, value = e.next
+      printf "(#{key}, #{value})"
+    end
+    puts
+
+    sl.lt(10) do |key, value|
+      printf "(#{key}, #{value})"
+    end
+    puts
+
+    e = sl.lt(10)
+    loop do
+      key, value = e.next
+      printf "(#{key}, #{value})"
+    end
+    puts
+
+    sl.le(10) do |key, value|
+      printf "(#{key}, #{value})"
+    end
+    puts
+
+    e = sl.le(10)
+    loop do
+      key, value = e.next
+      printf "(#{key}, #{value})"
+    end
+    puts
+
+    value = 10 ** 3
+    value.times { sl.add Random.rand(value), Random.rand(value*2) }
+    sl.print_me
+
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: DSA
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - lusaisai
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-21 00:00:00.000000000 Z
+date: 2014-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -57,12 +57,14 @@ files:
 - lib/DSA/binary_search_tree.rb
 - lib/DSA/list.rb
 - lib/DSA/priority_queue.rb
+- lib/DSA/skip_list.rb
 - lib/DSA/stack_and_queue.rb
 - lib/DSA/version.rb
 - test/algorithms_test.rb
 - test/binary_search_tree_test.rb
 - test/list_test.rb
 - test/priority_queue_test.rb
+- test/skip_list_test.rb
 - test/stack_and_queue_test.rb
 homepage: https://github.com/lusaisai/DSA
 licenses:
@@ -93,4 +95,5 @@ test_files:
 - test/binary_search_tree_test.rb
 - test/list_test.rb
 - test/priority_queue_test.rb
+- test/skip_list_test.rb
 - test/stack_and_queue_test.rb