ruby_priority_queue 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e19e98409ae9c0aaec42725d65e361f3678cd81cf9bdeb221e367ae292fc1bc
-  data.tar.gz: 1cf81d6996ca45614ac5bf21c3affad81f75a2f0db0ec9ea920131075c821d98
+  metadata.gz: 283341222cc9a9cd99ac44326bb67ace91206a4154f542be277823599fcd5d31
+  data.tar.gz: 289ee1d3a549e00e4f2f20bf62e3202a708418f178667e393df29204b97381d8
 SHA512:
-  metadata.gz: d71ff39084ed7aeffeb817c0d81506ee67fdaa81fd7bb229d739f236390198334417c5ed491b1a0dd47248e2f129c8784b06ba904e15f9949829af91595ff5e3
-  data.tar.gz: 83bb120de89baf7c6cdac61cb6b8092f22419b1f5a71314152071c3dff4c1c8e3c55f596589cb91c85cf1e877e51a6ae8e4a4327cb10cf58d22e93a5dbd8f28b
+  metadata.gz: 212eb825cfd93ff62de3d1c8632fa422cd0711ee9c502b7bbcb19348f77bceb007777ff59202375a7e2256eefccddceffb3dddb0e86ff811179b22c7a22d333a
+  data.tar.gz: 83f7a1340a1de4a0decf694972da9cd8b091adc3d362bb08640d6a8afaf1ccb3e2c3aed9eb2c4e4b898c4faf4ef072cd94094757796bbe356eb6ba158277ab88

data/README.md

@@ -1,34 +1,95 @@
 # RubyPriorityQueue
 
