C++ While循环错误

我有一个任务，将两个排序向量合并成第三个排序向量。我相信解决这个问题的方法很简单，但我的大脑现在已经崩溃了，需要你的帮助

基本上，向量A和B的大小为3。它们将分别保存1、2、3和4、5、6等整数。我似乎无法正确获取while循环的语法。我试着把它做成一个do/while循环，在案例周围加上括号，还有其他一些事情。它只是似乎没有读到&&&之后的部分

第一个for循环只会使R向量具有正确的大小。第二个for循环只显示R向量的值。结果应该从1-6打印出来，但我只看到1-3

任何帮助都将不胜感激

void::combine(vector<int> A, vector<int> B, vector<int> R) {
int ia = 0, ib = 0, ir = 0;

for (int i = 0; i < A.size() + B.size(); i++) {
    R.push_back(0);
}

while (ia != A.size() && ib != B.size()) {
        if (A[ia] < B[ib]) {
             R[ir] = A[ia];
             ia += 1;
        }
        else {
            R[ir] = B[ib];
            ib += 1;
        }
        ir += 1;
}

for (int i = 0; i < R.size(); i++) {
    cout << "L3[" << i << "] = " << R[i] << endl;
}

}

那是因为您的&&状况。一旦ia==A.size，条件ia！=A.size将始终计算为false，循环的ib部分将不会执行

---

要修复它，您可以将条件更改为：iA假设A包含[1,2,3]，B包含[4,5,6]，如您所说，这不会将B向量中的任何元素添加到R向量

这是因为在第4次迭代中，ia==3，因此连接条件不再为真

---

尝试将其更改为whileia！=A.尺寸| | ib！=B.size

语法很好，否则代码不会编译，但循环条件不是。给定示例A={1,2,3}和B={4,5,6}，循环将进入A[ia]

---

由于您已经知道需要在结果向量中放置多少项，因此我建议将while循环替换为具有相同主体的simple for one。

例如，使用123和456立即执行的操作

将R初始化为{0,0,0,0,0}

在将一个向量中的所有值插入R比较候选值并将较小的值插入R之前，从获胜者列表中获取下一个候选值

---

仅此而已-如果您要编写函数，我不知道这是函数的目的，否则我/我们可以提供解决方案，只需查看上面表格中的第二点。

可能您应该完全避免循环：

void combine(vector<int> const& A, vector<int> const& B, vector<int> & R) {
   R.resize( A.size() + B.size() );
   std::copy( A.begin(), A.end(), R.begin() );
   std::copy( B.begin(), B.end(), R.begin()+A.size() );
   std::sort( R.begin(), R.end() );
   for ( int i = 0; i < R.size(); ++i )
   {
    cout << "L3[" << i << "] = " << R[i] << endl;
   }
}

---

我不知道你在while循环中想做什么。但如果只是用A和B中的元素填充向量R，而不考虑它们的添加顺序，那么可以使用插入函数，如下所示：

void::combine(const vector<int> &A, const vector<int> &B, vector<int>& R)
{
    R.insert(R.end(), A.begin(), A.end());
    R.insert(R.end(), B.begin(), B.end());
}

如果你这样做，你必须包括在内。如果要按降序排序，请执行以下操作：

bool compare( int a, int b ) { return a > b; }
sort( R.begin(), R.end(), compare); //sorts in decreasing order.

---

首先，这闻起来像一个经典的合并排序或它的一部分：

目标是检查第一个向量A的元素到向量B的元素，并将元素按顺序附加到结果向量R

因此，如果A[i] 以下是未经测试的代码：

