执行递归算法，特别是递归执行层数多的时候，结果极其的慢，并且递归层数达到必定的值，还可能出现内存溢出的状况。本文就要将为你解释缘由和对应的解决方案。算法

1、递归与循环

1.1 所谓的递归慢究竟是什么缘由呢？

你们都知道递归的实现是经过调用函数自己，函数调用的时候，每次调用时要作地址保存，参数传递等，这是经过一个递归工做栈实现的。具体是每次调用函数自己要保存的内容包括：局部变量、形参、调用函数地址、返回值。那么，若是递归调用N次，就要分配N局部变量、N形参、N调用函数地址、N返回值，这势必是影响效率的，同时，这也是内存溢出的缘由，由于积累了大量的中间变量没法释放。函数

1.2 用循环效率会比递归效率高吗？

递归与循环是两种不一样的解决问题的典型思路。固然也并非说循环效率就必定比递归高，递归和循环是两码事，递归带有栈操做，循环则不必定，两个概念不是一个层次，不一样场景作不一样的尝试。性能

1.3 那么递归使用的栈是什么样的一个栈呢？

首先，看一下系统栈和用户栈的用途。优化

2.1 递归算法：

优势：代码简洁、清晰，而且容易验证正确性。（若是你真的理解了算法的话，不然你更晕）ui

缺点：它的运行须要较屡次数的函数调用，若是调用层数比较深，须要增长额外的堆栈处理（还有可能出现堆栈溢出的状况），好比参数传递须要压栈等操做，会对执行效率有必定影响。可是，对于某些问题，若是不使用递归，那将是极端难看的代码。操作系统

2.2 循环算法：

优势：速度快，结构简单。code

缺点：并不能解决全部的问题。有的问题适合使用递归而不是循环。若是使用循环并不困难的话，最好使用循环。排序

2.3 递归算法和循环算法总结：

1） 通常递归调用能够处理的算法，也能够经过循环去解决，常须要额外的低效处理。递归

2）如今的编译器在优化后，对于屡次调用的函数处理会有很是好的效率优化，效率未必低于循环。进程

3） 递归和循环二者彻底能够互换。若是用到递归的地方能够很方便使用循环替换，而不影响程序的阅读，那么替换成递归每每是好的。（例如：求阶乘的递归实现与循环实现。）

3.1 系统栈（也叫核心栈、内核栈）

是内存中属于操做系统空间的一块区域，其主要用途为：
1)保存中断现场，对于嵌套中断，被中断程序的现场信息依次压入系统栈，中断返回时逆序弹出；
2)保存操做系统子程序间相互调用的参数、返回值、返回点以及子程序(函数)的局部变量。

3.2 用户栈

是用户进程空间中的一块区域，用于保存用户进程的子程序间相互调用的参数、返回值、返回点以及子程序(函数)的局部变量。

咱们编写的递归程序属于用户程序，所以使用的是用户栈。

2、递归与尾递归

以上初略介绍了递归与循环的实现机理，彷佛代码简洁和效率不能共存。那么有没有一种方法能拥有递归代码简洁的好处，同时给咱们带来更快的速率么？算法的世界会告诉你，一切皆有可能。它的名字叫作尾递归。

让递归和尾递归来作一个对比吧。

2.1 递归

用线性递归实现Fibonacci函数，程序以下所示：

int FibonacciRecursive(int n) { if( n < 2) return n; return (FibonacciRecursive(n-1)+FibonacciRecursive(n-2));
}

递归写的代码很是容易懂，彻底是根据函数的条件进行选择计算机步骤。例如如今要计算n=5时的值，递归调用过程以下图所示，能够看出，程序向下递归，向上返回，因此每一步都须要存储中间变量和过程。

2.2 尾递归

顾名思义，尾递归就是从最后开始计算, 每递归一次就算出相应的结果, 也就是说, 函数调用出如今调用者函数的尾部, 由于是尾部, 因此根本没有必要去保存任何局部变量。直接让被调用的函数返回时越过调用者, 返回到调用者的调用者去。尾递归就是把当前的运算结果（或路径）放在参数里传给下层函数，深层函数所面对的不是愈来愈简单的问题，而是愈来愈复杂的问题，由于参数里带有前面若干步的运算路径。

尾递归是极其重要的，不用尾递归，函数的堆栈耗用难以估量，须要保存不少中间函数的堆栈。好比f(n, sum) = f(n-1) + value(n) + sum，会保存n个函数调用堆栈，而使用尾递归f(n, sum) = f(n-1, sum+value(n))，这样则只保留后一个函数堆栈便可。

采用尾递归实现Fibonacci函数，程序以下所示：

int FibonacciTailRecursive(int n,int ret1,int ret2) { if(n==0) return ret1; return FibonacciTailRecursive(n-1,ret2,ret1+ret2);
}

例如如今要计算n=5时的值，尾递归调用过程以下图所示：

从图能够看出，尾递归不须要向上返回了，可是须要引入额外的两个空间来保持当前的结果，这样减小了中间变量的存储和返回，大大提高了效率，并且避免了内存溢出。

3、触类旁通

相信不少读者对于快速排序都耳熟能详，不知道各位还记得快速排序的实现就是基于递归实现的么，因而这里就提供了一种优化快速排序的方案，固然尾递归不能改变快速排序的时间复杂度，可是提高性能仍是没问题的。笔者再也不作详细介绍，只贴上实现代码，留给各位独立思考的空间。

int Partition(int *p,int len,int start,int last)  
{ int flag=*(p+start); int i=start; int j=last; while(i<j)  
    { while(i<j && *(p+j)>flag) --j;  
        *(p+i)=*(p+j); while(i<j  && *(p+i)<=flag) ++i;  
        *(p+j)=*(p+i);  
    }  
    *(p+i)=flag; return i;     
}  
  
void QuickSort(int *p,int len,int start,int last)  
{ if(NULL=p) return; int index; while(start<last)  
   { index=Partition(p,len,start,last);  
 
     QuickSort(p,len,start,index-1); //QuickSort(p,len,index+1,last);   ／**递归调用*／
     start=index+1;   ／**尾递归调用*／
   }          
}