Nodejs Array Search Binary binarySearch(num)

Here you can find the source of binarySearch(num)

Method Source Code

var input = [ 1, 2, 2, 3, 4, 4, 5, 6, 8, 10 ];

Array.prototype.binarySearch = function(num) {
    var _this = this;

    function search(left, right) {
        if(right < left) return -1;
        else if(left === right) {
            return checkIndexForNum(left);
        }//from   w ww.java 2s.  com

        var mid = Math.floor((left + right) / 2);
        if(num > _this[mid]) {
            return search(mid + 1, right);
        } else if(num < _this[mid]) {
            return search(left, mid - 1);
        } else {
            return checkIndexForNum(mid);
        }
    }

    function checkIndexForNum(index) {
        if(_this[index] === num) {
            return index;
        } else {
            return -1;
        }
    }

    return search(0, this.length - 1);
};

console.log(input.binarySearch(-1));
console.log(input.binarySearch(8));
console.log(input.binarySearch(4));
console.log(input.binarySearch(0));
console.log(input.binarySearch(10000));

Related

  1. binSearch(data)
    Array.prototype.binSearch = function(data) {
      var first = 0;
      var last = this.length - 1;
      while(first <= last) {
        var mid = Math.floor((first + last) / 2);
        if(this[mid] < data) {
          first = mid + 1;
        else if(this[mid] > data) {
    ...
    
  2. binaryIndexOf(searchElement)
    function binaryIndexOf(){
    Array.prototype.binaryIndexOf = function(searchElement) {
        var minIndex = 0;
        var maxIndex = this.length - 1;
        var currentIndex;
        var currentElement;
        while (minIndex <= maxIndex) {
            currentIndex = Math.floor((minIndex + maxIndex) / 2);
            currentElement = this[currentIndex];
    ...
    
  3. binaryIndexOfbinaryIndexOf;
    function binaryIndexOf(searchElement, map) {
      'use strict';
      if (map === undefined) map = index => this[index]
      var minIndex = 0;
      var maxIndex = this.length - 1;
      var currentIndex;
      var currentElement;
      var resultIndex;
      while (minIndex <= maxIndex) {
    ...
    
  4. binarySearch(n)
    "use strict";
    var assert = require('assert'); 
    Array.prototype.binarySearch = function(n) {
      var O = Object(this);
      var f = function(lo,hi) {
        var mid = Math.floor((lo + hi) / 2);
        if (O[mid] === n) {
          return mid;
        if (lo === mid || hi === mid) {
          return -(mid+1);
        if(O[mid] < n) {
          return f(mid,hi);
        if (O[mid] > n) {
          return f(lo,mid);
      };
      return f(0, O.length);
    };
    describe('binary search', function() {
      it('doesnt find anything in an empty list', function() {
        assert.equal(-1, [].binarySearch(7));
      });
      it('finds a single element', function() {
        assert.equal(0, [0].binarySearch(0));
      });
      it('finds the middle element', function() {
        assert.equal(1, [1,2,3].binarySearch(2));
      });
      it('finds up', function() {
        assert.equal(2, [1,2,3].binarySearch(3));
      });
      it('finds down', function() {
        assert.equal(0, [1,2,3].binarySearch(1));
      });
      it('finds insertion index', function() {
        assert.equal(-2, [1,2,4,5,6].binarySearch(3));
      });
    });
    
  5. binarySearch(searchElement)
    Array.prototype.binarySearch = function (searchElement) {
        'use strict';
        var minIndex = 0;
        var maxIndex = this.length - 1;
        var currentIndex;
        var currentElement;
        while (minIndex <= maxIndex) {
            currentIndex = (minIndex + maxIndex) / 2 | 0;
            currentElement = this[currentIndex];
    ...
    
  6. binarySearch(val)
    Array.prototype.binarySearch = function(val){
      var min = 0;
      var max = this.length -1;
      var currentIndex;
      var currentElement;
      while (min <= max) {
        currentIndex = Math.floor((min +max) / 2);
        currentElement = this[currentIndex];
        if (currentElement > val) {
    ...
    
  7. binarySearch(val)
    Array.prototype.binarySearch = function(val){
      var keeper = 0;
      var answer = -1;
      function recursive(arr){
        var len = arr.length;
        var start = Math.floor(len / 2);
        var current = arr[start];
        if (current === val){
          answer = start + keeper;
    ...
    
  8. binarySearch(value)
    Array.prototype.binarySearch = function(value) {
        'use strict';
        if(!value){
            return null;
        var left = 0,
            right = this.length-1,
            find = false,
            middle = null;
    ...