数学递归函数是什么意思?

​是指函数/过程/子程序在运行过程序中直接或间接调用自身而产生的重入现象。在计算机编程里，递归指的是一个过程：函数不断引用自身，直到引用的对象已知。使用递归解决问题，思路清晰，代码少。但是在主流高级语言中（如C语言、Pascal语言等）使用递归算法要耗用更多的栈空间，所以在堆栈尺寸受限制时（如嵌入式系统或者内核态编程），应避免采用。所有的递归算法都可以改写成与之等价的非递归算法。汉诺塔问题，是常见可用递归解决的问题，不过也有非递归的解法。菲波纳契数列可用递归定义。以下为求汉诺塔问题的Pascal程序：procedure Hanoi(n:integer;x,y,z:char);递归beginif n<>1 then beginHanoi(n-1,x,z,y);writeln(x,n,z);Hanoi(n-1,y,x,z);else writeln(x,n,z);end;end;上述程序用接近自然语言的伪代码可表述如下：Hanoi 过程 (整型参数n; 字符型参数 x,y,z);//注：n 代表本步中要处理的盘子数，x,y,z 分别表示 n 号盘子原来所在柱子、经由柱子、目标柱子开始如果 n 不为 1 ，那么：开始调用 Hanoi 过程 (参数为 n-1,x,z,y);//注：这一步表示用本过程方法将剩余 n-1 个盘子从柱子 x 经由柱子 z 移动到柱子 y输出 x,n,z; //注：表示将 n 号盘子从 x 移动到 z调用 Hanoi 过程 (参数为 n-1,y,x,z);//注：这一步表示用本过程方法将剩余 n-1 个盘子从柱子 y 经由柱子 x 移动到柱子 z结束; //以上程序段就完成了把 n 个盘子从柱子 x 经由柱子 y 移动到柱子 z否则 输出 x,n,z; //注：若 n 为1 的话本句直接输出表示将 n 号盘子从 x 移动到 z递归，就是在运行的过程中调用自己。构成递归需具备的条件：函数嵌套调用过程示例1. 子问题须与原始问题为同样的事，且更为简单；2. 不能无限制地调用本身，须有个出口，化简为非递归状况处理。在数学和计算机科学中，递归指由一种（或多种）简单的基本情况定义的一类对象或方法，并规定其他所有情况都能被还原为其基本情况。

程序调用自身的编程技巧称为递归（ recursion）。递归作为一种算法在程序设计语言中广泛应用。 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。一般来说，递归需要有边界条件、递归前进段和递归返回段。当边界条件不满足时，递归前进；当边界条件满足时，递归返回。递归的缺点：递归算法解题相对常用的算法如普通循环等，运行效率较低。因此，应该尽量避免使用递归，除非没有更好的算法或者某种特定情况，递归更为适合的时候。在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。以上内容参考：百度百科-递归

1、定义是递归的：（1）n!的递归实现：递归方法：public class Method {    int fun(int n){    if(n==1)        return 1;    elsereturn(fun(n-1)*n);}}public class RecursionDemo {    public static void main (String[] args){Method m=new Method();      int num=m.fun(3);System.out.println(num);}}递归方法分析：（1）该方法是直接递归，即自己调用自己。例如：在执行fun(3)的时候，先执行fun（2）*3，而fun（2）=fun（1）*2，fun（1）=1。（2）递归过程将问题的规模逐步缩小，参数的大小每次减1。一个个重复的过程，通过调用自身，减少了代码量。（3）因为递归调用语句是在最后一句，因此，这种递归方式也称为尾递归。2、数据结构是递归的：       单链表的存储结构定义。3、问题的求解是递归的：#include<stdio.h> #include<malloc.h> #include<stdlib.h>#define LIST_INIT_SIZE 100 #define LISTINCREMENT 10#define OVERFLOW -2#define ERROR 0 #define OK 1typedef int ElemType; typedef struct{ //存储结构 ElemType *elem; //指针类型 int length; int listsize; }SqList;//顺序表的结构类型 typedef int Status; Status InitList(SqList &L){         L.elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));//动态分配存储空间 if(!L.elem) exit(OVERFLOW);  //分配失败退出 L.length=0;                  //空表 L.listsize=LIST_INIT_SIZE; //初始存储容量 return OK; }Status ListInsert(SqList &L,int i,ElemType e){//在第 i 个元素前插入一个新的元素e if(i<1 || i > L.length+1) return ERROR; //i值不合法 if(L.length>=L.listsize) //存储空间不足 { ElemType * newbase=(ElemType *)realloc(L.elem,(LIST_INIT_SIZE+LISTINCREMENT)*sizeof(ElemType)); if(!newbase) exit(OVERFLOW); //分配失败 L.elem=newbase; L.listsize=LIST_INIT_SIZE+LISTINCREMENT;} for (int j=L.length; j>=i; --j)L.elem[j]=L.elem[j-1]; L.elem[i-1]=e; L.length++;return OK; }Status ListEmpty(SqList L){ //判断顺序表是否为空return L.length == 0; }Status ListPrint(SqList &L) { printf(" 顺序表为： "); if (ListEmpty(L)) { printf(" 空。 "); return ERROR; } for (int i=0; i<L.length; ++i) { printf("%-4d ", L.elem[i]); } printf(" "); return OK; }int Sum(SqList L,int i){    if(i==L.length)    return 0;    elsereturn(L.elem[i]+Sum(L,i+1)); } main(){SqList L; ElemType e; int i,j; InitList(L); printf(" 请输入你想创建的顺序表中元素的个数： "); scanf("%d",&i); if(i<1) printf(" 您输入的值有误，无法创建顺序表。 "); else { printf(" 请您依次输入您想创建的顺序表的元素： "); for(j=1;j<=i;j++) { scanf("%d",&e); ListInsert(L,L.length+1,e); //尾插 } } ListPrint(L); //遍历顺序表 int result=Sum(L,0);printf( "顺序表所有元素的和为：%d",result);}这个程序是求解顺序表的元素的和，从顺序表的第一个元素开始，依次向后查找元素，并进行求和运算。

管理数据和信息只见的区别是相对的，一个系统或一次处理所输出的信息，可能是另一个系统或另一次处理的原始数据；低层决策所用的信息又可以成为加工处理高一层决策所需信息的数据，这就是信息间的递归定义

