Javascriptで最高のパフォーマンスで「レーベンシュタイン距離」で配列をソートします
だから私は名前のランダムなJavaScript配列を持っています...
[@ larry、@ nicholas、@ notch]など。
それらはすべて@記号で始まります。リストの一番上にあるものが検索語に最も近くなるように、レーベンシュタイン距離で並べ替えたいと思います。現時点では、jQueryの.grep()を使用するjavascriptがあり、キーを押したときに入力された検索用語の周りにjavascript .match()メソッドを使用しています。
（最初の公開以降に編集されたコード）
_limitArr = $.grep(imTheCallback, function(n){
return n.match(searchy.toLowerCase())
});
modArr = limitArr.sort(levenshtein(searchy.toLowerCase(), 50))
if (modArr[0].substr(0, 1) == '@') {
if (atRes.childred('div').length < 6) {
modArr.forEach(function(i){
atRes.append('<div class="oneResult">' + i + '</div>');
});
}
} else if (modArr[0].substr(0, 1) == '#') {
if (tagRes.children('div').length < 6) {
modArr.forEach(function(i){
tagRes.append('<div class="oneResult">' + i + '</div>');
});
}
}
$('.oneResult:first-child').addClass('active');
$('.oneResult').click(function(){
window.location.href = 'http://hashtag.ly/' + $(this).html();
});
_また、配列にハッシュタグ（＃）またはメンション（@）が含まれているかどうかを検出するifステートメントもあります。無視してください。 imTheCallbackはハッシュタグまたはメンションの名前の配列であり、modArrはソートされた配列です。次に、_.atResults_および_.tagResults_要素は、配列内の各時刻に追加される要素です。これは、入力された検索語に基づいて名前のリストを形成します。
I also Levenshtein Distanceアルゴリズムがあります：
_var levenshtein = function(min, split) {
// Levenshtein Algorithm Revisited - WebReflection
try {
split = !("0")[0]
} catch(i) {
split = true
};
return function(a, b) {
if (a == b)
return 0;
if (!a.length || !b.length)
return b.length || a.length;
if (split) {
a = a.split("");
b = b.split("")
};
var len1 = a.length + 1,
len2 = b.length + 1,
I = 0,
i = 0,
d = [[0]],
c, j, J;
while (++i < len2)
d[0][i] = i;
i = 0;
while (++i < len1) {
J = j = 0;
c = a[I];
d[i] = [i];
while(++j < len2) {
d[i][j] = min(d[I][j] + 1, d[i][J] + 1, d[I][J] + (c != b[J]));
++J;
};
++I;
};
return d[len1 - 1][len2 - 1];
}
}(Math.min, false);
_アルゴリズム（または同様のもの）を現在のコードに組み込んで、パフォーマンスを低下させることなくソートするにはどうすればよいですか？
更新：
だから、私は現在、James WestgateのLev Dist関数を使用しています。 WAYYYYは高速で動作します。パフォーマンスが解決されたため、問題はソースで使用しています...
_modArr = limitArr.sort(function(a, b){
levDist(a, searchy)
levDist(b, searchy)
});
_私の問題は、.sort()メソッドの使用に関する一般的な理解です。ヘルプ、感謝します。
ありがとう！
数年前にインラインスペルチェッカーを作成し、Levenshteinアルゴリズムを実装しました。これはインラインであり、IE8ではかなりのパフォーマンス最適化を行ったためです。
var levDist = function(s, t) {
var d = []; //2d matrix
// Step 1
var n = s.length;
var m = t.length;
if (n == 0) return m;
if (m == 0) return n;
//Create an array of arrays in javascript (a descending loop is quicker)
for (var i = n; i >= 0; i--) d[i] = [];
// Step 2
for (var i = n; i >= 0; i--) d[i][0] = i;
for (var j = m; j >= 0; j--) d[0][j] = j;
// Step 3
for (var i = 1; i <= n; i++) {
var s_i = s.charAt(i - 1);
// Step 4
for (var j = 1; j <= m; j++) {
//Check the jagged ld total so far
if (i == j && d[i][j] > 4) return n;
var t_j = t.charAt(j - 1);
var cost = (s_i == t_j) ? 0 : 1; // Step 5
//Calculate the minimum
var mi = d[i - 1][j] + 1;
var b = d[i][j - 1] + 1;
var c = d[i - 1][j - 1] + cost;
if (b < mi) mi = b;
if (c < mi) mi = c;
d[i][j] = mi; // Step 6
//Damerau transposition
if (i > 1 && j > 1 && s_i == t.charAt(j - 2) && s.charAt(i - 2) == t_j) {
d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + cost);
}
}
}
// Step 7
return d[n][m];
}
私はこの解決策に来ました：
var levenshtein = (function() {
var row2 = [];
return function(s1, s2) {
if (s1 === s2) {
return 0;
} else {
var s1_len = s1.length, s2_len = s2.length;
if (s1_len && s2_len) {
var i1 = 0, i2 = 0, a, b, c, c2, row = row2;
while (i1 < s1_len)
row[i1] = ++i1;
while (i2 < s2_len) {
c2 = s2.charCodeAt(i2);
a = i2;
++i2;
b = i2;
for (i1 = 0; i1 < s1_len; ++i1) {
c = a + (s1.charCodeAt(i1) === c2 ? 0 : 1);
a = row[i1];
b = b < a ? (b < c ? b + 1 : c) : (a < c ? a + 1 : c);
row[i1] = b;
}
}
return b;
} else {
return s1_len + s2_len;
}
}
};
})();
こちらもご覧ください http://jsperf.com/levenshtein-distance/12
一部のアレイの使用を排除することにより、ほとんどの速度が得られました。
更新： http://jsperf.com/levenshtein-distance/5
新しい改訂版は、他のすべてのベンチマークを全滅させます。 IE8/9/10テスト環境がないため、特にChromium/Firefoxのパフォーマンスを追いかけてきましたが、最適化は一般的にほとんどのブラウザーに適用されるはずです。
レーベンシュタイン距離
レーベンシュタイン距離を実行するマトリックスは、何度も再利用できます。これは最適化の明らかなターゲットでした（ただし、これは文字列の長さに制限を課します（マトリックスを動的にサイズ変更する場合を除きます））。
JsPerf Revision 5で追求されていない最適化の唯一のオプションは、メモ化です。レーベンシュタイン距離の使用に応じて、これは大幅に役立つ可能性がありますが、実装固有の性質のために省略されました。
// Cache the matrix. Note this implementation is limited to
// strings of 64 char or less. This could be altered to update
// dynamically, or a larger value could be used.
var matrix = [];
for (var i = 0; i < 64; i++) {
matrix[i] = [i];
matrix[i].length = 64;
}
for (var i = 0; i < 64; i++) {
matrix[0][i] = i;
}
// Functional implementation of Levenshtein Distance.
String.levenshteinDistance = function(__this, that, limit) {
var thisLength = __this.length, thatLength = that.length;
if (Math.abs(thisLength - thatLength) > (limit || 32)) return limit || 32;
if (thisLength === 0) return thatLength;
if (thatLength === 0) return thisLength;
// Calculate matrix.
var this_i, that_j, cost, min, t;
for (i = 1; i <= thisLength; ++i) {
this_i = __this[i-1];
for (j = 1; j <= thatLength; ++j) {
// Check the jagged ld total so far
if (i === j && matrix[i][j] > 4) return thisLength;
that_j = that[j-1];
cost = (this_i === that_j) ? 0 : 1; // Chars already match, no ++op to count.
// Calculate the minimum (much faster than Math.min(...)).
min = matrix[i - 1][j ] + 1; // Deletion.
if ((t = matrix[i ][j - 1] + 1 ) < min) min = t; // Insertion.
if ((t = matrix[i - 1][j - 1] + cost) < min) min = t; // Substitution.
matrix[i][j] = min; // Update matrix.
}
}
return matrix[thisLength][thatLength];
};
ダメラウ-レーベンシュタイン距離
jsperf.com/damerau-levenshtein-distance
Damerau-Levenshtein Distanceは、レーベンシュタイン距離をわずかに変更したもので、転置を含みます。最適化することはほとんどありません。
// Damerau transposition.
if (i > 1 && j > 1 && this_i === that[j-2] && this[i-2] === that_j
&& (t = matrix[i-2][j-2]+cost) < matrix[i][j]) matrix[i][j] = t;
ソートアルゴリズム
この答えの2番目の部分は、適切なソート関数を選択することです。最適化されたソート関数を http://jsperf.com/sort にアップロードします。
まだ必要な場合は、Levenshtein距離計算の非常に高性能な実装を実装しました。
function levenshtein(s, t) {
if (s === t) {
return 0;
}
var n = s.length, m = t.length;
if (n === 0 || m === 0) {
return n + m;
}
var x = 0, y, a, b, c, d, g, h, k;
var p = new Array(n);
for (y = 0; y < n;) {
p[y] = ++y;
}
for (; (x + 3) < m; x += 4) {
var e1 = t.charCodeAt(x);
var e2 = t.charCodeAt(x + 1);
var e3 = t.charCodeAt(x + 2);
var e4 = t.charCodeAt(x + 3);
c = x;
b = x + 1;
d = x + 2;
g = x + 3;
h = x + 4;
for (y = 0; y < n; y++) {
k = s.charCodeAt(y);
a = p[y];
if (a < c || b < c) {
c = (a > b ? b + 1 : a + 1);
}
else {
if (e1 !== k) {
c++;
}
}
if (c < b || d < b) {
b = (c > d ? d + 1 : c + 1);
}
else {
if (e2 !== k) {
b++;
}
}
if (b < d || g < d) {
d = (b > g ? g + 1 : b + 1);
}
else {
if (e3 !== k) {
d++;
}
}
if (d < g || h < g) {
g = (d > h ? h + 1 : d + 1);
}
else {
if (e4 !== k) {
g++;
}
}
p[y] = h = g;
g = d;
d = b;
b = c;
c = a;
}
}
for (; x < m;) {
var e = t.charCodeAt(x);
c = x;
d = ++x;
for (y = 0; y < n; y++) {
a = p[y];
if (a < c || d < c) {
d = (a > d ? d + 1 : a + 1);
}
else {
if (e !== s.charCodeAt(y)) {
d = c + 1;
}
else {
d = c;
}
}
p[y] = d;
c = a;
}
h = d;
}
return h;
}
同様のSO質問 最速の汎用レーベンシュタインJavascript実装
更新
上記の改良版がgithub/npmにあります https://github.com/gustf/js-levenshtein をご覧ください
@James Westgateの回答にあるような、より良いレーベンシュタインの方法を使用することをお勧めします。
そうは言っても、DOM操作は多くの場合大きな費用です。 jQueryの使用を確実に改善できます。
上記の例ではループはかなり小さくなっていますが、各oneResultに対して生成されたhtmlを単一の文字列に連結し、ループの最後で1つのappendを実行する方がはるかに効率的です。
セレクターが遅い。 $('.oneResult')は、DOMのall要素を検索し、古いIEブラウザーでclassNameをテストします。検索の範囲を決めるために、atRes.find('.oneResult')のようなものを検討することができます。
clickハンドラーを追加する場合、すべてのkeyupにハンドラーを設定しないようにすることをお勧めします。 atRestハンドラーを設定している同じブロック内のすべての結果に対してkeyupに単一のハンドラーを設定することにより、イベントの委任を活用できます。
atRest.on('click', '.oneResult', function(){
window.location.href = 'http://hashtag.ly/' + $(this).html();
});
詳細については、 http://api.jquery.com/on/ を参照してください。
これを行う明白な方法は、各文字列を（距離、文字列）のペアにマッピングし、このリストをソートしてから、距離を再度ドロップすることです。この方法では、レベンシュタイン距離を一度だけ計算する必要があります。重複を最初にマージすることもできます。
新しいリビジョンを書きました： http://jsperf.com/levenshtein-algorithms/16
function levenshtein(a, b) {
if (a === b) return 0;
var aLen = a.length;
var bLen = b.length;
if (0 === aLen) return bLen;
if (0 === bLen) return aLen;
var len = aLen + 1;
var v0 = new Array(len);
var v1 = new Array(len);
var i = 0;
var j = 0;
var c2, min, tmp;
while (i < len) v0[i] = i++;
while (j < bLen) {
c2 = b.charAt(j++);
v1[0] = j;
i = 0;
while (i < aLen) {
min = v0[i] - (a.charAt(i) === c2 ? 1 : 0);
if (v1[i] < min) min = v1[i];
if (v0[++i] < min) min = v0[i];
v1[i] = min + 1;
}
tmp = v0;
v0 = v1;
v1 = tmp;
}
return v0[aLen];
}
このリビジョンは、他のリビジョンよりも高速です。 IE =）でも動作します