Question

当通过控制台提供输入时，以C ++编写的以下mergesort程序可以正常运行。但是当我使用文本文件来提供输入时，它会给我一个分段错误。我已经尝试在代码的各个部分打印消息以检查错误在哪里，但除了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）进行编程。两种语言的部分优点是它们的本机指针算术能力。它可以奇妙地用于像merge-sort这样的算法。在我演示你的合并和mergesort函数应该如何工作之后，我将演示我正在谈论的内容，然后我将提供你可以用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时，您在后续调用mergesort时使用未初始化的q值。

您收到的错误是由于mergesort函数中的无限递归。

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

2 个答案: