在C语言中,获得两个数组差异的有效方法是什么?

在C语言中,获得两个数组差异的有效方法是什么?,c,arrays,algorithm,C,Arrays,Algorithm,样本输入 Array_1 [] = { 10, 20, 30, 40, 50 }; Array_2 [] = { 30, 40, 50, 60, 70 }; Array_1_Extras [] = { 10, 20 }; Array_2_Extras [] = { 60, 70 }; 样本输出 Array_1 [] = { 10, 20, 30, 40, 50 }; Array_2 [] = { 30, 40, 50, 60, 70 }; Array_1_Extras [] = { 10,

样本输入

Array_1 [] = { 10, 20, 30, 40, 50 };
Array_2 [] = { 30, 40, 50, 60, 70 };
Array_1_Extras [] = { 10, 20 };
Array_2_Extras [] = { 60, 70 };
样本输出

Array_1 [] = { 10, 20, 30, 40, 50 };
Array_2 [] = { 30, 40, 50, 60, 70 };
Array_1_Extras [] = { 10, 20 };
Array_2_Extras [] = { 60, 70 };
说明

  • 输入数组未排序

  • 输入阵列长度-10K

  • 输入数组值的范围为0-4095

  • 不应修改输入数组顺序和值

  • 输出数组可以是任意顺序

  • 输出数组中不需要重复项

  • 我需要一些时间效率的逻辑为这个程序。提前谢谢

    这里有一个简单的
    O(N)
    时间算法,它有点占用空间(它也考虑了重复项)

    1) 声明长度为4096的零的数组
    C

    2) 迭代第一个数组
    A
    和索引的每个元素
    i
    增量
    C[A[i]]

    3) 迭代第二个数组
    B
    ,并对每个元素
    i
    递减
    C[B[i]]

    4) 迭代
    C
    i
    的负值
    C[i]
    表示
    B-A
    元素,正值表示
    A-B


    *绝对值将指示重复数的差异,如果您感兴趣的话。

    对于大小为10000的输入数组,您很可能能够通过一般算法的渐进复杂性来判断

    简单的算法是迭代一个数组,扫描另一个数组中每个元素的外观,然后反转角色并再次执行。如果较长数组的大小与较短数组的大小之比为
    O(1)
    ,则此方法的成本限制为
    O(n
    2

    您可以通过创建输入数组的副本(
    O(n)
    ),对它们进行排序(
    O(n log n)
    ),并对排序后的数组执行一次联合线性扫描,这与合并排序的合并步骤类似(
    O(n)

    由于输入数组的值是从一个比较小的范围内提取的,但是,合理的是考虑一个解决方案:<代码> O(n)< /代码>整体:

  • 创建一个数组,每个可能的输入数组值有一个2位或更宽的位字段元素
  • 扫描第一输入阵列;对于每个值,设置对应于该值的位字段的位零
  • 扫描第二输入阵列;对于每个值集,对应于该值的一个位字段
  • 扫描位字段数组:这些元素告诉您相应的输入值是出现在两个输入数组中,还是正好出现在一个输入数组中,或者两者都不出现
  • 对阵列进行排序(如果无法更改原始阵列,请选择副本)
  • 循环往复地走,直到完成
  • 对于每个递归,取每个数组的第一个元素

    a。如果它们不同,则将较小的元素添加到
    array\u 1\u extras
    array\u 2\u extras
    中,并使用该元素推进数组
    B如果它们相等,注意复制并推进两个数组

    这里是一个O(n)实现:

    int seen[4096];
    memset(seen, 0, sizeof(seen));
    int a[10000], b[10000];
    size_t aSize, bSize;
    ... // Fill a and b
    for (size_t i = 0 ; i != aSize ; i++) {
        seen[a[i]] |= 1;
    }
    for (size_t i = 0 ; i != bSize ; i++) {
        seen[b[i]] |= 2;
    }
    size_t j = 0;
    for (size_t i = 0 ; i != aSize ; i++) {
        if (seen[a[i]] == 1) {
            a[j++] = a[i];
        }
    }
    aSize = j;
    j = 0;
    for (size_t i = 0 ; i != bSize ; i++) {
        if (seen[b[i]] == 2) {
            b[j++] = b[i];
        }
    }
    bSize = j;
    
    这种方法删除
    a
    中也在
    b
    中的所有数字,而不考虑它们的计数。它还保留副本。例如,如果输入是这样的

    a = [10, 10, 10, 20, 20, 20, 30 , 40]
    b = [10, 30, 40, 40, 40, 40, 50]
    
    输出将是

    a = [20, 20, 20]
    b = [50]
    

    数组排序了吗?它们是严格的整数吗?这些数字有界吗?所有的数字都是正数吗?他们有上限吗?是否可以更改数组顺序?两个数组的长度是否有界?叹气。。。你尝试过什么?那么,据我所知,元素不是唯一的?如何处理两个相同的元素?关于重复元素:我认为,如果第一个数组中有三个10,而第二个数组中只有一个,10不应该出现在任何一个差异中,因为数组被视为集合。你的答案将考虑10作为<代码> A -B < /代码>的元素。这取决于问题的定义。使用您的定义,
    C
    的元素应限定在
    -1
    1
    之间。更新:实际上不是。对第二个数组的迭代应该只是重置值。。但是我们不会得到对称的结果。如果我们加上额外的支票,我们会的。不管怎么说,我相信它展示了整个想法。是的。我想这个问题一开始就没有说清楚。