迭代法 递归 区别

迭代法

求助编辑
迭代法   
迭代法

迭代法也称辗转法,是一种不断用变量的旧值递推新值的过程,跟迭代法相对应的是直接法(或者称为一次解法),即一次性解决问题。迭代法又分为精确迭代和近似迭代。“二分法”和“牛顿迭代法”属于近似迭代法。迭代算法是用计算机解决问题的一种基本方法。它利用计算机运算速度快、适合做重复性操作的特点,让计算机对一组指令(或一定步骤)进行重复执行,在每次执行这组指令(或这些步骤)时,都从变量的原值推出它的一个新值。

目录

算法
递归的基本概念和特点
展开

编辑本段算法

   迭代 数值分析 中通过从一个 初始 估计 出发寻找一系列近似解来解决问题(一般是解 方程 或者 方程组 )的过程,为实现这一过程所使用的方法统称为 迭代法 (Iterative Method)。
  一般可以做如下定义:对于给定的线性方程组 x = Bx + f (这里的 x B f 同为 矩阵 ,任意线性方程组都可以变换成此形式),用公式 x (k+1)= Bx (k)+ f (括号中为上标,代表迭代k次得到的 x ,初始时k=0)逐步带入求近似解的方法称为 迭代法 (或称一阶定常迭代法)。如果k趋向无穷大时lim x (k)存在,记为 x *,称此 迭代法收敛 。显然 x *就是此方程组的解,否则称为 迭代法发散
  跟迭代法相对应的是 直接法 (或者称为一次解法),即一次性的快速解决问题,例如通过开方解决方程 x  +3= 4。一般如果可能,直接解法总是优先考虑的。但当遇到复杂问题时,特别是在未知量很多,方程为非线性时,我们无法找到直接解法(例如五次以及更高次的 代数方程 没有 解析解 ,参见 阿贝耳定理 ),这时候或许可以通过迭代法寻求方程(组)的近似解。
  最常见的迭代法是 牛顿法 。其他还包括 最速下降法 、共轭迭代法、变尺度迭代法、 最小二乘法 线性规划 非线性规划 、单纯型法、惩罚函数法、斜率投影法、 遗传算法 模拟退火 等等。
  利用迭代算法解决问题,需要做好以下三个方面的工作:

确定迭代变量

  在可以用迭代算法解决的问题中,至少存在一个直接或间接地不断由旧值递推出新值的变量,这个变量就是迭代变量。

建立迭代关系式

  所谓迭代关系式,指如何从变量的前一个值推出其下一个值的公式(或关系)。迭代关系式的建立是解决迭代问题的关键,通常可以顺推或倒推的方法来完成。

对迭代过程进行控制

  在什么时候结束迭代过程?这是编写迭代程序必须考虑的问题。不能让迭代过程无休止地重复执行下去。迭代过程的控制通常可分为两种情况:一种是所需的迭代次数是个确定的值,可以计算出来;另一种是所需的迭代次数无法确定。对于前一种情况,可以构建一个固定次数的循环来实现对迭代过程的控制;对于后一种情况,需要进一步分析出用来结束迭代过程的条件。

举例

  例 1 : 一个饲养场引进一只刚出生的新品种兔子,这种兔子从出生的下一个月开始,每月新生一只兔子,新生的兔子也如此繁殖。如果所有的兔子都不死去,问到第 12 个月时,该饲养场共有兔子多少只?
  分析: 这是一个典型的递推问题。我们不妨假设第 1 个月时兔子的只数为 u 1 ,第 2 个月时兔子的只数为 u 2 ,第 3 个月时兔子的只数为 u 3 ,……根据题意,“这种兔子从出生的下一个月开始,每月新生一只兔子”,则有
  u 1 = 1 , u 2 = u 1 + u 1 × 1 = 2 , u 3 = u 2 + u 2 × 1 = 4 ,……
  根据这个规律,可以归纳出下面的递推公式:
  u n = u( n - 1 )× 2 (n ≥ 2)
  对应 u n 和 u( n - 1 ),定义两个迭代变量 y 和 x ,可将上面的递推公式转换成如下迭代关系:
  y=x*2
  x=y
  让计算机对这个迭代关系重复执行 11 次,就可以算出第 12 个月时的兔子数。参考程序如下:
  cls
  x=1
  for i=2 to 12
  y=x*2
  x=y
  next i
  print y
  end
  例 2 : 阿米巴用简单分裂的方式繁殖,它每分裂一次要用 3 分钟。将若干个阿米巴放在一个盛满营养参液的容器内, 45 分钟后容器内充满了阿米巴。已知容器最多可以装阿米巴 220,220个。试问,开始的时候往容器内放了多少个阿米巴?请编程序算出。
  分析: 根据题意,阿米巴每 3 分钟分裂一次,那么从开始的时候将阿米巴放入容器里面,到 45 分钟后充满容器,需要分裂 45/3=15 次。而“容器最多可以装阿米巴2^ 20 个”,即阿米巴分裂 15 次以后得到的个数是 2^20 。题目要求我们计算分裂之前的阿米巴数,不妨使用倒推的方法,从第 15 次分裂之后的 2^20 个,倒推出第 15 次分裂之前(即第 14 次分裂之后)的个数,再进一步倒推出第 13 次分裂之后、第 12 次分裂之后、……第 1 次分裂之前的个数。
  设第 1 次分裂之前的个数为 x 0 、第 1 次分裂之后的个数为 x 1 、第 2 次分裂之后的个数为 x 2 、……第 15 次分裂之后的个数为 x 15 ,则有
  x 14 =x 15 /2 、 x 13 =x 14 /2 、…… x n-1 =x n /2 (n ≥ 1)
  因为第 15 次分裂之后的个数 x 15 是已知的,如果定义迭代变量为 x ,则可以将上面的倒推公式转换成如下的迭代公式:
  x=x/2 ( x 的初值为第 15 次分裂之后的个数 2^20 )
  让这个迭代公式重复执行 15 次,就可以倒推出第 1 次分裂之前的阿米巴个数。因为所需的迭代次数是个确定的值,我们可以使用一个固定次数的循环来实现对迭代过程的控制。参考程序如下:
  cls
  x=2^20
  for i=1 to 15
  x=x/2
  next i
  print x
  end
   ps: java中幂的算法是Math.pow(2, 20);返回double,稍微注意一下
  例 3 : 验证谷角猜想。日本数学家谷角静夫在研究自然数时发现了一个奇怪现象:对于任意一个自然数 n ,若 n 为偶数,则将其除以 2 ;若 n 为奇数,则将其乘以 3 ,然后再加 1 。如此经过有限次运算后,总可以得到自然数 1 。人们把谷角静夫的这一发现叫做“谷角猜想”。
  要求:编写一个程序,由键盘输入一个自然数 n ,把 n 经过有限次运算后,最终变成自然数 1 的全过程打印出来。
  分析: 定义迭代变量为 n ,按照谷角猜想的内容,可以得到两种情况下的迭代关系式:当 n 为偶数时, n=n/2 ;当 n 为奇数时, n=n*3+1 。用 QBASIC 语言把它描述出来就是:
  if n 为偶数 then
  n=n/2
  else
  n=n*3+1
  end if
  这就是需要计算机重复执行的迭代过程。这个迭代过程需要重复执行多少次,才能使迭代变量 n 最终变成自然数 1 ,这是我们无法计算出来的。因此,还需进一步确定用来结束迭代过程的条件。仔细分析题目要求,不难看出,对任意给定的一个自然数 n ,只要经过有限次运算后,能够得到自然数 1 ,就已经完成了验证工作。因此,用来结束迭代过程的条件可以定义为: n=1 。参考程序如下:
  cls
  input "Please input n=";n
  do until n=1
  if n mod 2=0 then
  rem 如果 n 为偶数,则调用迭代公式 n=n/2
  n=n/2
  print "—";n;
  else
  n=n*3+1
  print "—";n;
  end if
  loop
  end
  迭代法开平方:
  #include<stdio.h>
  #include<math.h>
  void main()
  {
  double a,x0,x1;
  printf("Input a:\n");
  scanf("%lf",&a);//为什么在VC6.0中不能写成“scanf("%f",&a);”?
  if(a<0)
  printf("Error!\n");
  else
  {
  x0=a/2;
  x1=(x0+a/x0)/2;
  do
  {
  x0=x1;
  x1=(x0+a/x0)/2;
  }while(fabs(x0-x1)>=1e-6);
  }
  printf("Result:\n");
  printf("sqrt(%g)=%g\n",a,x1);
  }
  求平方根的迭代公式:x1=1/2*(x0+a/x0)。
  算法:1.先自定一个初值x0,作为a的平方根值,在我们的程序中取a/2作为a的初值;利用迭代公式求出一个x1。此值与真正的a的平方根值相比,误差很大。
  2.把新求得的x1代入x0中,准备用此新的x0再去求出一个新的x1.
  3.利用迭代公式再求出一个新的x1的值,也就是用新的x0又求出一个新的平方根值x1,此值将更趋近于真正的平方根值。
  4.比较前后两次求得的平方根值x0和x1,如果它们的差值小于我们指定的值,即达到我们要求的精度,则认为x1就是a的平方根值,去执行步骤5;否则执行步骤2,即循环进行迭代。
  迭代法是用于求方程或方程组近似根的一种常用的算法设计方法。设方程为f(x)=0,用某种数学方法导出等价的形式x=g(x),然后按以下步骤执行:
  (1) 选一个方程的近似根,赋给变量x0;
  (2) 将x0的值保存于变量x1,然后计算g(x1),并将结果存于变量x0;
  (3) 当x0与x1的差的绝对值还小于指定的精度要求时,重复步骤(2)的计算。
  若方程有根,并且用上述方法计算出来的近似根序列收敛,则按上述方法求得的x0就认为是方程的根。上述算法用C程序的形式表示为:
  【算法】迭代法求方程的根
  { x0=初始近似根;
  do {
  x1=x0;
  x0=g(x1); /*按特定的方程计算新的近似根*/
  } while ( fabs(x0-x1)>Epsilon);
  printf(“方程的近似根是%f\n”,x0);
  }
  迭代算法也常用于求方程组的根,令
  X=(x0,x1,…,xn-1)
  设方程组为:
  xi=gi(X) (I=0,1,…,n-1)
  则求方程组根的迭代算法可描述如下:
  【算法】迭代法求方程组的根
  { for (i=0;i
  x=初始近似根;
  do {
  for (i=0;i
  y=x;
  for (i=0;i
  x=gi(X);
  for (delta=0.0,i=0;i
  if (fabs(y-x)>delta) delta=fabs(y-x);
  } while (delta>Epsilon);
  for (i=0;i
  printf(“变量x[%d]的近似根是 %f”,I,x);
  printf(“\n”);
  }
  具体使用迭代法求根时应注意以下两种可能发生的情况:
  (1) 如果方程无解,算法求出的近似根序列就不会收敛,迭代过程会变成死循环,因此在使用迭代算法前应先考察方程是否有解,并在程序中对迭代的次数给予限制;
  (2) 方程虽然有解,但迭代公式选择不当,或迭代的初始近似根选择不合理,也会导致迭代失败。
 


一般定义

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

编辑本段其它定义

  递归的另一种定义:
  递归,就是用自己的简单情况,定义自己。
  在 数学 和计算机科学中,递归指由一种(或多种)简单的基本情况定义的一类对象或方法,并规定其他所有情况都能被还原为其基本情况。
  例如,下列为某人祖先的递归定义:
  某人的 双亲 是他的 祖先 (基本情况)。某人祖先的双亲同样是某人的祖先(递归步骤)。 斐波那契数列 是典型的递归案例:
  Fib(0) = 0 [基本情况] Fib(1) = 1 [基本情况] 对所有n > 1的整数:Fib(n) = (Fib(n-1) + Fib(n-2)) [递归定义] 尽管有许多数学函数均可以递归表示,但在实际应用中,递归定义的高开销往往会让人望而却步。例如:
  阶乘(1) = 1 [基本情况] 对所有n > 1的整数:阶乘(n) = (n * 阶乘(n-1)) [递归定义] 一种便于理解的心理模型,是认为递归定义对对象的定义是按照“先前定义的”同类对象来定义的。例如:你怎样才能移动100个箱子?答案:你首先移动一个箱子,并记下它移动到的位置,然后再去解决较小的问题:你怎样才能移动99个箱子?最终,你的问题将变为怎样移动一个箱子,而这是你已经知道该怎么做的。
  如此的定义在数学中十分常见。例如,集合论对 自然数 的正式定义是:1是一个自然数,每个自然数都有一个后继,这一个后继也是自然数。
  

德罗斯特效应

   德罗斯特效应 是递归的一种视觉形式。图中女性手持的物体中有一幅她本人手持同一物体的小图片,进而小图片中还有更小的一幅她手持同一物体的图片,依此类推。
  又例如,我们在两面相对的镜子之间放一根正在燃烧的蜡烛,我们会从其中一面镜子里看到一根蜡烛,蜡烛后面又有一面镜子,镜子里里又有一根蜡烛……这也是递归的表现。

编辑本段递归应用

   递归算法 一般用于解决三类问题:
  (1)数据的定义是按递归定义的。(Fibonacci函数)
  (2)问题解法按递归算法实现。(回溯)
  (3)数据的结构形式是按递归定义的。(树的遍历,图的搜索)
  递归的缺点:
  递归算法解题相对常用的算法如普通循环等,运行效率较低。因此,应该尽量避免使用递归,除非没有更好的算法或者某种特定情况,递归更为适合的时候。在 递归调用 的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。


下面说说递归和迭代在算法上的区别(仅供参考);

所谓递归,简而言之就是应用程序自身调用自身, 以实现层次数据结构的查询和访问。 递归的使用可以使代码更简洁清晰,可读性更好(对于初学者到不见得),但由于递归需要系统堆栈,所以空间消耗要比非递归代码要大很多,而且,如果递归深度 太大,可能系统资源会不够用。    

往往有这样的观点:能不用递归就不用递归,递归都可以用迭代来代替。     

诚然,在理论上,递归和迭代在时间复杂度方面是等价的(在不考虑函数调用开销和函数调用产生的堆栈开销),但实际上递归确实效率比迭代低,既然这样,递归 没有任何优势,那么是不是就,没有使用递归的必要了,那递归的存在有何意义呢?     

万物的存在是需要时间的检验的,递归没有被历史所埋没,即有存在的理由。从理论上说,所有的递归函数都可以转换为迭代函数,反之亦然,然而代价通常都是比 较高的。但从算法结构来说,递归声明的结构并不总能够转换为迭代结构,原因在于结构的引申本身属于递归的概念,用迭代的方法在设计初期根本无法实现,这就 像动多态的东西并不总是可以用静多态的方法实现一样。这也是为什么在结构设计时,通常采用递归的方式而不是采用迭代的方式的原因,一个极典型的例子类似于 链表,使用递归定义及其简单,但对于内存定义(数组方式)其定义及调用处理说明就变得很晦涩,尤其是在遇到环链、图、网格等问题时,使用迭代方式从描述到 实现上都变得不现实。 因而可以从实际上说,所有的迭代可以转换为递归,但递归不一定可以转换为迭代。       

采用递归算法需要的前提条件是,当且仅当一个存在预期的收敛时,才可采用递归算法,否则,就不能使用递归算法。     

递归其实是方便了程序员难为了机器,递归可以通过数学公式很方便的转换为程序。其优点就是易理解,容易编程。但递归是用栈机制实现的,每深入一层,都要占 去一块栈数据区域,对嵌套层数深的一些算法,递归会力不从心,空间上会以内存崩溃而告终,而且递归也带来了大量的函数调用,这也有许多额外的时间开销。所 以在深度大时,它的时空性就不好了。     

而迭代虽然效率高,运行时间只因循环次数增加而增加,没什么额外开销,空间上也没有什么增加,但缺点就是不容易理解,编写复杂问题时困难。     

因而,“能不用递归就不用递归,递归都可以用迭代来代替”这样的理解,还是辩证的来看待,不可一棍子打死。*/



评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值