把最低的数字放在第一位，把两个数组组合成一个

Combining two arrays into one by putting the lowest numbers in first

本文关键字：两个 组合 一个 数组 数字 放在第一位      更新时间：2023-10-16

我需要遍历a和b数组，将元素从a和b复制到combo中，使combo最终被排序。

例如，如果a是{3,5,7,9}，b是{2,5,8,1234}（因此combo必须有9个元素），则此函数将combo设置为{2,3,5,7,8,91234}。我需要有效地做到这一点：当我把值放入组合框时，我需要把它们放在正确的位置；不要随意，以后再重新排列。

我在while循环中尝试了嵌套for循环，但得到了一些奇怪的结果。我似乎想不出一个办法来超过最低的数字。例如，一旦我将最低的数字添加到组合数组中，我就可以；I don’我不知道如何丢弃它。谢谢你的帮助。

void merge( 
    unsigned combo[], 
    const unsigned a[],
    unsigned aElements,
    const unsigned b[],
    unsigned bElements 
){
    if (mySort(a, aElements) == 0) {
        cout << "The first array is not sorted";
        exit(1);
    }
    if (mySort(b, bElements) == 0) {
        cout << "The second array is not sorted";
        exit(1);
    }
    unsigned combinedElements;
    unsigned lowest = 0;
    unsigned i = 0;
    combinedElements = aElements + bElements;
    while (i < combinedElements) {
        for (int n = 0; n < combinedElements; n++) {
            if (a[i] < b[n]) {
                lowest = a[i];
            }
            else {
                lowest = b[n];
            }
        }
        combo[i] = lowest;
        i++;
        cout << combo[i] << endl;
    }

}

除非这是家庭作业，否则使用std::merge

void merge( 
    unsigned combo[], 
    const unsigned a[],
    unsigned aElements,
    const unsigned b[],
    unsigned bElements 
){
    std::merge(a, a+aElements, b, b+bElemnts, combo);
}

如果是作业，请尝试以下算法：

index_result = 0; index_a = 0; index_b = 0;
while(index_a < size_a && index_b < size_b)
  if(a[index_a] < b[index_b])
    result[index_result++] = a[index_a++]
  else
    result[index_result++] = b[index_b++]
while(index_a < size_a)
  result[index_result++] = a[index_a++]
whle(index_b < size_b)
  result[index_result++] = b[index_b++]

我假设这是某种类型的家庭作业，如果不是，只使用std::merge。

如果您想手动推出它，您需要考虑使用三个游标：两个是两个不同数组中的输入游标，另一个是输出（写入）游标。

在决定要从哪个数组中移动下一个元素后，您需要复制和更新两个游标，即该数组中的读取游标（因为该元素已经被使用）和最终数组中的写入游标（因为那个位置已经被写入）。

我希望这足以引导您找到一个解决方案：）

以下是您可以尝试的标准方法列表：http://www.cplusplus.com/faq/sequences/sequencing/sort-algorithms/

另外，你有没有考虑过类似的东西，在psuedo代码中：

创建一个新数组[旧数组的大小减去一]mempcy（新数组，从删除点开始-1）mempcy（新阵列，移除点+1到结束）

从新阵列排序

再次对最低数字进行罚款。。。

这里有一个非常紧凑的解决方案，应该很容易阅读和理解。

我假设combo有足够的空间来拟合结果，并且a和b已经排序（正如您的示例所示）：

void merge(unsigned combo[], 
           const unsigned a[],
           unsigned aElements,
           const unsigned b[],
           unsigned bElements)
{
    while(aElements + bElements > 0)
    {
      if(bElements == 0 || (aElements > 0  && *a < *b))
      {
          aElements--;
          *combo++ = *a++;
      }
      else
      {
          bElements--;
          *combo++ = *b++;
      }
   }
}

它可以稍微调整一下以获得更好的性能，但它非常优雅且可读。另外，此代码同时兼容C和C++。

假设这是一项家庭作业或类似的任务，并且不允许使用std::merge等标准内容，则2个排序列表的合并算法可以以线性复杂度完成，如下所示：

void merge( unsigned combo[], const unsigned a[], unsigned aElements, const unsigned 
b[],    unsigned bElements ){
    if (mySort(a, aElements) == 0) {
        cout << "The first array is not sorted";
        exit(1);
    }
    if (mySort(b, bElements) == 0) {
        cout << "The second array is not sorted";
        exit(1);
    }
    int i,j,k =0;
    while (i<aElements && j<bElements)
    {
        if (a[i]<=b[j])
        {
            combo[j++]=a[i++];
        } else
        {
            combo[j++]=b[j++];
        }
    }
    //add remaining elements. at least one of these loops will not happen
    while (i < aElements) combo[j++]=a[i++];
    while (j < bElements) combo[j++]=b[j++];
}
相关文章：