-TODO: Delete this and the text below, and describe your gem
+The `RubyPriorityQueue` gem provides a simple implementation of a priority queue in Ruby. A priority queue is a data structure where each element is associated with a priority, and elements are served based on their priority.
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/ruby_priority_queue`. To experiment with that code, run `bin/console` for an interactive prompt.
 
-## Installation
+## Table of Contents
+
+- [Installation](#installation)
+- [Usage](#usage)
+- [Development](#development)
+- [Contributing](#contributing)
+- [License](#license)
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+
+## Installation
 
 Install the gem and add to the application's Gemfile by executing:
 
-    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+    $ bundle add ruby_priority_queue
 
 If bundler is not being used to manage dependencies, install the gem by executing:
 
-    $ gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+    $ gem install ruby_priority_queue
 
 ## Usage
 
-TODO: Write usage instructions here
+Here's how you can use the `RubyPriorityQueue` gem:
+
+```ruby
+require 'ruby_priority_queue'
+
+# Create a new priority queue
+pq = RubyPriorityQueue::PriorityQueue.new
+
+# Push elements with their priorities (lower value means higher priority, if you want to use a max heap, you can negate the priority)
+pq.push('task1', 1)
+# You can also use keyword arguments
+pq.push(item: 'task2', priority: 2)
+
+# Pop the element with the highest priority
+item, priority = pq.pop
+puts "Item: #{item}, Priority: #{priority}" # Output: Item: task1, Priority: 1
+
+# Check if the priority queue is empty
+puts pq.empty? # Output: false
+
+# Peek the item with the highest priority
+item, priority = pq.peek
+puts "Item: #{item}, Priority: #{priority}" # Output: Item: task2, Priority: 2
+
+# Get the size of the priority queue
+puts pq.size # Output: 1
+```
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+To contribute to the development of this gem, follow these steps:
+
+1. Clone the repository:
+```bash 
+   $ git clone https://github.com/caovanbi235/ruby_priority_queue.git 
+```
+
+2. Install dependecies:
+```bash
+   $ bin/setup
+```
+
+3. Run tests:
+```bash
+   $ rake spec
+```
+
+4. Experiment with the code:
+```bash
+   $ bin/console
+```
+
+5. To install this gem onto your local machine, run:
+```bash
+   $ bundle exec rake install
+```
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+6. To release a new version, update the version number in `version.rb`, and then run:
+```bash
+   $ bundle exec rake release
+```
+This will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/ruby_priority_queue.
+Bug reports and pull requests are welcome on GitHub at https://github.com/caovanbi235/ruby_priority_queue.
 
 ## License
 

data/lib/ruby_priority_queue/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyPriorityQueue
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/ruby_priority_queue.rb

@@ -14,6 +14,7 @@ module RubyPriorityQueue
   # - `pop`: Removes and returns the item with the highest priority.
   # - `empty?`: Checks if the queue is empty.
   # - `peek`: Returns the item with the highest priority without removing it.
+  # - `size`: Returns the number of elements in the queue.
   #
   # Example usage:
   #   pq = RubyPriorityQueue::PriorityQueue.new
@@ -21,55 +22,90 @@ module RubyPriorityQueue
   #   pq.push("task2", 2)
   #   pq.pop # => ["task1", 1]
   class PriorityQueue
+    # The Node class represents an element in the priority queue.
+    # Each node contains an item and its associated priority.
+    #
+    # The Node class includes the Comparable module to allow comparison
+    # between nodes based on their priority.
+    class Node
+      include Comparable
+      attr_accessor :item, :priority
+
+      # Initializes a new Node with the given item and priority.
+      #
+      # @param item [Object] the item to be stored in the node
+      # @param priority [Integer] the priority of the item
+      def initialize(item, priority)
+        @item = item
+        @priority = priority
+      end
+
+      # Compares this node with another node based on their priority.
+      #
+      # @param other [Node] the other node to compare with
+      # @return [Integer] -1, 0, or 1 if this node's priority is less than, equal to, or greater than the other node's priority
+      def <=>(other)
+        priority <=> other.priority
+      end
+    end
+
     def initialize
       @heap = []
     end
 
-    def push(item, priority)
-      @heap << [item, priority]
+    def push(item = nil, priority = nil, **kwargs)
+      item ||= kwargs[:item]
+      priority ||= kwargs[:priority]
+      @heap << Node.new(item, priority)
       bubble_up(@heap.size - 1)
     end
 
+    # @return [Array] an array containing the item and its priority
     def pop
       return if @heap.empty?
 
       swap(0, @heap.size - 1)
       min = @heap.pop
       bubble_down(0)
-      min
+      [min.item, min.priority]
     end
 
     def empty?
       @heap.empty?
     end
 
+    # @return [Array] an array containing the item and its priority
     def peek
-      @heap[0]
+      [@heap[0].item, @heap[0].priority]
+    end
+
+    def size
+      @heap.size
     end
 
     private
 
     def bubble_up(index)
       parent_index = (index - 1) / 2
-      return if index <= 0 || @heap[parent_index][1] <= @heap[index][1]
+      return if index <= 0 || @heap[parent_index] <= @heap[index]
 
       swap(index, parent_index)
       bubble_up(parent_index)
     end
 
     def bubble_down(index)
-      child_index = (index * 2) + 1
-      return if child_index >= @heap.size
+      left_child_index = (index * 2) + 1
+      return if left_child_index >= @heap.size
 
-      right_child_index = child_index + 1
-      if right_child_index < @heap.size && @heap[right_child_index][1] < @heap[child_index][1]
-        child_index = right_child_index
+      right_child_index = left_child_index + 1
+      if right_child_index < @heap.size && @heap[right_child_index] < @heap[left_child_index]
+        left_child_index = right_child_index
       end
 
-      return if @heap[index][1] <= @heap[child_index][1]
+      return if @heap[index] <= @heap[left_child_index]
 
-      swap(index, child_index)
-      bubble_down(child_index)
+      swap(index, left_child_index)
+      bubble_down(left_child_index)
     end
 
     def swap(source, target)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_priority_queue
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Cao Van Bi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-19 00:00:00.000000000 Z
+date: 2025-02-06 00:00:00.000000000 Z
 dependencies: []
 description: A priority queue implementation in Ruby
 email: