priority-queue 0.6.0

A Priority Queue implemented as a heap with a function to efficiently change the priority of an item.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

=============
PriorityQueue
============= 
.. image:: https://img.shields.io/crates/v/priority-queue.svg
	   :target: https://crates.io/crates/priority-queue
.. image:: https://travis-ci.org/garro95/priority-queue.svg?branch=master
	   :target: https://travis-ci.org/garro95/priority-queue
	   
This crate implements a Priority Queue with a function to change the priority of an object.
Priority and items are stored in an `IndexMap` and the queue is implemented as a Heap of indexes.


Please read the `API documentation here`__

__ https://docs.rs/priority-queue/

Usage
-----
To use this crate, simply add the following string to your `Cargo.toml`:

	  priority-queue = "0.5.2"

Notice that a change in the last digit (patch number) means that the interface is
backward and forward compatible and contains other type of fixes, like bug fixes or
documentation updates.
A change in the middle digit (minor) means that the interface is backward compatible
but includes something new, so that the previous version may be not forward compatible.
A change in the first, left digit may means a breacking change in the interface, that
will not be backward compatible anymore. Version 1.0.0 may be an exception to this and
may means just that the API is stable and is considered production ready.

Then use the data structure inside your Rust source code as in the following Example.

Remember that, if you need serde support, you should compile using `--features serde`.

Example
-------
.. code:: rust
	  
	  extern crate priority_queue;

	  use priority_queue::PriorityQueue;
	  
	  fn main() {
	      let mut pq = PriorityQueue::new();

	      assert!(pq.is_empty());
	      pq.push("Apples", 5);
	      pq.push("Bananas", 8);
	      pq.push("Strawberries", 23);

	      assert_eq!(pq.peek(), Some((&"Strawberries", &23)));

	      for (item, _) in pq.into_sorted_iter() {
	          println!("{}", item);
	      }
	  }

Note: in recent versions of Rust (edition 2018) the `extern crate priority_queue` is not necessary anymore!

Speeding up
-----------

You can use custom BuildHasher for the underlying IndexMap and therefore achieve better performance.
For example you can create the queue with the speedy FxHash_ hasher:

.. code:: rust

      use hashbrown::hash_map::DefaultHashBuilder;

      let mut pq = PriorityQueue::<_, _, DefaultHashBuilder>::with_default_hasher();

.. _FxHash: https://github.com/Amanieu/hashbrown

Benchmarks
----------
Some benchmarks have been run to compare the performances of this priority queue to the standard BinaryHeap, also using the FxHash hasher.
The benchmarks produced the following results:
::
   test benchmarks::push_and_pop                    ... bench:          80 ns/iter (+/- 6)
   test benchmarks::push_and_pop_fx                 ... bench:          49 ns/iter (+/- 5)
   test benchmarks::push_and_pop_on_large_queue     ... bench:         296 ns/iter (+/- 25)
   test benchmarks::push_and_pop_on_large_queue_fx  ... bench:         259 ns/iter (+/- 41)
   test benchmarks::push_and_pop_on_large_queue_std ... bench:          75 ns/iter (+/- 6)
   test benchmarks::push_and_pop_std                ... bench:          11 ns/iter (+/- 1)


Contributing
------------

Feel free to contribute to this project with pull requests and/or issues. All contribution should be under a license compatible with the GNU LGPL.

Changes
-------

* 0.6.0 Allow the usage of custom hasher
* 0.5.4 Prevent panic on extending an empty queue
* 0.5.3 New implementation of the `Default` trait avoids the requirement that `P: Default`
* 0.5.2 Fix documentation formatting
* 0.5.1 Add some documentation for `iter_mut()`
* 0.5.0 Fix #7 implementing the `iter_mut` features
* 0.4.5 Fix #6 for `change_priority` and `change_priority_by`
* 0.4.4 Fix #6
* 0.4.3 Fix #4 changing the way PriorityQueue serializes.
  Note that old serialized PriorityQueues may be incompatible with the new version.
  The API should not be changed instead.
* 0.4.2 Improved performance using some unsafe code in the implementation.
* 0.4.1 Support for serde when compiled with `--features serde`.
  serde marked as optional and serde-test as dev-dipendency.
  Now compiling the crate won't download and compile also serde-test, neither serde if not needed.
* 0.4.0 Support for serde when compiled with `cfg(serde)`
* 0.3.1 Fix #3
* 0.3.0 Implement PartialEq and Eq traits