Question

编辑：添加了更多细节。

我正在尝试编写一个算法来查找n个数组的交集（所有共同点）。我的程序接受这些数组并将它们存储在进行操作的二维数组中。例如，这是一个示例主要方法：

int a[] = { 12, 54, 42 };
int b[] = { 54, 3, 42, 7 };
int c[] = { 3, 42, 54, 57, 3 };

IntersectionTableau<int> x(3);    // Where 3 is the max number of arrays allowed
                                  // to be stored.
x.addArray(a, 3);
x.addArray(b, 4);
x.addArray(c, 9);
x.run();            // Finds the intersection.

这些添加的数组将存储在T** arrays中，其大小将存储在int* sizes中。 T是通用类型。什么是一个有效的算法，让我可以在可变数量的泛型类型数组上执行此操作？

以下是我目前正在尝试做的事情：

template <class T>
inline
void IntersectionTableau<T>::run() {
    T* commonElements = d_arrays[0];
    for (int i = 1; i < d_currentNumberOfArrays; ++i) {
        commonElements = getIntersection(commonElements, d_arrays[i], d_sizes[i - 1], d_sizes[i]);
    }
    d_results = commonElements;
}



template <class T>
inline
T* IntersectionTableau<T>::getIntersection(T* first, T* second, int sizeOfFirst, int sizeOfSecond) {
    T* commonElements;
    if (sizeOfFirst > sizeOfSecond) {
        commonElements = new T[sizeOfFirst];
    } else {
        commonElements = new T[sizeOfSecond];
    }
    for (int i = 0; i < sizeOfFirst; ++i) {
        for (int j = 0; j < sizeOfSecond; ++j) {
            if (first[i] == second[i]) {
                commonElements[i] = first[i];
            }
        }
    }
return commonElements;

}

第一个函数接受前两个数组并将它们发送到第二个函数，该函数返回这两个数组之间的交集数组。然后，第一个函数将交集数组与d_arrays中的下一个数组进行比较，依此类推。我的问题是当我从d_results打印出一个元素时，产生了一个垃圾值，我不确定为什么。有人能告诉我我做错了什么，或者更好的方法来实现这个目标吗？

Answer 1

要存储数组，您可以使用std::vector。如果数组中元素的范围很小，那么散列是最佳选择。否则首先单独对所有数组进行排序，然后合并它们。合并时你可以跳过它们。

Answer 2

代码中至少存在两个问题：

if (first[i] == second[i])

这应该是if (first[i] == second[j])。

commonElements[i] = first[i];

修复起来比较棘手。我想你想要另一个变量（i和j）;我们称之为k：

commonElements[k++] = first[i];

无论如何，既然您可以使用C ++，那么您可以使用std::vector代替。它将尺寸存储在里面;这样可以减少混淆：

template <class T>
std::vector<T> // note: adjusted the return type!
IntersectionTableau<T>::getIntersection(...)
{
    std::vector<T> commonElements;
    for (int i = 0; i < sizeOfFirst; ++i) {
        for (int j = 0; j < sizeOfSecond; ++j) {
            if (first[i] == second[j]) {
                commonElements.push_back(first[i]);
            }
        }
    }
    return commonElements;
}

您也可以将first和second转换为矢量（虽然您现在不会从中受益很多）。

以下是需要注意的几点：

我将返回类型更改为vector<T>
旧版本返回一个数组，需要额外的代码来指定其结果的长度;此版本返回vector<T>对象
旧版本返回一个数组，稍后需要delete[] array以防止内存泄漏
vector - 指针黑客&commonElements[0]不适用于空vector

如果你的其他代码使用数组/指针，你可以使用vector - 指针黑客&commonElements[0]，但在之外的函数，以尊重终身规则：

T* commonElements = NULL;
for (int whatever = 0; whatever < 10; ++whatever)
{
    std::vector<T> elements = xxx.getIntersection(...); // will work
    commonElements = &elements[0]; // can pass this pointer to a function receiving T*
    print(commonElements); // will work
}
print(commonElements); // cannot possibly work, will probably segfault
print(elements); // cannot possibly work, and compiler will reject this

找到'n'通用数组的相交

2 个答案: