C++ 将一个数组复制到另一个数组而不复制C++；

问题是，我有一个10个整数的数组，有一些重复的。任务是将此数组复制到另一个大小相同但没有重复值的数组。也就是说，从array1中读取一个元素，将其与array2中的所有元素进行比较，如果它已经在array2中，只需跳过它或打印它已经在array2中，转到array1的第二个元素，然后重复该过程。 现在，我尝试过这个，但不知道问题出在哪里：

#include <iostream>
using namespace std;

int main()
{
    int temp;

    int array1[] = {10,2,5,4,10,5,6,9,8,10};
    int array2[11] = {0};

    for(int i = 1; i <= 10; i++)
    {
            temp = array1[i-1];

            for(int j = 1; j <= 10; j++)
            {
                    if(temp == array2[j])
                    {
                            cout << "Duplicate " << temp << endl;
                            i++;
                            break;
                    }
            }

            array2[i] = array1[i-1];
    }

    for(int k = 1; k <= 10; k++)
            cout << array2[k] << "  " << endl;
system("pause");
}

#包括
使用名称空间std；
int main（）
{
内部温度；
int array1[]={10,2,5,4,10,5,6,9,8,10}；
int array2[11]={0}；
对于（int i=1；i有三种方法：


逐个比较每个元素（
O（N^2）
performance）
对引用数组排序并使用二进制搜索确定元素是否存在（
O（N*lnN）
performance）
创建查找哈希（
O（1）
performance）
您有三种方法：


逐个比较每个元素（
O（N^2）
performance）
对引用数组排序并使用二进制搜索确定元素是否存在（
O（N*lnN）
performance）
创建查找哈希（
O（1）
performance）
std:：unique\u copy是你的朋友：

请记住首先对源数组进行排序
std:：unique\u copy是您的朋友：

请记住首先对源数组进行排序。
array1
有10个元素，而
array2
有11个元素，因此没有立即满足要求。假设有11个元素是在
for
循环中使用不正确索引值的一种变通方法；索引应该从0到9运行，而不是从1到10

将元素添加到第二个数组时，应仅对照已添加的元素检查其值，而不是对照整个数组中的值

最后，还有一个不明确的规定。一旦消除了重复项，就只有不到10个元素；
array2
有10个元素；额外的元素应该有什么值？
array1
有10个元素，
array2
有11个元素，所以马上就没有满足要求。大概，有11个元素是正确的在
for
循环中使用不正确索引值的解决方法；索引应从0运行到9，而不是从1运行到10

将元素添加到第二个数组时，应仅对照已添加的元素检查其值，而不是对照整个数组中的值

最后，有一个不足之处：一旦你删除了重复的元素，你就有10个元素；<代码> ARARY2有10个元素；额外元素有什么值？
< P> C++，<代码>破解>代码>立即结束一个循环结构，并在它之后立即开始执行。

执行redardless，以确定内部

for

循环是否找到重复的值。一种解决方案是设置一个变量，指示该值是重复的：

 int main() {
     int temp;
     bool isDuplicate; //added this line

     int array1[] = {10,2,5,4,10,5,6,9,8,10};
     int array2[11] = {0};

     for(int i = 1; i <= 10; i++)
     {
             temp = array1[i-1];
             isDuplicate=false;//added this line
             for(int j = 1; j <= 10; j++)
             {
                     if(temp == array2[j])
                     {
                             cout << "Duplicate " << temp << endl;
                             i++;
                             isDuplicate=true; //added this line
                             break;
                     }
             }
             if(!isDuplicate) //added this line
             array2[i] = array1[i-1];
     }

     for(int k = 1; k <= 10; k++)
             cout << array2[k] << "  " << endl; system("pause"); }

---

在C++中，<代码>中断< /COD>立即结束一个循环结构，并在它之后立即开始执行。因此，行<代码> ARARY2[i]＝ARARY1[I-1 ]；< /COD>不执行内部代码< > < /COD>循环是否找到副本。一个解决方案是设置一个变量，该值指示重复值：

 int main() {
     int temp;
     bool isDuplicate; //added this line

     int array1[] = {10,2,5,4,10,5,6,9,8,10};
     int array2[11] = {0};

     for(int i = 1; i <= 10; i++)
     {
             temp = array1[i-1];
             isDuplicate=false;//added this line
             for(int j = 1; j <= 10; j++)
             {
                     if(temp == array2[j])
                     {
                             cout << "Duplicate " << temp << endl;
                             i++;
                             isDuplicate=true; //added this line
                             break;
                     }
             }
             if(!isDuplicate) //added this line
             array2[i] = array1[i-1];
     }

     for(int k = 1; k <= 10; k++)
             cout << array2[k] << "  " << endl; system("pause"); }

---

您可以使用std:：set来确保唯一性

---

您可以使用std:：set来确保您的唯一性

---

我可以在代码中看到两个主要的问题来源：1）实际上，

break

语句并不能解决在发现重复的情况下与在array1中的元素应添加到array2时的区分问题。2）没有计数器可以存储插入array2的元素数量，这样它们就不能彼此相邻地复制到array2。T修复这两个问题的代码是：

#include <iostream>
using namespace std;

int main()
{

  int array1[] = {10,2,5,4,10,5,6,9,8,10};
  int array2[10];

  int array2_elements_inserted = 0; 

  for(int i = 0; i < 10; i++)
    {
      int temp = array1[i];

      bool isDuplicate = false; 
      for(int j = 0; j < array2_elements_inserted; j++)
        {
          if(temp == array2[j])
            {
              cout << "Duplicate " << temp << endl;
              isDuplicate = true; 
              break;
            }
        }

      if (!isDuplicate)
        {
          array2[array2_elements_inserted] = temp;
          ++array2_elements_inserted; 
        }
    }

    for(int k = 0; k < array2_elements_inserted; k++)
        cout << array2[k] << "  " << endl;
  //  system("pause");
}

---

我可以在您的代码中看到两个主要的问题来源：1）

break

语句不能解决在发现重复时区分情况的问题，也不能解决在array1中的元素应添加到array2时区分情况的问题。2）没有计数器可以存储到array2中插入的元素数量，因此y无法将它们相邻复制到array2。修复这两个问题的代码是：

#include <iostream>
using namespace std;

int main()
{

  int array1[] = {10,2,5,4,10,5,6,9,8,10};
  int array2[10];

  int array2_elements_inserted = 0; 

  for(int i = 0; i < 10; i++)
    {
      int temp = array1[i];

      bool isDuplicate = false; 
      for(int j = 0; j < array2_elements_inserted; j++)
        {
          if(temp == array2[j])
            {
              cout << "Duplicate " << temp << endl;
              isDuplicate = true; 
              break;
            }
        }

      if (!isDuplicate)
        {
          array2[array2_elements_inserted] = temp;
          ++array2_elements_inserted; 
        }
    }

    for(int k = 0; k < array2_elements_inserted; k++)
        cout << array2[k] << "  " << endl;
  //  system("pause");
}

---

首先，使用动态容器。特别是看看 标准库，例如

std:：vector

。其次，您应该使用一个集合数据结构 跟踪您以前见过的元素，例如，

std:：set

然后，它只是对输入数组进行迭代，并将新元素添加到 输出数组

下面是一个例子：

#include <vector>
#include <set>
#include <iostream>

int main() {
    // define and print input data
    std::vector<int> v1 = {10,2,5,4,10,5,6,9,8,10};
    for (int i : v1) 
        std::cout << i << " ";
    std::cout << "\n";
    // this will soon contain the output data
    std::vector<int> v2;
    // a set to keep track of the already seen elements 
    std::set<int> set;
    // iterate the input array using range-based for loop
    for (int i : v1) {
        // check for duplicates
        if (set.find(i) == set.end()) {
            // first occurrence, insert to set, append to output data
            set.insert(i);
            v2.push_back(i);
        }
        else {
            // seen before, do nothing
        }
    }
    // print output data
    for (int i : v2) 
        std::cout << i << " ";
    std::cout << "\n";    
}

供参考：

---

首先，使用动态容器。特别是查看 标准库，例如

std:：vector

。其次，您应该使用一个集合数据结构 跟踪您以前见过的元素，例如，

std:：set

然后，它只是对输入数组进行迭代，并将新元素添加到 输出数组

下面是一个例子：

#include <vector>
#include <set>
#include <iostream>

int main() {
    // define and print input data
    std::vector<int> v1 = {10,2,5,4,10,5,6,9,8,10};
    for (int i : v1) 
        std::cout << i << " ";
    std::cout << "\n";
    // this will soon contain the output data
    std::vector<int> v2;
    // a set to keep track of the already seen elements 
    std::set<int> set;
    // iterate the input array using range-based for loop
    for (int i : v1) {
        // check for duplicates
        if (set.find(i) == set.end()) {
            // first occurrence, insert to set, append to output data
            set.insert(i);
            v2.push_back(i);
        }
        else {
            // seen before, do nothing
        }
    }
    // print output data
    for (int i : v2) 
        std::cout << i << " ";
    std::cout << "\n";    
}

供参考：

---

最后一个

cout

的输出是什么？数组的索引从0到（数组长度-1）不，不是排序。任务是一个元素一个元素地复制。此外，正如代码中所显示的，array2将从索引1开始而不是从零开始。请指导我。这似乎很奇怪。为什么您希望array2是一个数组？既然您不应该预先知道有多少重复项，您应该使用std:：vector，或者更好的是使用std:：set来对el进行排序设置元素并防止重复。如果不希望对array2进行排序，可以使用std:：unordered_集合。为什么array2的元素数比array1多？array2的输出是什么