Change constructor

Author: dafeng.xdf

README.md

@@ -9,13 +9,24 @@
 
 ### BinaryHeap()
 
+Constructs a new minimum binary heap, Minimum heap is default;
+
+### BinaryHeap(Boolean isMinHeap)
+
 Constructs a new minimum binary heap.
 
+` Parameters: `
+
+* isMinHeap - true to use the order imposed by the given comparator; false to reverse that order
 
-### BinaryHeap(Array comparator)
+### BinaryHeap(Function comparator)
 
 Constructs a new BinaryHeap that will use the given comparator to order its elements.
 
+` Parameters: `
+
+* capacity - the initial capacity for the heap
+
 ### BinaryHeap(Number capacity)
 
 Constructs a new minimum binary heap with the specified initial capacity.
@@ -28,13 +39,14 @@ Constructs a new minimum binary heap with the specified initial capacity.
 
 * IllegalArgumentException - if capacity is <= 0
 
-### BinaryHeap(Number capacity, Array comparator)
+### BinaryHeap(Number capacity, Boolean isMinHeap, Function comparator)
 
 Constructs a new BinaryHeap.
 
 ` Parameters: `
 
 * capacity - the initial capacity for the heap
+* isMinHeap - true to use the order imposed by the given comparator; false to reverse that order
 * comparator - the comparator used to order the elements, null means use natural order
 
 ` Throws: `

lib/BinaryHeap.js

@@ -24,31 +24,54 @@
     /* browser */
     factory(root['BinaryHeap'] || (root['BinaryHeap'] = {}));
   }
-})(this, function(exports, undefined){
+})(this, function(exports, undefined) {
 
   /**
    * @constructor BinaryHeap
    * @param {Number} capacity
+   * @param {Boolean} isMinHeap
    * @param {Array} comparator
    */
   function BinaryHeap() {
     var args = arguments;
     var capacity = Infinity;
-    var comparator;
+    var comparator = function(a, b) {
+      return a - b;
+    };
+    var isMinHeap = true;
 
-    if(args[1]) {
+    if(typeof args[2] !== 'undefined') {
       capacity = args[0];
-      comparator = args[1];
+      isMinHeap = args[1];
+      comparator = args[2];
     }else {
-
-      if(typeof args[0] === 'number') {
-        capacity = args[0];
-      }else if(typeof args[0] === 'object'){
-        comparator = args[0];
+      if(typeof args[1] !== 'undefined') {
+
+        if(typeof args[0] === 'number' && typeof args[1] === 'boolean') {
+          capacity = args[0];
+          isMinHeap = args[1];
+        }else if(typeof args[0] === 'boolean' && typeof args[1] === 'function') {
+          isMinHeap = args[0];
+          comparator = args[1];
+        }else if(typeof args[0] === 'number' && typeof args[1] === 'function') {
+          capacity = args[0];
+          comparator = args[1];
+        }
+      }else {
+
+        if(typeof args[0] === 'number') {
+          capacity = args[0];
+        }else if (typeof args[0] === 'function'){
+          comparator = args[0];
+        }else if(typeof args[0] === 'boolean'){
+          isMinHeap = args[0];
+        }
       }
     }
+
     // create heap
-    this.list = comparator? comparator: [];
+    this.list = [];
+    this.isMinHeap = isMinHeap;
     this.capacity = capacity;
     this.comparator = comparator;
   }
@@ -127,7 +150,7 @@
    */
   proto.peek = function() {
     if(this.isEmpty()) throw('Error: heap is empty.');
-    return this.list[this.list.length - 1];
+    return this.list[0];
   }
 
   /**
@@ -173,6 +196,28 @@
     return !!~this.list.indexOf(object);
   }
 
+  /**
+   * Increases the size of the heap to support additional elements
+   * @method grow
+   */
+  proto.grow = function() {
+    this.capacity ++;
+  }
+
+  /**
+   * Percolates element up heap from from the position given by the index.
+   * @method percolateDown
+   */
+  proto.percolateUp = function(index) {
+  }
+
+  /**
+   * Percolates element down heap from the position given by the index.
+   * @method percolateDown
+   */
+  proto.percolateDown = function(index) {
+  }
+
   exports.BinaryHeap = BinaryHeap;
   exports.version = '0.1.0';
 });

package.json

@@ -18,7 +18,7 @@
     "should": "*"
   },
   "scripts": {
-    "test": "mocha"
+    "test": "mocha test/**/*.js"
   },
   "homepage": "https://github.com/xudafeng/BinaryHeap",
   "author": "xudafeng",

test/BinaryHeap.test.js

@@ -70,8 +70,8 @@ describe('get and peek', function(){
     binaryHeap.add(1);
     binaryHeap.add(2);
     binaryHeap.add(3);
-    binaryHeap.get().should.equal(3);
-    binaryHeap.peek().should.equal(3);
+    binaryHeap.get().should.equal(1);
+    binaryHeap.peek().should.equal(1);
   });
 });
 
@@ -113,3 +113,20 @@ describe('iterator method', function() {
   });
 });
 
+describe('grow method', function() {
+  it('should increases after grow', function() {
+    var binaryHeap = new BinaryHeap(3, [1, 2, 3]);
+    try {
+    }catch(e) {
+      binaryHeap.add(4);
+    }
+    binaryHeap.size().should.equal(3);
+    binaryHeap.grow();
+    try {
+      binaryHeap.add(4);
+      binaryHeap.add(5);
+    }catch(e) {
+    }
+    binaryHeap.size().should.equal(4);
+  });
+});