Question

我需要知道一种方法，可以在从两个不同的数组中获取数字时保持重复数字不被存储在新数组中。该函数应该存储一次“唯一”值，而不是再次存储重复值。

到目前为止，这是我的功能代码：

int * arrayIntersect(int *sizeOfResult, const int *a, const int *b, int sizeOfA, int sizeOfB){
int i;
int j;
int k = 0;
int c[(sizeOfA + sizeOfB)];

    for(j = 0; j < sizeOfB; j++){
        for(i = 0; i < sizeOfA; i++){
            if(a[i] == b[j]){
                c[k] = a[i];
                (*sizeOfResult)++;
                k++;
            }   
        }
    }
int *d = (int *)malloc(sizeof(int) * *sizeOfResult);
    for(i = 0; i < *sizeOfResult; i++){
        d[i] = c[i];
    }
return d;

}

它会打印我需要的值，但是我想在打印新动态数组的内容时多次显示相同的数字。

如何改进我的代码以防止重复？

Answer 1

正确的方法是对数组进行排序，然后像@Murilo Vasoncelos所指出的那样对每个插入进行二进制搜索。

下面是一个快速而肮脏的解决方案，它循环通过a和b，并且每次迭代检查之前是否插入了数字。如果不是，则插入它。

int duplicate = 0;
*sizeOfResult = 0;
for(j = 0; j < sizeOfA; j++){
    for(i = 0; i < (*sizeOfResult); i++){
        if(c[i] == a[j]){
            duplicate = 1;
            break;
        }   
    }
    if (!duplicate)
    {
        c[(*sizeOfResult)] = a[i];
        (*sizeOfResult)++;
    }
    duplicate = 0;
}
for(j = 0; j < sizeOfB; j++){
    for(i = 0; i < (*sizeOfResult); i++){
        if(c[i] == b[j]){
            duplicate = 1;
            break;
        }   
    }
    if (!duplicate)
    {
        c[(*sizeOfResult)] = b[i];
        (*sizeOfResult)++;
    }
    duplicate = 0;
}

Answer 2

如果您的数组a和b是有序的，您只需将此线性算法用于数组交集：

int* inter(int* szr, int* a, int* b, int sza, int szb)
{
    int c[MAX(sza, szb)];
    int i, j, k = 0;

    for (i = 0, j = 0; i < sza && j < szb;) {
        if (a[i] == b[j]) {
            if (k == 0 || c[k - 1] < a[i]) {
                c[k++] = a[i];
            }

            i++;
            j++;
        }
        else if (a[i] < b[j]) {
            i++;
        }
        else {
            j++;
        }
    }

    *szr = k;

    int* ans = (int*)malloc(sizeof(int) * k);
    for (i = 0; i < k; ++i) {
        ans[i] = c[i];
    }

    return ans;
}

使用来自两个不同数组的值填充动态数组时，防止存储重复项

2 个答案: