add .contains

src/maxPriorityQueue.d.ts

@@ -12,6 +12,7 @@ export class MaxPriorityQueue<T> {
   dequeue(): T;
   pop(): T;
   remove(cb: (value: T) => boolean): T[];
+  contains(cb: (value: T) => boolean): boolean;
   toArray(): T[];
   clear(): void;
   static fromArray<T>(values: T[], getCompareValue?: IGetCompareValue<T>): MaxPriorityQueue<T>;

src/maxPriorityQueue.js

@@ -105,6 +105,32 @@ class MaxPriorityQueue {
     return removed;
   }
 
+  /**
+   * Checks if the queue contains an element that matches a criteria
+   * @public
+   * @param {function} cb
+   * @returns {boolean}
+   */
+  contains(cb) {
+    if (typeof cb !== 'function') {
+      throw new Error('MaxPriorityQueue contains expects a callback');
+    }
+
+    let found = false;
+    const dequeued = [];
+    while (!this.isEmpty()) {
+      const popped = this.pop();
+      dequeued.push(popped);
+      if (cb(popped)) {
+        found = true;
+        break;
+      }
+    }
+
+    dequeued.forEach((val) => this.push(val));
+    return found;
+  }
+
   /**
    * Returns the number of elements in the queue
    * @public

src/minPriorityQueue.d.ts

@@ -12,6 +12,7 @@ export class MinPriorityQueue<T> {
   dequeue(): T;
   pop(): T;
   remove(cb: (value: T) => boolean): T[];
+  contains(cb: (value: T) => boolean): boolean;
   toArray(): T[];
   clear(): void;
   static fromArray<T>(values: T[], getCompareValue?: IGetCompareValue<T>): MinPriorityQueue<T>;

src/minPriorityQueue.js

@@ -104,6 +104,32 @@ class MinPriorityQueue {
     return removed;
   }
 
+  /**
+   * Checks if the queue contains an element that matches a criteria
+   * @public
+   * @param {function} cb
+   * @returns {boolean}
+   */
+  contains(cb) {
+    if (typeof cb !== 'function') {
+      throw new Error('MinPriorityQueue contains expects a callback');
+    }
+
+    let found = false;
+    const dequeued = [];
+    while (!this.isEmpty()) {
+      const popped = this.pop();
+      dequeued.push(popped);
+      if (cb(popped)) {
+        found = true;
+        break;
+      }
+    }
+
+    dequeued.forEach((val) => this.push(val));
+    return found;
+  }
+
   /**
    * Returns the number of elements in the queue
    * @public

src/priorityQueue.d.ts

@@ -12,6 +12,7 @@ export class PriorityQueue<T> {
   dequeue(): T;
   pop(): T;
   remove(cb: (value: T) => boolean): T[];
+  contains(cb: (value: T) => boolean): boolean;
   toArray(): T[];
   clear(): void;
   static fromArray<T>(values: T[], compare: ICompare<T>): PriorityQueue<T>;

src/priorityQueue.js

@@ -105,6 +105,32 @@ class PriorityQueue {
     return removed;
   }
 
+  /**
+   * Checks if the queue contains an element that matches a criteria
+   * @public
+   * @param {function} cb
+   * @returns {boolean}
+   */
+  contains(cb) {
+    if (typeof cb !== 'function') {
+      throw new Error('PriorityQueue contains expects a callback');
+    }
+
+    let found = false;
+    const dequeued = [];
+    while (!this.isEmpty()) {
+      const popped = this.pop();
+      dequeued.push(popped);
+      if (cb(popped)) {
+        found = true;
+        break;
+      }
+    }
+
+    dequeued.forEach((val) => this.push(val));
+    return found;
+  }
+
   /**
    * Returns the number of elements in the queue
    * @public

test/PriorityQueue.test.js

@@ -108,6 +108,15 @@ describe('PriorityQueue', () => {
     });
   });
 
+  describe('contains', () => {
+    it('checks if the queue contains an element', () => {
+      const maxQ = new PriorityQueue(charComparator);
+      charValues.forEach((value) => maxQ.push(value));
+      expect(maxQ.contains((c) => c.id === 'z')).to.equal(true);
+      expect(maxQ.contains((c) => c.id === 'y')).to.equal(false);
+    });
+  });
+
   describe('remove', () => {
     it('remove elements that match a criteria', () => {
       const testArr = [20, 30, 40, 50, 80, 90];

test/maxPriorityQueue.test.js

@@ -107,6 +107,15 @@ describe('MaxPriorityQueue', () => {
       });
     });
 
+    describe('contains', () => {
+      it('checks if the queue contains an element', () => {
+        const testArr = [90, 80, 50, 40, 30, 20];
+        const qTest = MaxPriorityQueue.fromArray(testArr.slice());
+        expect(qTest.contains((n) => n === 50)).to.equal(true);
+        expect(qTest.contains((n) => n === 100)).to.equal(false);
+      });
+    });
+
     describe('remove', () => {
       it('remove elements that match a criteria', () => {
         const testArr = [20, 30, 40, 50, 80, 90];

test/minPriorityQueue.test.js

@@ -103,6 +103,15 @@ describe('MinPriorityQueue', () => {
       });
     });
 
+    describe('contains', () => {
+      it('checks if the queue contains an element', () => {
+        const testArr = [90, 80, 50, 40, 30, 20];
+        const qTest = MinPriorityQueue.fromArray(testArr.slice());
+        expect(qTest.contains((n) => n === 50)).to.equal(true);
+        expect(qTest.contains((n) => n === 100)).to.equal(false);
+      });
+    });
+
     describe('remove', () => {
       it('remove elements that match a criteria', () => {
         const testArr = [20, 30, 40, 50, 80, 90];