Question

我有3个阵列。

Array 1 = {1,1,1,1,2,2,3,3}
Array 2 = {a,a,a,a,e,e,b,b}
Array 3 = {z,z,z,z,z,z,z,z}

我想从数组1中删除所有重复项，并在其他数组中的所述副本中删除相同的元素，以使它们保持正确链接。

我知道你可以使用.Distinct（）。ToArray（）为一个数组执行此操作，但其他数组也不会删除元素。

结果看起来像这样。

Array 1 = {1,2,3}
Array 2 = {a,e,b}
Array 3 = {z,z,z}

我猜测解决这个问题的唯一方法是：

For(int a = 0; a < Array1.count; a++) {
    For(int b = a + 1; b < Array1.count; b++) {
      if(Array1[a]==Array1[b]) {
        Array1.RemoveAt(b);
        Array2.RemoveAt(b);
        Array3.RemoveAt(b);
      }
    }
}

很高兴能找到一个简单的预定义函数！

Answer 1

var distinctIndexes = array1
    .Select((item, idx) => new { Item = item, Index = idx })
    .GroupBy(p => p.Item)
    .Select(grp => grp.First().Index);

var result1 = distinctIndexes.Select(i => array1[i]).ToArray();
var result2 = distinctIndexes.Select(i => array2[i]).ToArray();
var result3 = distinctIndexes.Select(i => array3[i]).ToArray();

注意，这不一定使用第一个数组中的第一个唯一元素。如果需要，可以将索引计算为

var distinctIndexes = array1
    .Select((item, idx) => new { Item = item, Index = idx })
    .Aggregate(new Dictionary<int, int>(), (dict, i) =>
    {
        if (! dict.ContainsKey(i.Item))
        {
            dict[i.Item] = i.Index;
        }
        return dict;
    })
    .Values;

Answer 2

您应该仔细考虑您正在使用的数据结构。这种“移除”操作是否可能同时发生？多常？（我不是要挑战你对Array的使用，只是一般性的提示，但你的场景似乎很奇怪）。此外，您没有解释这是基于索引的删除还是基于元素的删除。如果我正在实现这一点，我很想创建一个新的数组，并将所有剩余的元素添加到循环中的新数组中，忽略要删除的元素。然后只需用'='重新分配引用。当然，这取决于数组的最大预期大小，因为像我建议的副本会占用更多内存（通常不会有问题）。

Answer 3

我真的不知道一个干净的方式来做你所要求的，但这是做你问的一个通用的例子吗？

static void RemoveDupes(ref Array a1, ref Array a2, ref Array a3)
{
    Type a1t, a2t, a3t;
    int newLength, ni, oi;
    int[] indices;

    a1t = a1.GetType().GetElementType();
    a2t = a1.GetType().GetElementType();
    a3t = a1.GetType().GetElementType();


    Dictionary<object, List<int>> buckets = new Dictionary<object, List<int>>();
    for (int i = 0; i < a1.Length; i++)
    {
        object val = a1.GetValue(i);
        if (buckets.ContainsKey(val))
            buckets[val].Add(i);
        else
            buckets.Add(val, new List<int> { i });
    }

    indices = buckets.Where(kvp => kvp.Value.Count > 1).SelectMany(kvp => kvp.Value.Skip(1)).OrderBy(i => i).ToArray();
    newLength = a1.Length - indices.Length;

    Array na1 = Array.CreateInstance(a1t, newLength);
    Array na2 = Array.CreateInstance(a2t, newLength);
    Array na3 = Array.CreateInstance(a3t, newLength);

    oi = 0;
    ni = 0;
    for (int i = 0; i < indices.Length; i++)
    {
        while (oi < indices[i])
        {
            na1.SetValue(a1.GetValue(oi), ni);
            na2.SetValue(a2.GetValue(oi), ni);
            na3.SetValue(a3.GetValue(oi), ni);
            oi++;
            ni++;
        }
        oi++;
    }
    while (ni < newLength)
    {
        na1.SetValue(a1.GetValue(oi), ni);
        na2.SetValue(a2.GetValue(oi), ni);
        na3.SetValue(a3.GetValue(oi), ni);
        oi++;
        ni++;
    }
    a1 = na1;
    a2 = na2;
    a3 = na3;
}

高级删除阵列重复

3 个答案: