合并排序，使用文件的 I/O 显示分段错误

Question

以下用 C++ 编写的合并排序程序在通过控制台提供输入时可以正常工作。但是当我使用文本文件提供输入时，它会给我一个分段错误。我尝试在代码的各个部分打印消息以检查错误在哪里，但除了 d seg-fault 消息之外，它没有打印任何内容。 这是代码。当我不使用文件提供输入/显示输出时，它工作正常。

我在一个基本内存为 1 GB 的 virtualbox 4.0.8(ubuntu OS) 中的 gcc 编译器上运行了这个 prog。 cud错误是由于内存不足引起的？

#include<iostream>
#include<fstream>
#include<sys/time.h>
using namespace std;

int array[50];
int barray[50];

void merge(int p,int q, int r)
 {
    int i,j,k,l;
    l=p;
    i=p;
    j=q+1;

    while((i<=q)&&(j<=r))
    {

     if(array[i]<=array[j])
        barray[++k]=array[i++];

     else
        barray[k++]=array[j++];

    }

    if(i>q)
    {  
       for(l=j;l<=r;l++)
       { 
         barray[k]=array[l];
         k++;
       }
    }

   else
   {
      for(l=i;l<=q;l++)
      {
        barray[k]=array[l];
        k++;
      }

   }

   for(i=p;i<=r;i++)
        array[i]=barray[i];
}

void mergesort(int p, int r)
{
   int q;

   if(p<r)
      q=(p+r)/2;

   mergesort(p,q);
   mergesort(q+1,r);
   merge(p,q,r);

}


int main()
{
  int r, p, i;

  struct timeval tv1, tv2;/* For finding the running time */
  gettimeofday(&tv1, NULL);

  ifstream fin;
  ofstream fout;

  fin.open("abc5.txt");
  fout.open("new5.txt");

  fin>>r;
  while(fin)
  {

    for(i=1;i<=r;++i)
    {
       fin>>array[i];
    }

  }

  mergesort(1,r);

  for(i=1;i<=r;++i)
  {
    fout<<array[i]<<"\n";
  }

  gettimeofday(&tv2, NULL);
  fout<<"Running Time: "<<(double) (tv2.tv_usec - tv1.tv_usec) / 1000000 + (double)    (tv2.tv_sec - tv1.tv_sec)<<" sec";


 fin.close();
 fout.close();

 return 0;

}

输入文件 8 3 6 2 8 9 1 4 10

Answer 1

您的索引还有很多不足之处。我不会害羞地告诉你，也不会简单地说我不会以这种方式进行合并排序。但它就是这样，所以我会介绍它。

重要的是要理解，使用分治算法的序列排序都是关于在序列中传递一些碱基引用以及与该引用的一些偏移量。该算法应该独立于外部变量（如array[] 和barray[]），而是将它们作为参数。此外，请记住您正在使用 C++（或 C）进行编程。 两种语言的部分优点在于它们原生的指针算术能力。它可以很好地用于合并排序等算法。在我演示了你的合并和合并排序函数应该如何工作之后，我将演示我在说什么，然后我会提供你可以在 C++ 中使用的最简单的合并排序标准库功能。

---

您的代码优先

首先使用您的参数重新滚动您的函数。我冒昧地将参数重命名为它们实际上对审阅者有意义。该算法应该是不言自明的，我敦促您将其与您正在做的事情并排比较。

//  low  = starting index
//  mid  = middle index
//  high = last index
void merge(int low, int mid, int high)
{
    int i=low, j=mid, k=0;

    while (i < mid && j <=high)
    {
        if (array[i] < array[j])
            barray[k++] = array[i++];
        else
            barray[k++] = array[j++];
    }

    // finish whichever segment isn't done
    while (i < mid)
        barray[k++] = array[i++];
    while (j <= high)
        barray[k++] = array[j++];

    // copy back
    for (i=0;i<k;++i)
        array[low+i] = barray[i];
}

void mergesort(int low, int high)
{
    int len = high - low;
    if (len < 2)
        return;

    int mid = low + len/2;
    mergesort(low, mid);
    mergesort(mid, high);
    merge(low, mid, high);
}

这个算法需要注意的是，传递的初始参数必须是序列中的有效索引。换句话说，如果您读取一个包含 8 个元素的数组，有效索引是0..7，因此您可以将其调用为mergesort(0,7)。

---

另一种方法

C/C++ 中的传统合并排序使用数组基索引和长度作为其唯一参数。中点由排序算法计算。尽管合并算法并不严格需要它（它也可以只使用长度/2），但它可以在您需要从现在中间未拆分的段合并的情况下提供更强大的算法。

不要纠结于下面 std::vector、std::random_device 等的使用。它们在main() 函数中仅用于填充随机数数组，然后对其进行排序，并在排序操作之前和之后显示。我想让你摆脱的是实际的算法本身。

#include <iostream>
#include <vector>
#include <random>

void merge(int ar[], std::size_t mid, std::size_t len)
{
    if (len < 2)
        return;

    // temporary storage. normally I use a RAII container
    //  such as std::vector<>, but I wanted to demonstrate
    //  the algorithm and indexing, not the memory management.
    //  none the less it is worth noting.
    int *tmp = new int[len];
    std::size_t i=0, j=mid, k=0;

    while (i < mid && j < len)
    {
        if (ar[i] < ar[j])
            tmp[k++] = ar[i++];
        else
            tmp[k++] = ar[j++];
    }

    // complete the unfinished segment
    while (i < mid)
        tmp[k++] = ar[i++];
    while (j < len)
        tmp[k++] = ar[j++];

    // and move back to the original array
    for (i=0; i<len; ++i)
        ar[i] = tmp[i];

    delete [] tmp;
}

void mergesort(int ar[], std::size_t len)
{
    if (len < 2)
        return;

    // note pointer arithemtic in second call.
    mergesort(ar, len/2);
    mergesort(ar+len/2, len - len/2);
    merge(ar, len/2, len);
}

int main()
{
    std::vector<int> data;
    data.reserve(20);

    std::random_device rd;
    std::default_random_engine rng(rd());
    std::uniform_int_distribution<> dist(1,50);

    // populate array
    std::generate_n(std::back_inserter(data),
                data.capacity(),
                [&](){ return dist(rng);});

    // show on-screen
    for (auto n : data)
        std::cout << n << ' ';
    std::cout << '\n';

    // mergesort
    mergesort(data.data(), data.size());

    // show on-screen
    for (auto n : data)
        std::cout << n << ' ';
    std::cout << '\n';

    return 0;
}

输出（可变）

15 10 8 38 20 21 9 43 8 22 19 45 12 16 17 36 2 32 6 37 
2 6 8 8 9 10 12 15 16 17 19 20 21 22 32 36 37 38 43 45 

---

你会讨厌的部分

在完成所有这些工作之后，您会不太高兴知道标准库中已经存在两种为您进行段合并的算法，即std::merge 和std::inplace_merge。使用其中之一可以实现mergesort 琐碎，如下所示：

#include <algorithm>

void mergesort(int ar[], std::size_t len)
{
    if (len < 2)
        return;

    mergesort(ar, len/2);
    mergesort(ar+len/2, len-len/2);
    std::inplace_merge(ar, ar+len/2, ar+len);
}

请记住，如果您需要使用除 std::sort 之外的其他东西，老实说，除了实现学术目的之外，这一切都几乎无用。

Answer 2

因此，根据您的输入，看起来当 p=1 和 r=1 时，您在随后的合并排序调用中使用未初始化的 q 值。

您收到的错误是由于合并排序函数中的无限递归。