Question

给定一个用字符串填充的数组。我需要以下行为：

foo = []
foo = add_search_string(foo, 'a')

foo应该等于['a']

foo = add_search_string(foo, 'a')

foo应该等于['a']因为'a'已经是搜索字符串

foo = add_search_string(foo, 'ab')

foo应该等于['ab']，因为'a'是'ab'的子串，因此可以删除

foo = add_search_string(foo, 'a')

由于与上述相同的原因，

foo应该等于['ab']

foo = add_search_string(foo, 'c')

foo应该等于['ab'，'c']

我的功能如下：

function add_search_string(search_strings, new_search_string) {
    var keep = true;
    var new_search_strings = []
    $.each(search_strings, function(i, search_string) {
        if (new_search_string == search_string) {
            keep = false;
        } else if (search_string.indexOf(new_search_string) >= 0) {
            keep = false;
        }
    });

    if (keep) {
        $.each(search_strings, function(i, search_string) {
            if (new_search_string.indexOf(search_string) == -1) {
                new_search_strings.push(search_string);
            }
        });
        new_search_strings.push(new_search_string);
        search_strings = new_search_strings;
    }
    return search_strings;
}

有没有'更好'的方法呢？

Answer 1

如果打算继续更新同一个阵列，我可能会这样做：

function add_search_string(search_strings, new_search_string) {
   var replaced = false;
   for (var i = search_strings.length -1; i >= 0; i--) {
      if (search_strings[i].indexOf(new_search_string) != -1) {
          // string found, so just return
          return search_strings;
      }
      if (new_search_string.indexOf(search_strings[i]) != -1){
          // existing string is a substring of new search string
          // if it already matched another element just remove the current one
          // otherwise replace the current one
          if (replaced)
              search_strings.splice(i,1);
          else
              search_strings[i] = new_search_string;
          replaced = true;
      }
   }
   // if not found add it
   if (!replaced)
      search_strings.push(new_search_string);
   return search_strings;
}

虽然此函数返回数组，但它也会更新您传入的数组，因此您在调用函数时不必将其分配回来，您只需说：

add_search_string(foo, 'a');

Answer 2

没有快速的内置方法来做到这一点。如果你想测试真正的子串而不仅仅是'以'开头'那么它就是一个二次问题，这意味着该函数将占用密钥长度的n ^ 2倍。如果键不是太长，它应该工作。

Answer 3

由于您需要“包含”运算符，因此数组join（）可能是高效的：

var str = search_strings.join("|");

// if the new string can't be found
if str.indexOf(new_search_string)==-1 {
    // remove sub-strings of new_search_string (need to start from the top)
    for (var i=search_strings.length-1;i>=0;i--) {
        if (new_search_string.indexOf(search_strings[i])!=-1) {search_strings.splice(i,1);}
    }
    // add new
    search_strings.push(new_search_string);
}
// else new_search_string can be ignored

为了加快处理速度，您还可以考虑按字符串长度排序或过滤数组，并且只循环遍历比new_search_string短的字符串。

Answer 4

对于高性能实现，您可以使用suffix tree在搜索字符串（及其子集）中快速搜索。但是，只有当你真正遇到一个简单的实现问题时（例如你的或者@nnnnn的），你应该这样做，因为trie会增加一个巨大的复杂层。

在javascript中创建没有冗余的搜索字符串数组

4 个答案: