Question

我有一个函数，它接受大量的长双精度数（65536个元素），并对每个元素执行一系列数学运算，最后得到一个修改后的数组，然后返回到main。

问题是，它是递归的，并且有这么多元素，程序和计算机最终崩溃，我只能假设是因为堆栈溢出（！）。递归函数的代码如下：

long double *sift(long double *signal){
   int i, def;
   double maxsize, minsize;
   int *max,*min;
   long double *maxinterp, *mininterp,*upenv,*loenv,*protoimf;

   max = maxArray(signal, ARRAYSIZE); //build binary array indicating 
   min = minArray(signal, ARRAYSIZE); //maxima or minima at that index

   maxsize = count(max, ARRAYSIZE); //count total max/minima
   minsize = count(min, ARRAYSIZE);

   def = checkDefinition(signal, maxsize+minsize); 
   if(def>0) {          //checks if signal has equal number of zero
       return signal;   //crossings and extrema
   }

   maxinterp = gslMax(signal, maxsize, ARRAYSIZE); //gnu scientific lib
   mininterp = gslMin(signal, minsize, ARRAYSIZE); //cubic spline interp.

   upenv = envelope(maxinterp, max, min, maxsize, minsize); //envelopes of
   loenv = envelope(mininterp, min, max, minsize, maxsize); //signal

   protoimf = imf(signal, upenv, loenv); //find mean curve 
   protoimf = sift(protoimf);            //recursive call till definition
                                         //is satisfied
   if (def > 0) {
      return protoimf;
   }

   //free(min); free(upenv) etc. 

   return protoimf;
}

我尝试通过在一个while循环中调用sift（）并使用checkDefinition（）作为条件来修改forc的迭代路径。但是，与递归相比，我没有获得相同的数组。我的辅助函数countExtrema（）调用max / minarray（）和count（）并返回传入的数组中的极值数。但是该值与递归时的值不同（它给出了正确的输出/行为）。

我认为这是因为我需要以某种方式存储局部变量？我在网上研究过，似乎我需要一个堆栈？有人可以指导我如何在c中复制我的递归函数吗？

以下是我的imf函数的代码：

long double *imf(long double *hilbert, long double *upper, long double *lower){
   int i;
   long double *imf = malloc(sizeof(long double)*ARRAYSIZE);   //253
   for(i=0; i < ARRAYSIZE; i++){
      imf[i] = upper[i] + lower[i];
      imf[i] = imf[i] / 2.0000000000;
   }
   for(i = 0; i < ARRAYSIZE; i++){
      imf[i] = hilbert[i] - imf[i];
   }
   return imf;

}

以下是valgrind的投诉：

15,728,400 bytes in 15 blocks are definitely lost in loss record 14 of 15
==10394==    at 0x4C2AB80: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==10394==    by 0x401C68: imf (sift.c:253)
==10394==    by 0x402472: sift (sift.c:337)
==10394==    by 0x402626: main (sift.c:423)

还有更多关于信封（）等功能的投诉和gslMin（）但它们都有相同的结构，我分配一些内存并返回指向该内存的指针。问题是如果我将自由语句移动到sift（）中的while循环内，我会遇到seg错误。我该如何修复此内存泄漏？

Answer 1

深度递归是一个不好的迹象。您应该更彻底地检查算法。
可以将任何递归算法转换为迭代算法，使用＆＃34; stack-like＆＃34;数组存储＆＃34;递归上下文＆＃34;。不用说，该阵列可以与自由RAM一样大。例如，请参阅快速排序迭代实现 - http://www.geeksforgeeks.org/iterative-quick-sort

Answer 2

我注意到：

if (def > 0) {
  return protoimf;
}
//free memory

def永远不会＆gt; 0因为之前已经检查了一些行。然后，如果你可以将“空闲内存”部分移动到protoimf = sift(protoimf);之前，那么你将得到尾递归，这是一个适当的编译器可以优化以避免实际执行的递归。然后函数的最后一行变为：

    return(sift(protoimf));
}

Answer 3

您可以完全摆脱内存分配。以下是imf函数的简化版本：

void imf(long double *hilbert, long double *upper, long double *lower) {
    for (int i = 0; i < ARRAYSIZE; i++) {
        hilbert[i] -= (upper[i] + lower[i]) / 2.0;
}

sift也可以简化。它会迭代地修改signal数组。

long double *sift(long double *signal) {
    int i, def;
    double maxsize, minsize;
    int *max, *min;
    long double *maxinterp, *mininterp, *upenv, *loenv;

    for (;;) {
        max = maxArray(signal, ARRAYSIZE); //build binary array indicating 
        min = minArray(signal, ARRAYSIZE); //maxima or minima at that index

        maxsize = count(max, ARRAYSIZE); //count total max/minima
        minsize = count(min, ARRAYSIZE);

        def = checkDefinition(signal, maxsize + minsize); 
        if (def > 0) {       //checks if signal has equal number of zero
            return signal;   //crossings and extrema
        }

        maxinterp = gslMax(signal, maxsize, ARRAYSIZE); //gnu scientific lib
        mininterp = gslMin(signal, minsize, ARRAYSIZE); //cubic spline interp.

        upenv = envelope(maxinterp, max, min, maxsize, minsize); //envelopes of
        loenv = envelope(mininterp, min, max, minsize, maxsize); //signal

        imf(signal, upenv, loenv); //find mean curve 
    }
}

如何编写递归函数的迭代版本？

3 个答案: