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

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循环中调用main中的sift（）（以递归编辑为c）并以checkDefinition（）为条件来进行迭代。 但是，与递归相比，我没有得到相同的数组。 我的助手函数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)

还有更多关于函数的抱怨，例如envelope（）和gslMin（），但是它们都具有相同的结构，其中我分配了一些内存并将指针返回到该内存。 问题是如果我将自由语句移动到sift（）的while循环内，则会出现seg错误。 我该如何解决此内存泄漏？

Answer 1

1. 深度递归是一个不好的信号。 您应该更彻底地检查算法。

2. 使用“类似堆栈”的数组来存储“递归上下文”，可以将任何递归算法转换为迭代算法。 不用说，该阵列可以和可用RAM一样大。 例如，请参阅快速排序迭代实现-http: //www.geeksforgeeks.org/iterative-quick-sort

Answer 2

我注意到：

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

def从不大于0，因为之前已经检查了几行。 然后，如果您可以将“空闲内存”部分移至protoimf = sift(protoimf);之前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 
    }
}