递归与迭代都是基于控制结构：迭代用重复结构，而递归用选择结构。递归与迭代都涉及重复：迭代显式使用重复结构，而递归通过重复函数调用实现重复。递归与迭代都涉及终止测试：迭代在循环条件失败时终止，递归在遇到基本情况时终止。使用计数器控制重复的迭代和递归都逐渐到达终止点：迭代一直修改计数器，直到计数器值使循环条件失败；递归不断产生最初问题的简化副本，直到达到基本情况。迭代和递归过程都可以无限进行：如果循环条件测试永远不变成false，则迭代发生无限循环；如果递归永远无法回推到基本情况，则发生无穷递归。递归函数是通过调用函数自身来完成任务，而且在每次调用自身时减少任务量。而迭代是循环的一种形式，这种循环不是由用户输入而控制，每次迭代步骤都必须将剩余的任务减少；也就是说，循环的每一步都必须执行一个有限的过程，并留下较少的步骤。

1、嵌套函数，就是指在某些情况下，您可能需要将某函数作为另一函数的参数使用。嵌套函数，就是指在某些情况下，您可能需要将某函数作为另一函数的参数使用，这一函数就是嵌套函数。一个为大家所熟知的例子就是qsort函数会将一个比较器cmp作为参数.又如图1中所示的公式使用了嵌套的 AVERAGE 函数，并将结果与 50 相比较。这个公式的含义是：如果单元格F2到F5的平均值大于50，则求F2到F5的和，否则显示数值0。又如，在一个程序中，主函数调用了sum函数，而在sum函数中又调用了mul函数。在一个函数被调用的过程中又调用另一个函数，这就是函数的嵌套调用。如果是函数本身嵌套调用函数本身，那就是函数递归调用了。2、递归，就是在运行的过程中调用自己。构成递归需具备的条件：函数嵌套调用过程示例1）子问题须与原始问题为同样的事，且更为简单；2）不能无限制地调用本身，须有个出口，化简为非递归状况处理。在数学和计算机科学中，递归指由一种（或多种）简单的基本情况定义的一类对象或方法，并规定其他所有情况都能被还原为其基本情况。例如，下列为某人祖先的递归定义：某人的双亲是他的祖先（基本情况）。某人祖先的双亲同样是某人的祖先（递归步骤）。斐波纳契数列（Fibonacci Sequence），又称黄金分割数列，指的是这样一个数列：1、1、2、3、5、8、13、21..... I 

递归就是程序不断的调用自己

递归英文：recursion。recurrence（n.）重现；重新提起；再发生；反复。recursion（n.）递归；递推；循环；递归定义；递推定义。例句：1、递归方法也需要显式的返回类型。Recursive methods also require an explicit return type.2、使递归函数不能得到正确的结果。So recursive function will not get the right results.3、否则, 使用递归函数计算阶乘。Otherwise, a recursive function is used to calculate the factorial.4、绪论：递归神经网络的基本概念。Introduction: the basic concept of RNN.5、提出采用递归子程序实现数值计算。And a recursive subroutine is presented to realize recursive algorithms.

应该不是要求编程吧？斐波纳契数列以如下被递归的方法定义：F（0）=0，F（1）=1，F（n）=F(n-1)+F(n-2)（n≥2，n∈N*）。

多看书，多编写点程序吧

一、含义不同：递归是重复调用函数自身实现循环。迭代是函数内某段代码实现循环，循环代码中参与运算的变量同时是保存结果的变量，当前保存的结果作为下一次循环计算的初始值。递归循环中，遇到满足终止条件的情况时逐层返回来结束。迭代则使用计数器结束循环。当然很多情况都是多种循环混合采用，这要根据具体需求。二、结构不同：递归与迭代都是基于控制结构：迭代用重复结构，而递归用选择结构。递归与迭代都涉及重复：迭代显式使用重复结构，而递归通过重复函数调用实现重复。递归与迭代都涉及终止测试：迭代在循环条件失败时终止，递归在遇到基本情况时终止，使用计数器控制重复的迭代和递归都逐渐到达终止点：迭代一直修改计数器，直到计数器值使循环条件失败；递归不断产生最初问题的简化副本，直到达到基本情况。递归算法一般用于解决三类问题：(1)数据的定义是按递归定义的。（Fibonacci函数）(2)问题解法按递归算法实现。这类问题虽则本身没有明显的递归结构，但用递归求解比迭代求解更简单，如Hanoi问题。(3)数据的结构形式是按递归定义的。如二叉树、广义表等，由于结构本身固有的递归特性，则它们的操作可递归地描述。以上内容参考：百度百科-递归

#include <stdio.h>long f(int n){return n == 0 ? 1: n*f(n-1);}int main(void){printf("%ld ", f(4) + f(6) + 7);return 0;}扩展资料：编程语言中，函数Func(Type a,……)直接或间接调用函数本身，则该函数称为递归函数。递归函数不能定义为内联函数。在数学上，关于递归函数的定义如下：对于某一函数f(x)，其定义域是集合A，那么若对于A集合中的某一个值X0，其函数值f(x0)由f(f(x0))决定，那么就称f(x)为递归函数。参考资料来源：百度百科-递归函数

树的定义　　树（tree）是包含n（n>0）个结点的有穷集合，其中：　　（1）每个元素称为结点（node）；　　（2）有一个特定的结点被称为根结点或树根（root）。　　（3）除根结点之外的其余数据元素被分为m（m≥0）个互不相交的结合T1，T2，……Tm-1，其中每一个集合Ti（1<=i<=m）本身也是一棵树，被称作原树的子树（subtree）。　　树也可以这样定义：树是有根结点和若干颗子树构成的。树是由一个集合以及在该集合上定义的一种关系构成的。集合中的元素称为树的结点，所定义的关系称为父子关系。父子关系在树的结点之间建立了一个层次结构。在这种层次结构中有一个结点具有特殊的地位，这个结点称为该树的根结点，或称为树根。　　我们可以形式地给出树的递归定义如下:　　单个结点是一棵树，树根就是该结点本身。　　设T1,T2,..,Tk是树，它们的根结点分别为n1,n2,..,nk。用一个新结点n作为n1,n2,..,nk的父亲，则得到一棵新树，结点n就是新树的根。我们称n1,n2,..,nk为一组兄弟结点，它们都是结点n的子结点。我们还称n1,n2,..,nk为结点n的子树。　　空集合也是树，称为空树。空树中没有结点

二叉树（binary tree）是指树中节点的度不大于2的有序树，它是一种最简单且最重要的树。二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树。二叉树是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。二叉树特点是每个结点最多只能有两棵子树，且有左右之分。二叉树的类型1、完全二叉树——若设二叉树的高度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第h层有叶子结点，并且叶子结点都是从左到右依次排布，这就是完全二叉树。2、满二叉树——除了叶结点外每一个结点都有左右子叶且叶子结点都处在最底层的二叉树。3、平衡二叉树——平衡二叉树又被称为AVL树（区别于AVL算法），它是一棵二叉排序树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

