C# 确定阵列与目标阵列的距离

我正在做一个小实验来增加我的知识，我已经达到了一个我觉得我可以真正优化它的程度，但我不太确定如何做到这一点

我有许多数字数组。（为了简单起见，假设每个数组有4个数字：1、2、3和4）

• 目标是将所有数字按升序排列（即， 1-2-3-4），但这些数字都在不同的数组中被置乱

• 数字越大，权重越高

• 我需要对所有这些数组进行排序，按照它们与 目标

也就是说，4-3-2-1可能是最坏的情况

一些例子：

3-4-2-1 is better than 4-3-2-1
2-3-4-1 is better than 1-4-3-2 (even though two numbers match (1 and 3). 
                                the biggest number is closer to its spot.)

所以大数字总是优先于小数字。以下是我的尝试：

        var tmp = from m in moves
                  let mx = m.Max()
                  let ranking = m.IndexOf(s => s == mx)
                  orderby ranking descending
                  select m;

        return tmp.ToArray();

在上面的示例中，p.S IndexOf是我编写的一个扩展，用于获取数组和表达式，并返回满足表达式的元素的索引。这是必要的，因为情况确实有点复杂，我用我的例子来简化它

不过，我在这里尝试的问题是，它只会按最大的数字排序，而会忘记所有其他数字。它应该按照最大的数字排在第一位，然后是第二位，然后是第三位

此外，由于它将在几分钟内反复执行此操作，因此应尽可能提高效率。

我希望这会有所帮助

var i = 0;
var temp = (from m in moves select m).ToArray();
do
{
  temp = (from m in temp
         orderby m[i] descending
         select m).ToArray();
}
while (++i < moves[0].Length);

var i=0；
var temp=（从移动中的m选择m）.ToArray（）；
做
{
温度=（从温度中的m开始）
按m[i]降序排序
选择m）.ToArray（）；
}
而（++i<移动[0]。长度）；

您可以实现气泡排序，并计算移动数据的次数。在远离理想排序的阵列上，数据移动的数量将很大

int GetUnorderedness<T>(T[] data) where T : IComparable<T>
{
    data = (T[])data.Clone(); // don't modify the input data, 
                              // we weren't asked to actually sort.
    int swapCount = 0;
    bool isSorted;
    do
    {
        isSorted = true;
        for(int i = 1; i < data.Length; i++)
        {
            if(data[i-1].CompareTo(data[i]) > 0)
            {
                T temp = data[i];
                data[i] = data[i-1];
                data[i-1] = temp;
                swapCount++;
                isSorted = false;
            }
        }
    } while(!isSorted);
}

int GetUnorderedness（T[]数据），其中T:i可比较
{
data=（T[]）data.Clone（）；//不要修改输入数据，
//我们没有被要求实际分类。
int swapCount=0；
布尔被分类；
做
{
isSorted=true；
for（int i=1；i0
{
T temp=数据[i]；
数据[i]=数据[i-1]；
数据[i-1]=温度；
swapCount++；
isSorted=假；
}
}
}而（！isSorted）；
}

根据示例数据，这将给出与您指定的结果稍有不同的结果

一些示例案例：
3-4-2-1比4-3-2-1好
2-3-4-1比1-4-3-2好

3-4-2-1

需要5个掉期进行排序，

4-3-2-1

需要6个掉期进行排序，这样就可以了。

2-3-4-1

将取3，

1-4-3-2

也将取3，因此这与您的预期结果不匹配

这个算法没有把最大的数字当作最重要的，这似乎是你想要的；所有数字都被平等对待。从你的描述中，你会认为<代码> 2-1-3-4<代码>比<代码> 1-2-4-3好得多，因为第一个在它们的适当位置都有最大和第二个最大的数字。这个算法会考虑这两个相等，因为每个只需要1个交换来排序数组。

---

此算法的优点在于，它不仅仅是一个比较算法，每个输入都有一个离散的输出，因此您只需为每个输入数组运行一次算法。

如果使用反向迭代并计算swapcount*值的倍数，则应正确加权第二个示例。很明显，会有一些样本产生冲突并返回相同的结果。我最终给出了自己的解决方案，但我会接受它，因为它很有创意，而且我很喜欢：）