Javascript 如何对数组进行排序，使其最像一个单位矩阵？

我尝试过许多不同的算法，但都找不到有效的

所以基本上我会有一个矩阵

1 0 1 | 4
7 0 1 | 9
1 1 3 | 3

我想对它进行排序，使它最像单位矩阵

1 0 0
0 1 0
0 0 1

因此，对于上一个矩阵，它将返回

1 0 1 | 4
1 1 3 | 3
7 0 1 | 9

有谁能告诉我一个排序函数可以做到这一点，最好是用javascript

这就是我目前所拥有的

matrix.sort(function(a,b) {
      if (b.indexOf(1)!=-1) {
          var index =  a.indexOf(1)-b.indexOf(1)
          if (index!==0) return index
              else {
                  return b.indexOf(0) - a.indexOf(0)
              }
      }
      else {
          return 0
      }
})

再举几个例子

3  1 -2 | 2
1 -2  1 | 3
2 -1 -3 | 3

会变成

1 -2  1 | 3
3  1 -2 | 2 
2 -1 -3 | 3

-1 -1  3 |  6
 3  1 -2 | -7
 2  2  1 |  9

及

会变成

1 -2  1 | 3
3  1 -2 | 2 
2 -1 -3 | 3

-1 -1  3 |  6
 3  1 -2 | -7
 2  2  1 |  9

---

这与字符串度量非常相似。换句话说，您的算法应该以字符串度量/距离算法为模型，例如

基本上，您的算法需要定义您希望如何对相似性进行排序。 这通常使用“置换”和“匹配”点来完成

什么更接近100-010或000

您应该决定如何对相似性进行排名，然后找到排名最高的集合。

我的最终代码：

    function(matrix) {
            var newmatrix = matrix.slice(0)
            var sorted = []
            var id = identity(newmatrix.length)
            for ( var i = 0; i < id.length; i++ ) {
                    var bestindex;
                    var bestdist = 100
                    for ( var j = 0; j < newmatrix.length; j++ ) {
                            var idstr = id[i].join('')
                            var matstr = newmatrix[j].join('')
                            var newdist = levenshteinDistance(idstr,matstr)
                            if (newdist < bestdist) {
                                    bestdist = newdist
                                    bestindex = j
                            }
                    }
                    sorted[i] = newmatrix[bestindex]
                    newmatrix.splice(bestindex,1)
            }
            return sorted
    }
    function levenshteinDistance(s, t) {
            if (s.length === 0) return t.length;
            if (t.length === 0) return s.length;
            return Math.min(
                    levenshteinDistance(s.substr(1), t) + 1,
                    levenshteinDistance(t.substr(1), s) + 1,
                    levenshteinDistance(s.substr(1), t.substr(1)) + (s[0] !== t[0] ? 1 : 0)
            );
    }
    function identity(n) {
            var id = []
            for ( var i = 0; i < n; i++) {
                    id[i]=[]
                    for (var j = 0; j < n; j++) {
                            id[i][j] = (i===j) ? 1 : 0
                    }
            }
            return id
    }

---

我使用for循环，因为数组开头的项匹配比结尾的项匹配更重要。非常感谢@Etai提供的公式

如果你真的发布了数组，并解释了这些示例之间的关系，这会更容易理解，因为它不是很清楚。最类似于身份矩阵的意思是什么？你只需要对角线上的1和其他地方的0吗。或者矩阵之间的差异应该接近于0？基本上，我正在尝试实现排序行的第一步，很高兴能提供帮助！如果这个答案有用，你介意接受/投票吗？我会的，但我还没有足够的声誉：如果再多一个人投票，我会的。