从一个数组中删除其索引存在于另一个数组中的元素

Question

一个包含 N 个对象的数组 A1。另一个数组 A2 包含表示第一个数组的索引的数字。您需要从 A1 中删除 A2 中存在索引的元素并生成压缩数组。例如：

A1 = [ a, b, c, d, e, f, g ] // N elements and N is large
A2 = [ 5, 1 ] // k elements and k is small (and constant)
Answer = [ a, c, d, e, g, _, _ ]

我写的 C# 代码如下：

public class CompactingArray
{
    private Compact(array A1 , array A2)
    {
        var hash = new Hashset<int>(A2);
        foreach(int c in hash)
        {
            A1.remove(c,1);
        }

        Console.WriteLine(A1);
    }
}

我需要 O(n) 复杂度代码并且不使用任何内置函数。请建议一个不使用任何内置函数的 C# 代码。

Answer 1

如果k，A2 中的元素个数是“小而恒定”，那么一个 O(N*k) 复杂度的普通算法（对于A1 中的每个元素，看看它的索引是否在A2) 将被视为线性：

int writingPosition = 0;
for (int i = 0 ; i != N ; i++) {
    boolean found = false;
    // Since k is constant, this loop is considered constant-time
    for (int j = 0 ; j != k ; j++) {
        if (A2[j] == i) {
            found = true;
            break;
        }
    }
    if (!found) {
        A1[writingPosition++] = A1[i];
    }
}
while (writingPosition != N) {
    A1[writingPosition++] = "_";
}

但是，这不是最佳选择。为了提高性能，您可以对A2 进行排序（对其进行排序是一个恒定时间操作）。对A2 进行排序后，您可以创建一个int current=0，一个指向A2 的索引，然后将A1 数组从零遍历到N，并跳过来自A2[current] 的索引。在循环到N 的每次迭代中，您只需要查看“A2”的一个元素，因此总体上该算法也是线性的。

实现与上述类似，但不是使用嵌套循环并检查if (!found)，而是检查A2[current] == i，并相应地调整current。

Answer 2

这里是解决方案。

        Char[] A1 = { 'a', 'b', 'c', 'd', 'e', 'f', 'g' };
        int[] A2 = { 5, 1 };

        int k = A2.Length;

        int N = A1.Length;

        for (int i = 0; i < k; i++)
        {
            A1[A2[i]] = '\0'; // place null charcater here
        }

        Char[] copy = new char[N];

        for (int i = 0,j=0; i < N; i++) // place all values in sorted order
        {
            if (A1[i] != '\0')
                copy[j++] = A1[i];
        }
        for (int i = (N-k); i < N;i++ )
        {
            copy[i] = '-';
        }
        Console.WriteLine(copy);

Answer 3

结果数组的顺序重要吗？如果没有，您可以围绕以下几行做一些事情：

char[] a = { 'a', 'b', 'c', 'd', 'e', 'f', 'g' };
int[] z = { 5, 1 };

int zlen = z.Length;
int amax = a.Length - 1;

for (int i = 0; i < zlen; i++)
    a[z[i]] = a[amax - i];

最后，您必须调整结果数组（a 本身）的大小，以从数组末尾删除 zlen 元素。该解决方案只是将要删除的元素冒泡到数组的末尾。无需顺序移除。添加对索引边界等的适当检查。

Answer 4

如果A2 已排序，则O(n) 的复杂性是可能的，因为这样你就可以只用一个循环来单独索引每个数组：

var A1 = new string[] { "a", "b", "c", "d", "e", "f", "g" }; // N elements and N is large

var A2 = new int[] { 1, 5 }; // k elements and k is small (and constant)

A2 = A2.OrderBy(x => x).ToArray();

var A3 = new string[A1.Length];

int m = 0; // To check it runs only n times.
int leftItemCount = A1.Length - A2.Length;
for (int i = 0, j = 0, k = 0, l = leftItemCount; i < leftItemCount || m < items.Length; i++)
{
    m++;
    if (j < A2.Length && k == A2[j])
    {
        j++;
        k++;
        A3[l++] = "_";
        i--;
        continue;
    }
    A3[i] = A1[k];
    k++;
}

// Answer = [ a, c, d, e, g, _, _ ] for { 1, 5 }
// Answer = [ a, d, e, g, _, _, _ ] for { 1, 2, 5 }

---

测试代码：

static void ArrayTests()
{
    // Item array lengths.
    for (int i = 45; i < 256; i++)
    {
        var items = Enumerable.Range(0, i).Select(x => x.ToString()).ToArray();

        // Number of tests per array.
        for (int j = 0; j < 100; j++)
        {
            // Items to remove.
            Random rnd = new Random(DateTime.Now.Millisecond);
            var remove = new int[rnd.Next(1, i)];
            HashSet<int> indexes = new HashSet<int>();
            for (int k = 0; k < remove.Length; k++)
            {
                int index = 0;
                do
                {
                    index = rnd.Next(0, i);
                } while (indexes.Contains(index));
                indexes.Add(index);
                remove[k] = index;
            }
            remove = remove.OrderBy(x => x).ToArray();
            var result = ArrayTest(items, remove);
        }
    }
}

static string[] ArrayTest(string[] items, int[] remove)
{
    var A3 = new string[items.Length];

    int m = 0;
    int leftItemCount = items.Length - remove.Length;
    for (int i = 0, j = 0, k = 0, l = leftItemCount; i < leftItemCount || m < items.Length; i++)
    {
        m++;
        if (j < remove.Length && k == remove[j])
        {
            j++;
            k++;
            A3[l++] = "_";
            i--;
            continue;
        }
        A3[i] = items[k];
        k++;
    }            
    Debug.Assert(m == items.Length);
    return A3;
}