void Sort_Vector(const std::vector& A, const std::vector& B, std::vector& result)
{
  unsigned int index_a = 0;  // Point to first element in first vector.
  unsigned int index_b = 0;  // Point to first element in second vector.
  result.clear();            // Clear all elements, so size == 0.

  while ((index_a < A.size()) && (index_b < B.size())
  {
     if (A[index_a] < B[index_b])
     {
         result.push_back(A[index_a]);
         ++index_a;
     }
     else // B[index_b] <= A[index_a]
     {
         result.push_back(B[index_b]);
         ++index;
     }
  }

  // Append any remaining elements to the result vector.
  // Only one of the two loops should be executed,
  //    the other will fail the comparison expression
  //    and not execute.
  for (; index_a < A.size(); ++index_a)
  {
     result.push_back(A[index_a]);
  }
  for (; index_b < B.size(); ++index_b)
  {
     result.push_back(B[index_b]);
  }
  return;
}

请注意我的函数的签名参数与您的签名参数之间的差异。我将源向量作为常量数据传递，结果向量通过引用传递，这使我的函数能够修改调用方的结果向量

---

另外，我很懒，使用std:：vector:：push_-back方法。我相信这比在结果向量中指定一个元素更可读。push_-back方法意味着我将附加到向量。如果读者忘记了向量将展开以解决分配，则分配路径可能会让他们措手不及

使用迭代器而不是使用大小。会让你的生活更轻松。顺便说一句，你的目标不是在事后使用这个向量，我希望：你对R所做的所有更改都是函数的局部更改。如果知道你实际上想要完成什么，那就太好了，因为基本上如果A[ia]=B.size，并且你试图到达索引为iB的元素：是的，我之前尝试过这种方法。我的编译器由于断言错误而不断崩溃。正如Kiril所说，它对ia有效，但在IB中失败。这将导致错误。但是，如果向量A中的所有数字都不小于向量B中的数字，您可能需要重新考虑如何实现这一点function@David：您可以使用“插入”，而不是调整大小然后复制，对吗？这比使用带索引的for循环更简单吗？这

---

看起来过于臃肿，这会带来不必要的复杂性。如果先复制后排序不是最佳选择，那么可能应该使用std:：set作为结果，而不是另一个向量。@纳瓦兹：是的，您可以使用push_back或std:：back_插入器迭代器适配器使其根据需要增长。当我编写代码时，我想把它添加到答案中，然后我忘记填写它：如果向量很大，调整大小或保留将有利于将重置减少到1 @基督教：如果删除所有变量声明，代码在C和C++中是非常地道的，而且简洁。假设你第一次看到*x++=*y++需要几秒钟的时间来推理。@David：我不是说推回或返回插入器。只需插入。看看我的解决方案！是的，我想这么做，但我不确定这是否是允许的，因为这是一个课程作业。我可能会把它作为最后的手段。谢谢你的回复！谢谢你的回复，纳瓦兹。不幸的是，我不能使用sort函数，因为赋值的目的是手动排序。是的，R应该包含A和B的所有元素，谢谢你，托马斯。我能够根据您的建议正确修改我的代码

bool compare( int a, int b ) { return a > b; }
sort( R.begin(), R.end(), compare); //sorts in decreasing order.

void Sort_Vector(const std::vector& A, const std::vector& B, std::vector& result)
{
  unsigned int index_a = 0;  // Point to first element in first vector.
  unsigned int index_b = 0;  // Point to first element in second vector.
  result.clear();            // Clear all elements, so size == 0.

  while ((index_a < A.size()) && (index_b < B.size())
  {
     if (A[index_a] < B[index_b])
     {
         result.push_back(A[index_a]);
         ++index_a;
     }
     else // B[index_b] <= A[index_a]
     {
         result.push_back(B[index_b]);
         ++index;
     }
  }

  // Append any remaining elements to the result vector.
  // Only one of the two loops should be executed,
  //    the other will fail the comparison expression
  //    and not execute.
  for (; index_a < A.size(); ++index_a)
  {
     result.push_back(A[index_a]);
  }
  for (; index_b < B.size(); ++index_b)
  {
     result.push_back(B[index_b]);
  }
  return;
}