Make it possible to use objects in priority queue.

src/data-structures/priority-queue/PriorityQueue.js

@@ -1,52 +1,59 @@
 import MinHeap from '../heap/MinHeap';
 import Comparator from '../../utils/comparator/Comparator';
 
-// It is the same as min heap except that when comparing to elements
+// It is the same as min heap except that when comparing two elements
-// we take into account not element's value but rather its priority.
+// we take into account its priority instead of the element's value.
 export default class PriorityQueue extends MinHeap {
   constructor() {
+    // Call MinHip constructor first.
     super();
-    this.priorities = {};
+
+    // Setup priorities map.
+    this.priorities = new Map();
+
+    // Use custom comparator for heap elements that will take element priority
+    // instead of element value into account.
     this.compare = new Comparator(this.comparePriority.bind(this));
   }
 
   /**
-   * @param {*} item
+   * Add item to the priority queue.
-   * @param {number} [priority]
+   * @param {*} item - item we're going to add to the queue.
+   * @param {number} [priority] - items priority.
    * @return {PriorityQueue}
    */
   add(item, priority = 0) {
-    this.priorities[item] = priority;
+    this.priorities.set(item, priority);
     super.add(item);
-
     return this;
   }
 
   /**
-   * @param {*} item
+   * Remove item from priority queue.
-   * @param {Comparator} [customFindingComparator]
+   * @param {*} item - item we're going to remove.
+   * @param {Comparator} [customFindingComparator] - custom function for finding the item to remove
    * @return {PriorityQueue}
    */
   remove(item, customFindingComparator) {
     super.remove(item, customFindingComparator);
-    delete this.priorities[item];
+    this.priorities.delete(item);
-
     return this;
   }
 
   /**
-   * @param {*} item
+   * Change priority of the item in a queue.
-   * @param {number} priority
+   * @param {*} item - item we're going to re-prioritize.
+   * @param {number} priority - new item's priority.
    * @return {PriorityQueue}
    */
   changePriority(item, priority) {
     this.remove(item, new Comparator(this.compareValue));
     this.add(item, priority);
-
     return this;
   }
 
   /**
+   * Find item by ite value.
    * @param {*} item
    * @return {Number[]}
    */
@@ -55,6 +62,7 @@ export default class PriorityQueue extends MinHeap {
   }
 
   /**
+   * Check if item already exists in a queue.
    * @param {*} item
    * @return {boolean}
    */
@@ -63,19 +71,20 @@ export default class PriorityQueue extends MinHeap {
   }
 
   /**
+   * Compares priorities of two items.
    * @param {*} a
    * @param {*} b
    * @return {number}
    */
   comparePriority(a, b) {
-    if (this.priorities[a] === this.priorities[b]) {
+    if (this.priorities.get(a) === this.priorities.get(b)) {
       return 0;
     }
-
+    return this.priorities.get(a) < this.priorities.get(b) ? -1 : 1;
-    return this.priorities[a] < this.priorities[b] ? -1 : 1;
   }
 
   /**
+   * Compares values of two items.
    * @param {*} a
    * @param {*} b
    * @return {number}
@@ -84,7 +93,6 @@ export default class PriorityQueue extends MinHeap {
     if (a === b) {
       return 0;
     }
-
     return a < b ? -1 : 1;
   }
 }

src/data-structures/priority-queue/__test__/PriorityQueue.test.js

@@ -20,6 +20,23 @@ describe('PriorityQueue', () => {
     expect(priorityQueue.peek()).toBe(100);
   });
 
+  it('should be possible to use objects in priority queue', () => {
+    const priorityQueue = new PriorityQueue();
+
+    const user1 = { name: 'Mike' };
+    const user2 = { name: 'Bill' };
+    const user3 = { name: 'Jane' };
+
+    priorityQueue.add(user1, 1);
+    expect(priorityQueue.peek()).toBe(user1);
+
+    priorityQueue.add(user2, 2);
+    expect(priorityQueue.peek()).toBe(user1);
+
+    priorityQueue.add(user3, 0);
+    expect(priorityQueue.peek()).toBe(user3);
+  });
+
   it('should poll from queue with respect to priorities', () => {
     const priorityQueue = new PriorityQueue();