建议一个合适的算法来合并包含类对象的两个数组(不重复）

如果您不介意丢失两个数组的原始顺序：

std::sort(first_array, first_array + N);
std::sort(second_array, second_array + M);
std::set_union(
first_array, first_array+N, 
second_array, second_array+M, 
target_array
);

CCD_ 1和CCD_。您需要为类定义operator<或专门化std::less：或者编写一个比较器函数并将其提供给sort和set_union。

时间复杂度是O(N log N + M log M)——sort是较慢的部分，然后set_union是线性的。

如果N0或second_array本身可能已经包含重复数据(而不仅仅是它们之间)，那么您需要额外的步骤来删除它们，这不仅会丢失顺序，还会丢失源阵列中的重复数据：

std::sort(first_array, first_array + N);
MyClass *first_end = std::unique(first_array, first_array + N);
std::sort(second_array, second_array + M);
MyClass *second_end = std::unique(second_array, second_array + M);
std::set_union(
first_array, first_end, 
second_array, second_end, 
target_array
);

或者，您可以编写set_union的修改版本，在一次通过中进行合并和重复数据消除

[编辑：对不起，在写这篇文章时，我错过了结果最终会返回到first_array，而不是单独的target_array。set_union不能将输出作为输入之一，因此这也需要目标阵列的额外内存，然后可以将其复制回源阵列，当然前提是源足够大。]

如果你确实想保留原始数组的顺序，那么你可以创建一个容器并边走边检查：

container<MyClass> items(first_array, first_array + N);
MyClass *dst = first_array + N;
for (MyClass *it = second_array; it != second_array + M; ++it) {
if (items.count(*it) == 0) {
items.insert(*it);
*dst++ = *it;
}
}

如果数组本身可以包含重复数据，则从items为空和dst = first_array开始，然后在两个输入数组上循环。

container可以是std::set(在这种情况下，时间是M0，实际上又是O(N log N + M log M)，您仍然需要一个顺序比较器)，也可以是C++11中的std::unordered_set(在这种情形下，预期时间是病理最坏情况下的O(N + M)，您需要专门化std::hash，或者编写一个散列函数，还提供一个等于函数，而不是顺序比较器)。在C++11之前，标准中没有其他哈希容器。

如果你不介意额外的内存和，也不介意丢失原始订单：

container<MyClass> items(first_array, first_array + N);
items.insert(second_array, second_array + M);
std::copy(items.begin(), items.end(), first_array);

如果你不想使用(太多)额外的内存，并且在源数组中有M个额外元素的空间，而不是只为结果留出空间：

std::copy(second_array, second_array + M, first_array + N);
std::sort(first_array, first_array + N + M);
MyClass *dst = std::unique(first_array, first_array + N + M);
// result now has (dst - first_array) elements

使用x、y、z定义对象的比较，对两个数组进行排序(如有必要，可以进行复制)，然后创建一个辅助目标列表，将第一个数组中的所有元素复制到该列表中，并仅将第二个数组中不匹配的元素复制到其中。如有必要，请复制回第一个数组。

复杂性：max(O(n log n)，O(m log m))，因为排序占主导地位，并且填充目的地列表是在O(max(n，m))上。

这并不是说该算法一定有效：对于较小的数组，复制和排序将占主导地位。