add .contains (#67)

* add .contains

* readme

* update

README.md

@@ -23,6 +23,7 @@ A heap-based implementation of priority queue in javascript with typescript supp
   * [front](#front)
   * [back](#back)
   * [dequeue (pop)](#dequeue-pop)
+  * [contains](#contains)
   * [remove](#remove)
   * [isEmpty](#isEmpty)
   * [size](#size)
@@ -248,6 +249,16 @@ console.log(bidsQueue.pop()); // { id: 5, value: 12000 }
 console.log(bidsQueue.pop()); // { id: 7, value: 8000 }
 ```
 
+### contains
+checks if the queue contains an element that meet a criteria in O(n*log(n)) runtime.
+
+```js
+carsQueue.contains((car) => car.price === 50000); // true
+carsQueue.contains((car) => car.price === 200000); // false
+numbersQueue.contains((n) => n === 4); // true
+numbersQueue.contains((n) => n === 10); // false
+```
+
 ### remove
 removes all elements that meet a criteria in O(n*log(n)) runtime and returns a list of the removed elements.
 

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];