递归数列 （recursive sequence ）：一种用归纳方法给定的数列。一般地，递归数列的前k项a1，a1，…，ak为已知数，从第k+1项起，由某一递推公式=f（an，an+1，…an+k-1） ( n=1，2，…）所确定。k称为递归数列的阶数。例如 ，斐波那契数列，各项依次为 1 ，1 ，2 ，3，5 ，8 ，13 ，21 ，…，就是已知a1=1，a2=1，其余各项由公式an+1=an+an-1（n=2，3，…）确定的二阶递归数列。

double sum(int n){ if(n==1) { return 1; } else { return n+sum(n-1); }}

我查到一种说法是很通俗的： 首先，递归你可以想象成循环，每次循环，均属于自己独立的空间，而多次循环是累加，嵌套的。 可以把递归看做到楼顶取东西。从一楼爬，看，不是的，继续爬，每层楼梯看上去都一样，你执行的过程都一样，但是实际上，1到2，2到3的楼梯是两个楼梯，等你到楼顶了，取了东西，你不能直接就跳楼，还得从楼顶一层层退回来。 还有种属于for循环，如“驴子拉磨”，则无论跑多少次，都是在原地。

递归的主要方法是什么？一、递归算法 递归算法（英语：recursion algorithm）在计算机科学中是指一种通过重复将问题分解为同类的子问题而解决问题的方法。递归式方法可以被用于解决很多的计算机科学问题，因此它是计算机科学中十分重要的一个概念。绝大多数编程语言支持函数的自调用，在这些语言中函数可以通过调用自身来进行递归。计算理论可以证明递归的作用可以完全取代循环，因此在很多函数编程语言（如Scheme）中习惯用递归来实现循环。二、递归程序在支持自调的编程语言中，递归可以通过简单的函数调用来完成，如计算阶乘的程序在数学上可以定义为：这一程序在Scheme语言中可以写作：1(define (factorial n) (if (= n 0) 1 (* n (factorial (- n 1)))))不动点组合子即使一个编程语言不支持自调用，如果在这语言中函数是第一类对象（即可以在运行期创建并作为变量处理），递归可以通过不动点组合子（英语：Fixed-point combinator）来产生。以下Scheme程序没有用到自调用，但是利用了一个叫做Z 算子（英语：Z combinator）的不动点组合子，因此同样能达到递归的目的。1(define Z (lambda (f) ((lambda (recur) (f (lambda arg (apply (recur recur) arg)))) (lambda (recur) (f (lambda arg (apply (recur recur) arg)))))))(define fact (Z (lambda (f) (lambda (n) (if (<= n 0) 1 (* n (f (- n 1))))))))这一程序思路是，既然在这里函数不能调用其自身，我们可以用 Z 组合子应用(application)这个函数后得到的函数再应用需计算的参数。尾部递归尾部递归是指递归函数在调用自身后直接传回其值，而不对其再加运算。尾部递归与循环是等价的，而且在一些语言（如Scheme中）可以被优化为循环指令。 因此，在这些语言中尾部递归不会占用调用堆栈空间。以下Scheme程序同样计算一个数字的阶乘，但是使用尾部递归： 1(define (factorial n) (define (iter product counter) (if (> counter n) product (iter (* counter product) (+ counter 1)))) (iter 1 1))三、能够解决的问题数据的定义是按递归定义的。如Fibonacci函数。问题解法按递归算法实现。如Hanoi问题。数据的结构形式是按递归定义的。如二叉树、广义表等。 四、递归数据数据类型可以通过递归来进行定义，比如一个简单的递归定义为自然数的定义：“一个自然数或等于0，或等于另一个自然数加上1”。Haskell中可以定义链表为：1data ListOfStrings = EmptyList | Cons String ListOfStrings这一定义相当于宣告“一个链表或是空串列，或是一个链表之前加上一个字符串”。可以看出所有链表都可以通过这一递归定义来达到。

C 语言支持递归，即一个函数可以调用其自身。. 但在使用递归时，程序员需要注意定义一个从函数退出的条件，否则会进入死循环。. 递归函数在解决许多数学问题上起了至关重要的作用，比如计算一个数的阶乘、生成斐波那契数列

递归函数的就是从一个作业的，然后归到一个男生，然后实现递归需要一些特殊条件。

联系：都是问题求解之时的一种算法。区别：一、作用不同1、贪心算法：把子问题的解局部最优解合成原来解问题的一个解。2、递归算法：问题解法按递归算法实现。如Hanoi问题；数据的结构形式是按递归定义的。如二叉树、广义表等。3、动态规划：动态规划算法通常用于求解具有某种最优性质的问题。4、分治算法：可以再把它们分成几个更小的子问题，以此类推，直至可以直接求出解为止。二、方法不同1、贪心算法：在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，算法得到的是在某种意义上的局部最优解。2、递归算法：通过重复将问题分解为同类的子问题而解决问题。3、动态规划：将过程分成若干个互相联系的阶段，在它的每一阶段都需要作出决策，从而使整个过程达到最好的活动效果。4、分治算法：将一个规模为N的问题分解为K个规模较小的子问题。三、特点不同1、贪心算法：根据题意选取一种量度标准。2、递归算法：递归就是在过程或函数里调用自身。3、动态规划：虽然动态规划主要用于求解以时间划分阶段的动态过程的优化问题，但是一些与时间无关的静态规划(如线性规划、非线性规划)，只要人为地引进时间因素，把它视为多阶段决策过程，也可以用动态规划方法方便地求解。4、分治算法：原问题可以分解为多个子问题；原问题在分解过程中，递归地求解子问题；在求解并得到各个子问题的解后。

树的后序遍历是指先依次后序遍历每棵子树，然后访问根结点。当树用二叉树表示法(也叫孩子兄弟表示法)存储时，可以找到唯一的一棵二叉树与之对应，我们称这棵二叉树为该树对应的二叉树。那么根据这个法则可知，树的后序遍历序列等同于该树对应的二叉树的中序遍历。从二叉树的递归定义可知，一棵非空的二叉树由根结点及左、右子树这三个基本部分组成。因此，在任一给定结点上。⑴访问结点本身（N），⑵遍历该结点的左子树（L），⑶遍历该结点的右子树（R）。以上三种操作有六种执行次序：NLR、LNR、LRN、NRL、RNL、RLN。注意：前三种次序与后三种次序对称，故只讨论先左后右的前三种次序。从二叉树的递归定义可知，一棵非空的二叉树由根结点及左、右子树这三个基本部分组成。因此，在任一给定结点上。扩展资料：二叉树前序访问如下：从根结点出发，则第一次到达结点A，故输出A;继续向左访问，第一次访问结点B，故输出B；按照同样规则，输出D，输出H；当到达叶子结点H，返回到D，此时已经是第二次到达D，故不在输出D，进而向D右子树访问，D右子树不为空，则访问至I，第一次到达I，则输出I；I为叶子结点，则返回到D，D左右子树已经访问完毕，则返回到B，进而到B右子树，第一次到达E，故输出E；向E左子树，故输出J；按照同样的访问规则，继续输出C、F、G。二叉树中序访问如下：从根结点出发，则第一次到达结点A，不输出A，继续向左访问，第一次访问结点B，不输出B；继续到达D，H；到达H，H左子树为空，则返回到H，此时第二次访问H，故输出H；H右子树为空，则返回至D，此时第二次到达D，故输出D；由D返回至B，第二次到达B，故输出B；按照同样规则继续访问，输出J、E、A、F、C、G。参考资料来源：百度百科-二叉树参考资料来源：百度百科-二叉树遍历

递归：递归是一种重要的编程技术。该方法用于让一个函数从其内部调用其自身。一个示例就是计算阶乘。0 的阶乘被特别地定义为 1。 更大数的阶乘是通过计算 1 * 2 * ...来求得的。

链表，举例：struct mlink {int data;struct mlink *next; //属于递归定义，next是指向mlink结构的指针}

代码如下：public class Test {      public static void main(String[] args) {          System.out.println("结果是："+Test.foo(30));      }      /**      * 常见解法      */      public static int foo(int i){      int a=1,b=1;    int c=0;    for(int k=2;k<i;k++){//注意循环次数    c=a+b;    a=b;//注意这句要放在b=c之前    b=c;    }    return c;   }  }扩展资料递归思想的内涵：递归就是有去（递去）有回（归来）。“有去”是指：递归问题必须可以分解为若干个规模较小，与原问题形式相同的子问题，这些子问题可以用相同的解题思路来解决，就像上面例子中的钥匙可以打开后面所有门上的锁一样。“有回”是指 : 这些问题的演化过程是一个从大到小，由近及远的过程，并且会有一个明确的终点(临界点)，一旦到达了这个临界点，就不用再往更小、更远的地方走下去。最后，从这个临界点开始，原路返回到原点，原问题解决。更直接地说，递归的基本思想就是把规模大的问题转化为规模小的相似的子问题来解决。特别地，在函数实现时，因为解决大问题的方法和解决小问题的方法往往是同一个方法，所以就产生了函数调用它自身的情况，这也正是递归的定义所在。格外重要的是，这个解决问题的函数必须有明确的结束条件，否则就会导致无限递归的情况。

关于递归定义的函数，下列说法正确的是（）。 A.有些递归定义的函数可以“迭代计算”，有些递归定义的函数则必须“递归计算” B.递归定义的函数一定是“递归计算”的 C.递归定义的函数一定是“迭代计算”的 D.凡是可以“迭代计算”的函数，一定可以“递归计算”，凡是可以“递归计算”的函数，也一定可以“迭代计算” 正确答案：有些递归定义的函数可以“迭代计算”，有些递归定义的函数则必须“递归计算”

问题一：递归算法还不是很理解!!高手教一教! 递归（recursion）是指把一个大的问题转化为同样形式但小一些的问题加以解决的方法。C语言允许一个函数调用它本身，这就是递归调用。即在调用一个函数的过程中又直接或间接地调用函数本身。不加控制的递归都是无终止的自身调用，程序中是绝对不应该出现这种情况的。为了防止无休止的递归，程序中应控制递归的次数，在某条件成立时进行递归，条件不成立不进行递归调用。并且在递归的调用过程中，不断改变递归的条件，以使递归条件不再成立。 同一问题可能既可以用递归算法解决，也可以用非递归算法解决，递归往往算法设计简单，出奇制胜，而普通算法（通常用循环解决）往往设计稍复杂。但执行效率递归算法逊于循环算法。递归反复调用自己，需要占用较多内存和计算机时间。但有一些问题只有用递归方法才能解决，如著名的汉诺塔问题。 递归程序设计的关键就是考虑问题的两种情况，一种是普遍情况即函数值等于把问题递推一步后的本函数的调用，一种是极端或端点情况，此时函数值有确定的一个值而无须再调用本函数。递归的过程就是从普遍情况逐步过渡到端点情况的过程。 例子： 5个坐在一起论年龄，问第五个人多少岁？他说比第四个人大两岁。问第四个人多少岁，他说比第三个人大两岁。问第三个人多少岁，他说比第二个人大两岁。问第二个人多少岁，他说比第一个人大两岁。问第一个人多少岁，他说10岁。请问第五个人几岁？ int age(int n) { int x; if(n>1) x=age(n-1)+2; else if(n==1) x=10; return x; } void main( ) { printf(%d,age(5));} 问题二：什么是递归算法 递归算法就是一个函数通过不断对自己的调用而求得最终结果的一种思维巧妙但是开销很大的算法。 比如： 汉诺塔的递归算法： void move(char x,char y){ printf(%c-->%c ,x,y); } void hanoi(int n,char one,char two,char three){ /*将n个盘从one座借助two座，移到three座*/ if(n==1) move(one,three); else{ hanoi(n-1,one,three,two); move(one,three); hanoi(n-1,two,one,three); } } main(){ int n; printf(input the number of diskes:); scanf(%d,&n); printf(The step to moving %3d diskes: ,n); hanoi(n,"A","B","C"); } 我说下递归的理解方法 首先：对于递归这一类函数，你不要纠结于他是干什么的，只要知道他的一个模糊功能是什么就行，等于把他想象成一个能实现某项功能的黑盒子，而不去管它的内部操作先，好，我们来看下汉诺塔是怎么样解决的 首先按我上面说的把递归函数想象成某个功能的黑盒子，void hanoi(int n,char one,char two,char three); 这个递归函数的功能是：能将n个由小到大放置的小长方形从one 位置，经过two位置 移动到three位置。那么你的主程序要解决的问题是要将m个的汉诺块由A借助B移动到C，根据我们上面说的汉诺塔的功能，我相信傻子也知道在主函数中写道：hanoi(m,A,B,C)就能实现将m个块由A借助B码放到C，对吧？所以，mian函数里面有hanoi(m,"A","C","B");这个调用。 接下来我们看看要实现hannoi的这个功能，hannoi函数应该干些什么？ 在hannoi函数里有这么三行 hanoi(n-1,one,three,two); move(one,three); hanoi(n-1,two,one,three); 同样以黑盒子的思想看待他，要想把n个块由A经过B搬到C去，是不是可以分为上面三步呢？ 这三部是：第一步将除了最后最长的那一块以外的n-1块由one位置经由three搬到two 也就是从A由C搬到B 然后把最下面最长那一块用move函数把他从A直接搬到C 完事后 第三步再次将刚刚的n-1块借助hanno处函数的功能从B由A搬回到C 这样的三步实习了n块由A经过B到C这样一个功能，同样你不用纠结于hanoi函数到底如何实现这个功能的，只要知道他有这么一个神奇的功能就行 最后：递归都有收尾的时候对吧，收尾就是当只有一块的时候汉诺塔怎么个玩法呢？很简单吧，直接把那一块有Amove到C我们就完成了，所以hanoni这个函数最后还要加上 if(n==1)move(one,three);（当只有一块时，直接有Amove到C位置就行）这么一个条件就能实现hanoin函数n>=1时......>> 问题三：怎么更好地终极理解递归算法 递归的基本思想是把规模大的问题转化为规模小的相似的子问题来解决。在函数实现时，因为解决大问题的方法和解决小问题的方法往往是同一个方法，所以就产生了函数调用它自身的情况。另外这个解决问题的函数必须有明显的结束条件，这样就不会产生无限递归的情况了。 需注意的是，规模大转化为规模小是核心思想，但递归并非是只做这步转化，而是把规模大的问题分解为规模小的子问题和可以在子问题解决的基础上剩余的可以自行解决的部分。而后者就是归的精髓所在，是在实际解决问题的过程。 问题四：怎样才能深刻理解递归和回溯？ 递归的精华就在于大问题的分解，要学会宏观的去看问题，如果这个大问题可分解为若干个性质相同的规模更小的问题，那么我们只要不断地去做分解，当这些小问题分解到我们能够轻易解决的时候，大问题也就能迎刃而解了。如果你能独立写完递归创建二叉树，前序、中序、后序递归遍历以及递归计算二叉树的最大深度，递归就基本能掌握了。 回溯本人用得很少，仅限于八皇后问题，所以帮不上啥了。 问题五：二叉树的递归算法到底该怎么理解 这不就是在二叉排序树上的递归查找，看程序 tree& find(const T& d, tree& t){ if(t==NULL) return t;如果二叉树为空则返回空，查找失败 if(t->data==d) return t;否则，如果当前根结点关键码为d，则查找成功，当前根结点为待查找结点 if(d>t->data) return find(d, t->right);如果比根的关键码大就递归查找右子树 return find(d, t->left);如果比根的关键码小就递归查找左子树 } 二叉树的递归定义的含义就是非空二叉树，除了根以外，左右子树都是二叉树（可以为空） 问题六：怎么理解递归算法?我看了代码但还是不理解? 函数自己调用自己就是递归啊。 从前有座山，山里有座庙，庙里有个老和尚给小和尚讲故事。讲的内容是： 从前有座山，山里有座庙，庙里有个老和尚给小和尚讲故事，讲 从前有座山，山里有座庙，庙里有个老和尚给小和尚讲故事…… 跟循环差不多。而且浪费栈空间，效率不高。能够转化为循环最好。 问题七：数据结构中的二叉树中的递归怎么理解？ 以中序遍历为例，思想是： 若二叉树为空，则空操作；否则 （1）中序遍历左子树 （中序遍历左子树时也是这三步） （2）访问根结点 （3）中序遍历右子树 （当然右子树也是重复着三步） 示例代码： int InOrderTraverse(BiTree T) { if(T) { InOrderTraverse(T->lchild); printf(%d ,T->data); InOrderTraverse(T->rchild); } return OK; } 问题八：java递归算法，怎么理解？？？ n! = (n-1)*n！ 简单理解，就是目前的所有任务，等于前面所有的任务+现在的任务。 比如你求 1。。。100的加法总和 实际上是 1... 99 的加法总和 + 100 就是了。 这就是递归的来源。 你只需要计算你前一步的任务，然后加上自己，就OK了。 前一步，在再次调用前前一步...... 问题九：新手一个，有什么更好理解递归的方法吗？（c++） 递归的话就是重复调用方法直到满足条件为止就停止这个方法，就跟循环类似，不过循环使用的方法一边比较简单 问题十：递归的原理解释 递归的底层实现其实是一个栈.栈的特点是后进先出,也就是最后进入栈的事件是最先被处理的. 递归就是这样运作.比如计算阶乘函数F(n)=n!=n*F(n-1)=.... 写成递归,我用java public static long F(long num){ if(num

如果一个整数N的绝对值等于0，那么N是一个偶数；否则N的奇偶性与它的绝对值减2的整数N"的奇偶性相同。

当然是可以的

1、主方法求解递归式一种求解大部分递归式的公式。给出递归式: T(n) = a * T(n/b) + f(n) ，其中a>=1，b>1，f(n)是给定的函数，T(n)是定义在非负整数上的递归式。2、递归树求解用主方法求解不了的递归式，我们可以用递归树来猜测解的上界，然后用代入法来证明解的正确性。递归树的求解精确度取决于画递归树的精确度。3、代入法比如我们求解，递归式T(n) = 2T(n/2)+n，我们猜测解是O(nlgn)，我们要寻找到一个常数c，使得T(n)<=cnlgn。即T(n) <= 2c(n/2)lg(n/2)+n <= cnlgn-cnlg2+n = cnlgn-cn+n只要c>=1，T(n)<=cnlgn，所以我们的猜测是正确的。要注意的是，代入法全凭经验，通常用递归树来确定上界，然后用代入法再证明。扩展资料：设p0，p1，…，pn，…是一个序列。如果pn和序列中在它前面的若干项联系起来的一个关系式对所有大于等于某个整数n0的整数n都是有效的，则称这个关系式为递归关系(recursive relation)式。如：设(a0，a1，...，ar，...)是一个序列，把该序列中的ar和它前面的几个ai(0≤i<r)关联起来的方程称做一个递归关系。如关系式:ar=3ar-1 (r≥1)和错排数:Dn=(n-1)(Dn-1+Dn-2) (n=3，4，...)，都是递归关系。

int rev(int i){ if(i<5) rev(i++); else return i;}

将一类需要调自身的算法，称为递归。就是需要不断循环算法本身，直到达成条件。递归就是解决这种算法而写出的函数；递归的缺点，是由于要大量调用函数自身，从而产生了大量的进栈操作，从而对栈内存造成巨大压力，如果栈过小，而算法循环次数太多的，很容易导致栈溢出。

递归函数是数论函数的一种，其定义域与值域都是自然数集，只是由于构作函数方法的不同而有别于其他的函数。 最简单又最基本的函数有三个：零函数，射影函数，后继函数，它们合称初始函数。 要想由旧函数作出新函数，必须使用各种算子。在数理逻辑和计算机科学中，递归函数是一类从自然数到自然数的函数，它是在某种直觉意义上是"可计算的"。事实上，在可计算性理论中证明了递归函数精确的是图灵机的可计算函数。

bitree是二叉树的结点，类型为node，lchild是左子节点，rchild是右子节点，两个子节点又同时拥有它们的子节点（就是和他们的父节点一样）。和递归函数中的局部变量一样，lchild和rchild也可理解为“二叉树定义中的局部变量”，所以那并不是指向本身。

为了描述问题的某一状态，必须用到该状态的上一状态，而描述上一状态，又必须用到上一状态的上一状态……这种用自已来定义自己的方法，称为递归定义。形式如 f(n) = n * f(n - 1), if n = 0, f(n) = 1. 从问题的某一种可能出发，搜索从这种情况出发所能达到的所有可能，当这一条路走到“尽头”的时候，再倒回出发点，从另一个可能出发，继续搜索。这种不断“反悔”寻找解的方法，称作“回溯法”。 递归法好比是一个军队要通过一个迷宫，到了第一个分岔口，有 3 条路，将军命令 3 个小队分别去探哪条路能到出口，3 个小队沿着 3 条路分别前进，各自到达了路上的下一个分岔口，于是小队长再分派人手各自去探路——只要人手足够（对照而言，就是计算机的堆栈足够），最后必将有人找到出口，从这人开始只要层层上报直属领导，最后，将军将得到一条通路。所不同的是，计算机的递归法是把这个并行过程串行化了。 而回溯法则是一个人走迷宫的思维模拟，其实是一种试探，走错了倒回来，继续走。该方法放弃关于问题规模大小的限制，并将问题的方案按某种顺序逐一枚举和试验。发现当前方案不可能有解时，就选择下一个方案，倘若当前方案不满足问题的要求时，继续扩大当前方案的规模，并继续试探。如果当前方案满足所有要求时，该方案就是问题的一个解。 放弃当前方案，寻找下一方案的过程称为回溯。 递归算法依赖与前一步的结果，它的结果来源于一条主线，是确定的，而不是试探的结果，这就是其与回溯的区别，而在很多情况下，回溯与递归算法是在一起使用的。 递归会出现在子程序中自己调用自己或间接地自己调用自己。最直接的递归应用就是计算连续数的阶乘，计算规律：n! = (n - 1)! * n。观察阶乘计算的规律，前一个数结成的结果可以直接被应用到后一个数结成的计算中。 回溯是一种算法思想，可以用递归实现。通俗点讲回溯就是一种试探，类似于穷举，但回溯有“剪枝”功能，比如求和问题。给定 7 个数字，1 2 3 4 5 6 7 求和等于 7 的组合，从小到大搜索，选择 1 + 2 + 3 + 4 = 10 > 7，已经超过了 7，之后的 5 6 7 就没必要在继续了，这就是一种搜索过程的优化。比如 8 皇后问题。

递归在数学与计算机科学中，是指在函数的定义中使用函数自身的方法。递归一词还较常用于描述以自相似方法重复事物的过程。例如，当两面镜子相互之间近似平行时，镜中嵌套的图像是以无限递归的形式出现的。一般用在可以被简化成各个小问题的复杂大问题里。斐波那契数列是典型的递归案例：Fib(0) = 0 [基本情况]Fib(1) = 1 [基本情况]对所有n > 1的整数：Fib(n) = (Fib(n-1) + Fib(n-2)) [递归定义]

首先要理解递归本身其实是一项非常重要的算法技巧。递归满足两个条件：1，不断调用函数本身，也就是递归函数。2，调用是有限的，也就是递归出口。为了理解方便，下面是用一个最简单的例子：求n的阶乘。n!(阶乘)定义：n!数学意思为n!=n*(n-1)!&1!=1;其实根据上面递归定义结合分析下就可以n阶乘的递归算法：1,构造一个递归函数,不断乘以自身和使用自身减一后调用同样函数．2,定义出口，当函数参数等于1时结束;如果用isoc++语言描述如下：intfactorial(intn){if(n>1){returnn*factorial(n-1);//递归函数调用}elseif(n==1){return1;//递归出口}else{returnerror;//报告输入错误}}这里讨论主要的不是上面这个简单的例子，而是下面的一些改良．因为递归设计大量的堆栈操作，所以一般都会考虑将递归转为非递归来执行．这里用上面这个程序作一个分析例子来分析．假设这里执行factorial(4)，那么程序会按照下面方式来执行：(1)执行factorial(4)判断n>1执行factorial(3),并且将factorial(4)函数相关信息存入一个堆栈．(2)执行factorial(3)判断n>1执行factorial(2),并且将factorial(3)函数相关信息存入一个堆栈．(3)执行factorial(2)判断n>1执行factorial(1),并且将factorial(2)函数相关信息存入一个堆栈．(4)执行factorial(1)判断n==1执行返回1;(5)将factorial(2)函数从堆栈中弹出，执行2*1，并且返回2．(6)将factorial(3)函数从堆栈中弹出，执行2*3，并且返回6．(7)将factorial(4)函数从堆栈中弹出，执行6*4，并且返回24．如下图所示：factorial(4)-->factorial(3);-->factorial(2);-->factorail(1);<--factorail(1);<--factorial(2);<--factorial(3);<--结果可以看到中间涉及的堆栈操作是很大的开销，每次需要保存当前函数的所有信息．为了避免这样情况，可以使用下面这几种方法来实现递归到非递归的转换．(1)循环方法循环方法是所有递归到非递归的转换中最理想的方法，可以将开销减少到最小．不过也是分析起来最复杂的，对于简单的递归可以用这样的方法来处理．例如：factorial计算这里回到n!(阶乘)定义上面来分析，这里将n!数学意思为n!=n*(n-1)!&1!=1;做一个扩展可以到到n!另外一个表示方法n!=n*(n-1)*(n-2)*....*1;这样就可以很容易得到另外一个定义：n!表示执行n次循环计算一个增量k，初始k=1和结果t=1;每次t乘以k++的值.isoc++实现代码如下：factorial(intn){intk=1;//增量intt=1;//临时结果while(k!=n){t*=k;k++;}returnt;}这样可以避免递归带来的大量堆栈操作．(2)自定义堆栈对于复杂逻辑的堆栈操作，需要借助外部堆栈来实现．因为对于所有的递归操作最后分析出来都是形成的一颗树形结构．下面是一个递归实现factorial的一个方法，虽然在这个程序中对比循环来相对复杂，不过对于一些不能分析出来循环的递归操作来说自定义堆栈的方法可以达到空间开销可控．factorial(intn){stacks;intt=1;//临时变量s.push(n);while(s.top()!=1)[t*=s.top();s.push(s.top()-1);s.pop();}returnt;}除了上面这两种方法外，还可以使用一种迭代的方法实现递归到非递归的处理．

程序调用自身的编程技巧称为递归（ recursion）。递归作为一种算法在程序设计语言中广泛应用。 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。一般来说，递归需要有边界条件、递归前进段和递归返回段。当边界条件不满足时，递归前进；当边界条件满足时，递归返回。递归的缺点：递归算法解题相对常用的算法如普通循环等，运行效率较低。因此，应该尽量避免使用递归，除非没有更好的算法或者某种特定情况，递归更为适合的时候。在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。以上内容参考：百度百科-递归

递归是程序调用自身的编程技巧。递归作为一种算法在程序设计语言中广泛应用。 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。一般来说，递归需要有边界条件、递归前进段和递归返回段。当边界条件不满足时，递归前进；当边界条件满足时，递归返回。

一句话，用整体思维看待问题，你会用整体法来分析力，递归就不成问题，当然意义绝不仅如此。

递归 就是 函数掉用自己或间接的调用自己

1、程序调用自身的编程技巧称为递归。递归做为一种算法在程序设计语言中广泛应用。一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。一般来说，递归需要有边界条件、递归前进段和递归返回段。当边界条件不满足时，递归前进；当边界条件满足时，递归返回。x0dx0ax0dx0a2、递归一般的作用用于解决三类问题：x0dx0a(1)数据的定义是按递归定义的。（Fibonacci函数）x0dx0a(2)问题解法按递归算法实现。x0dx0a这类问题虽则本身没有明显的递归结构，但用递归求解比迭代求解更简单，如Hanoi问题。x0dx0a(3)数据的结构形式是按递归定义的。

1、程序调用自身的编程技巧称为递归。递归做为一种算法在程序设计语言中广泛应用。 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。一般来说，递归需要有边界条件、递归前进段和递归返回段。当边界条件不满足时，递归前进；当边界条件满足时，递归返回。2、递归一般的作用用于解决三类问题：(1)数据的定义是按递归定义的。（Fibonacci函数）(2)问题解法按递归算法实现。这类问题虽则本身没有明显的递归结构，但用递归求解比迭代求解更简单，如Hanoi问题。(3)数据的结构形式是按递归定义的。

.... 上面太长了 我给你举个例子 树是什么知道吧 树 就是递归定义的 就是 什么是 树呢? 树就是 有很多 子树构成的 对吧 你想一下 这就是递归定义 就是一层套一层

也就是一个函数的中再调用该函数，也就是说是循环的递归调用，但必须得有一个判断结束的条件，否则都成了死循环！

程序调用自身的编程技巧称为递归（ recursion）。 　　一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。一般来说，递归需要有边界条件、递归前进段和递归返回段。当边界条件不满足时，递归前进；当边界条件满足时，递归返回。 　　注意： 　　(1) 递归就是在过程或函数里调用自身; 　　(2) 在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。　递归算法一般用于解决三类问题： 　　(1)数据的定义是按递归定义的。(Fibonacci函数) 　　(2)问题解法按递归算法实现。(回溯) 　　(3)数据的结构形式是按递归定义的。(树的遍历，图的搜索) 　　递归的缺点： 　　递归算法解题的运行效率较低。在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。 　　例子： 　　#include <iostream.h> 　　void move (char getone,char putone) 　　{ 　　cout <<getone<<"-->"<} 　　void hanoi(int n,char one ,char two ,char three) 　　{ 　　void move (char getone,char putone ); 　　if (n==1) 　　move (one,three); 　　else 　　{ 　　hanoi(n-1,one,three,two); 　　move (one ,three); 　　hanoi(n-1,two,one,three); 　　} 　　} 　　void main() 　　{ 　　void hanoi(int n ,char one ,char two ,char three); 　　int m ; 　　cout <<"Input the numberof disker:"; 　　cin>>m; 　　cout<<"the steps to moving "<<m<<"diskes 　　:"<<endl; 　　hanoi(m,"A","B","C"); 　　} 　　如: 　　procedure a; 　　begin 　　a; 　　end; 　　这种方式是直接调用. 　　又如: 　　procedure b; 　　begin 　　c; 　　end; 　　procedure c; 　　begin 　　b; 　　end; 　　这种方式是间接调用. 　　例1计算n!可用递归公式如下: 　　1 当 n=0 时 　　fac(n)={n*fac(n-1) 当n>0时 　　可编写程序如下: 　　program fac2; 　　var 　　n:integer; 　　function fac(n:integer):real; 　　begin 　　if n=0 then fac:=1 else fac:=n*fac(n-1)； 　　end; 　　begin 　　write("n=");readln(n); 　　writeln("fac(",n,")=",fac(n):6:0); 　　end. 　　例2 楼梯有n阶台阶,上楼可以一步上1阶,也可以一步上2阶,编一程序计算共有多少种不同的走法. 　　设n阶台阶的走法数为f(n) 　　显然有 　　1 n=1 　　f(n)={2 n=2 　　f(n-1)+f(n-2) n>2 　　可编程序如下： 　　program louti; 　　var n:integer; 　　function f(x:integer):integer; 　　begin 　　if x=1 then f:=1 else 　　if x=2 then f:=2 else f:=f(x-1)+f(x-2); 　　end; 　　begin 　　write("n=");read(n); 　　writeln("f(",n,")=",f(n)) 　　end. 　　2.2 如何设计递归算法 　　1.确定递归公式 　　2.确定边界(终了)条件 　　练习: 　　用递归的方法完成下列问题 　　1.求数组中的最大数 　　2.1+2+3+...+n 　　3.求n个整数的积 　　4.求n个整数的平均值 　　5.求n个自然数的最大公约数与最小公倍数 　　6.有一对雌雄兔,每两个月就繁殖雌雄各一对兔子.问n个月后共有多少对兔子? 　　7.已知:数列1,1,2,4,7,13,24,44,...求数列的第 n项. 　　2.3典型例题 　　例3 梵塔问题 　　如图:已知有三根针分别用1,2,3表示,在一号针中从小放n个盘子,现要求把所有的盘子 　　从1针全部移到3针,移动规则是:使用2针作为过度针,每次只移动一块盘子,且每根针上 　　不能出现大盘压小盘.找出移动次数最小的方案. 　　程序如下: 　　program fanta; 　　var 　　n:integer; 　　procedure move(n,a,b,c:integer); 　　begin 　　if n=1 then writeln(a,"--->",c) 　　else begin 　　move(n-1,a,c,b); 　　writeln(a,"--->",c); 　　move(n-1,b,a,c); 　　end; 　　end; 　　begin 　　write("Enter n="); 　　read(n); 　　move(n,1,2,3); 　　end. 　　例4 快速排序 　　快速排序的思想是:先从数据序列中选一个元素,并将序列中所有比该元素小的元素都放到它的右边或左边,再对左右两边分别用同样的方法处之直到每一个待处理的序列的长度为1, 处理结束. 　　程序如下: 　　program kspv; 　　var 　　a:array[0..10000] of longint; 　　i:integer; 　　procedure quicksort(l,r:longint); 　　var i,j,mid:longint; 　　begin 　　i:=l;j:=r;mid:=a[(l+r) div 2]; 　　repeat 　　while a[i]<mid do inc(i); 　　while a[j]>mid do dec(j); 　　if i<=j then 　　begin 　　a[0]:=a[i];a[i]:=a[j];a[j]:=a[0]; 　　inc(i);dec(j); 　　until i>j; 　　if i<r then quicksort(i,r); 　　if l<j then quicksort(l,j); 　　end; 　　begin 　　write("input data:"); 　　readln(n); 　　for i:=1 to n do read(a[i]); 　　writeln; 　　quicksort(1,n); 　　write("output data:"); 　　for i:=1 to n do write(a[i]," "); 　　writeln; 　　end.

一、含义不同：递归是重复调用函数自身实现循环。迭代是函数内某段代码实现循环，循环代码中参与运算的变量同时是保存结果的变量，当前保存的结果作为下一次循环计算的初始值。递归循环中，遇到满足终止条件的情况时逐层返回来结束。迭代则使用计数器结束循环。当然很多情况都是多种循环混合采用，这要根据具体需求。二、结构不同：递归与迭代都是基于控制结构：迭代用重复结构，而递归用选择结构。 递归与迭代都涉及重复：迭代显式使用重复结构，而递归通过重复函数调用实现重复。 递归与迭代都涉及终止测试：迭代在循环条件失败时终止，递归在遇到基本情况时终止，使用计数器控制重复的迭代和递归都逐渐到达终止点：迭代一直修改计数器，直到计数器值使循环条件失败；递归不断产生最初问题的简化副本，直到达到基本情况。递归算法一般用于解决三类问题：(1)数据的定义是按递归定义的。（Fibonacci函数）(2)问题解法按递归算法实现。这类问题虽则本身没有明显的递归结构，但用递归求解比迭代求解更简单，如Hanoi问题。(3)数据的结构形式是按递归定义的。如二叉树、广义表等，由于结构本身固有的递归特性，则它们的操作可递归地描述。以上内容参考：百度百科-递归

递归算法是一种使用递归的计算方法，即在函数的定义中使用函数自身的计算方法。递归算法可以用来解决许多计算问题，例如搜索、排序和递推。递归算法通常包括一个基本情况（即不再使用递归的情况）和一个递归情况，在递归情况中，函数调用自身来解决更小的问题。

是指函数/过程/子程序在运行过程序中直接或间接调用自身而产生的重入现象。在计算机编程里，递归指的是一个过程：函数不断引用自身，直到引用的对象已知。使用递归解决问题，思路清晰，代码少。但是在主流高级语言中（如C语言、Pascal语言等）使用递归算法要耗用更多的栈空间，所以在堆栈尺寸受限制时（如嵌入式系统或者内核态编程），应避免采用。所有的递归算法都可以改写成与之等价的非递归算法。汉诺塔问题，是常见可用递归解决的问题，不过也有非递归的解法。菲波纳契数列可用递归定义。以下为求汉诺塔问题的Pascal程序：procedure Hanoi(n:integer;x,y,z:char);beginif n<>1 then beginHanoi(n-1,x,z,y);writeln(x,n,z);Hanoi(n-1,y,x,z);else writeln(x,n,z);end;end;上述程序用接近自然语言的伪代码可表述如下：Hanoi 过程 (整型参数n; 字符型参数 x,y,z);//注：n 代表本步中要处理的盘子数，x,y,z 分别表示 n 号盘子原来所在柱子、经由柱子、目标柱子开始如果 n 不为 1 ，那么：开始调用 Hanoi 过程 (参数为 n-1,x,z,y);//注：这一步表示用本过程方法将剩余 n-1 个盘子从柱子 x 经由柱子 z 移动到柱子 y输出 x,n,z; //注：表示将 n 号盘子从 x 移动到 z调用 Hanoi 过程 (参数为 n-1,y,x,z);//注：这一步表示用本过程方法将剩余 n-1 个盘子从柱子 y 经由柱子 x 移动到柱子 z结束; //以上程序段就完成了把 n 个盘子从柱子 x 经由柱子 y 移动到柱子 z否则 输出 x,n,z; //注：若 n 为1 的话本句直接输出表示将 n 号盘子从 x 移动到 z结束;

递归做为一种算法在程序设计语言中广泛应用.是指函数/过程/子程序在运行过程序中直接或间接调用自身而产生的重入现像.　　程序调用自身的编程技巧称为递归（ recursion）。 　　一个过程或函数在其定义或说明中又直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。用递归思想写出的程序往往十分简洁易懂。 　　一般来说，递归需要有边界条件、递归前进段和递归返回段。当边界条件不满足时，递归前进；当边界条件满足时，递归返回。 　　注意： 　　(1) 递归就是在过程或函数里调用自身; 　　(2) 在使用递增归策略时，必须有一个明确的递归结束条件，称为递归出口。　　递归算法一般用于解决三类问题：　　(1)数据的定义是按递归定义的。(Fibonacci函数)　　(2)问题解法按递归算法实现。(回溯)　　(3)数据的结构形式是按递归定义的。(树的遍历，图的搜索)　　递归的缺点：　　递归算法解题的运行效率较低。在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。原理及详解: http://baike.baidu.com/view/96473.htm