Nodejs Array Search Binary binarySearch(searchElement)

Here you can find the source of binarySearch(searchElement)

Method Source Code

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

        if (currentElement < searchElement) {
            minIndex = currentIndex + 1;
        }//  w ww .j a v a 2  s.  c o  m
        else if (currentElement > searchElement) {
            maxIndex = currentIndex - 1;
        }
        else {
            return currentIndex;
        }
    }

    return -1;
}

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(num)
    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);
            var mid = Math.floor((left + right) / 2);
    ...
    
  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;
    ...
    
  9. binarySearch(value)
    Array.prototype.binarySearch = function(value){
        var items = this;
        console.log(items.length);
        var startIndex  = 0;
        var stopIndex = items.length - 1;
        var middle = Math.floor((stopIndex + startIndex)/2);
        while(items[middle] != value && startIndex < stopIndex){
            if (value < items[middle]){
                stopIndex = middle - 1;
    ...