javascript中的模式匹配搜索答案

【问题标题】：Pattern Matching Search in javascriptjavascript中的模式匹配搜索
【发布时间】：2017-03-10 07:38:05
【问题描述】：

我正在尝试在 javascript 中使用模式匹配进行二进制搜索。但问题是它在许多情况下都失败了。

我已经尝试过这段代码。

function binarySearch(ar, el, compare_fn) {
    var m = 0;
    var n = ar.length - 1;
    while (m <= n) {
        var k = parseInt((n + m) / 2);
        var cmp = compare_fn(el, ar[k]);
        if (cmp > 0) {
            m = k + 1;
            console.log(cmp,m,ar[m],k)
        } else if(cmp < 0) {
            n = k - 1;
             console.log(cmp,n,ar[n],k)
        } else {
            return k;
        }
    }
    return -m - 1;
}

function compare_number(a, b) {
  var regExp = new RegExp(a, 'gi');
  var match= (regExp.test(b)?0:1);
  if(match){
     match=a.localeCompare(b);
  }
  return(match);
}

new function test() {
  var ar = ["job0000ya","job0002","job003","hello","myui",]; 
  var n = binarySearch(ar, "ya", compare_number);
     console.log([n]);
}();

但似乎对于这种特殊情况它失败了。建议我可以使它成为可能。

【问题讨论】：

顺便说一句，new 不是启动 IIFE 的推荐关键字。更好地使用void。这会强制表达式进行评估。
可能是，在这种情况下，搜索不起作用，因为二进制排序需要排序的数据和返回较小/相等/较大值的函数，但它不适用于 a 内部的部分字符串，带有正则表达式，而不是两个字符串之间的比较，并且缺少限定哪个字符串先出现或后出现。
有什么建议可以实现这个吗？
实际上不是用于在数组中搜索字符串的一部分。在这种情况下，您可以只迭代数组中的每个项目。二进制搜索不适合这里。
问题是我的数据结构包含超过一万条记录。如果我按照班轮搜索，我会减慢我的申请速度：（

标签： javascript algorithm search binary-search

【解决方案1】：

//The binary search algorithm
var binarySearch = (function() {
  /**
   * compare_complex
   *
   * @param {(number | string)} a
   * @param {(number | string)} b
   * @returns {number}
   */
  function compare_complex(a, b) {
    return a.toString().localeCompare(b.toString());
  }
  /**
   * compare_number
   *
   * @param {number} a
   * @param {number} b
   * @returns {number}
   */
  function compare_number(a, b) {
    return a - b;
  }
  /**
   * binarySearch
   *
   * @param {IBinarySearch} [args={ list: [], target: '' }]
   * @returns {number}
   */
  function binarySearch(args) {
    if (args === void 0) {
      args = {
        list: [],
        target: ''
      };
    }
    var params = {
      list: [],
      target: '',
      searchThreshold: 10,
      complex: false
    };
    for (var key in args) {
      if (args.hasOwnProperty(key) && params.hasOwnProperty(key)) {
        params[key] = args[key];
      }
    }
    var max = params.list.length - 1;
    var min = 0;
    if (params.list[min] == params.target) {
      return min;
    }
    if (params.list[max] == params.target) {
      return max;
    }
    var compare = (params.complex === true ? compare_complex : compare_number);
    while (max - min >= params.searchThreshold) {
      var diff = max - Math.floor((max - min) / 2);
      var cmp = compare(params.list[diff], params.target);
      if (cmp == 0) {
        return diff;
      } else if (cmp < 0) {
        min = diff;
      } else {
        max = diff;
      }
    }
    return params.list.slice(min, max).indexOf(params.target) + min;
  }
  return binarySearch;
})();
//------------SIMULATION------------//
//Global compare function for sorting
function compare_complex(a, b) {
  return a.toString().localeCompare(b.toString());
}
//Test array
var arr = [];
//Minimum test array length
var arrLength = 1000000;
//Populate
while (arr.length < arrLength) {
  arr = arr.concat(arr, ["job0000ya", "job0002", "job003", "hello", "myui"]);
}
//Target to find in haystack
var target = "job033";
//Add target to list
arr.push(target);
//Sort list (must be done before search)
arr = arr.sort(compare_complex);
//Actual test
setTimeout(function() {
  console.log("Looking for:", target, "among", arr.length, "rows");
  var t = Date.now();
  console.log("Result at index:", binarySearch({
    list: arr,
    target: target,
    complex: true
  }));
  console.log("Time(ms):", Date.now() - t);
  var index = binarySearch({
    list: arr,
    target: target,
    complex: true
  });
  console.log("5 nearest elements:", arr.slice(index - 2, index + 3));
}, 1000);

【讨论】：