ag旗舰厅官网_ag旗舰厅下载客户端

热门关键词: ag旗舰厅官网,ag旗舰厅下载客户端

网络编程

当前位置:ag旗舰厅官网 > 网络编程 > 递归方法

递归方法

来源:http://www.pedaLyourcycLe.com 作者:ag旗舰厅官网 时间:2019-10-05 15:00

图片 1

复习

<pre>
sum = 0
i = 0
while i <= 100:
sum = sum + i
i = i + 1

print(sum)

</pre>

  1. for循环
    <pre>
    sum = 0

for i in range(101):
sum = sum + 1

print(sum)

</pre>

所谓递归方法正是办法本身调本身,那么些看五个例证就会知道了。

函数

函数是团体好的,可重复使用的,用来兑现单一,或相关联功用的代码段。
函数能加强使用的模块性,和代码的再度利用率。你曾经知道Python提供了无数内建函数,举个例子print()。但你也足以团结创制函数,那被叫做客商自定义函数。

哪些定义函数

参数

什么样调用函数

怎么回到函数

函数体内部的话语在举行时,一旦执行到return时,函数就施行实现,并将结果再次回到。

例子:求和n

类比
函数:厨房
参数:食材

多个参数

<pre>
import math

def abs(num):
if num < 0:
return -num;
else:
return num;
</pre>

练习:

  1. 概念一个函数,传入八个数字参数, 重回最大值
  2. 概念四个函数,传入多少个数字参数, 重临最小值
  3. 概念二个函数,传入七个数字参数a,b. 重回a的b次方
  4. 概念二个函数,传入多个数字参数a, 作为圆的半径,重临圆的面积
  5. 概念贰个函数,传入四个数字参数, 重临最小值
  6. 概念叁个函数,传入数字数组, 再次来到最小值

调用其余函数

身体力行代码1:用递归来算整数n的阶乘。

递归函数

在函数内部,能够调用其余函数。如果多少个函数在里头调用本身本人,这一个函数正是递归函数。

举个例证,我们来计量阶乘n! = 1 x 2 x 3 x ... x n,用函数fact(n)表示,能够看到:

fact(n) = n! = 1 x 2 x 3 x ... x (n-1) x n = (n-1)! x n = fact(n-1) x n

于是,fact(n)可以代表为n x fact(n-1),独有n=1时亟待特殊管理。

于是乎,fact(n)用递归的法子写出来就是:
<pre>
def fact(n):
if n==1:
return 1
return n * fact(n - 1)
</pre>
地点便是一个递归函数。可以尝试:

设若大家总结fact(5),能够根据函数定义见到总结进度如下:

===> fact(5)
===> 5 * fact(4)
===> 5 * (4 * fact(3))
===> 5 * (4 * (3 * fact(2)))
===> 5 * (4 * (3 * (2 * fact(1))))
===> 5 * (4 * (3 * (2 * 1)))
===> 5 * (4 * (3 * 2))
===> 5 * (4 * 6)
===> 5 * 24
===> 120
递归函数的长处是概念轻便,逻辑清晰。理论上,全体的递归函数都能够写成循环的办法,但循环的逻辑比不上递归清晰。

选择递归函数须求专一防守栈溢出。在计算机中,函数调用是通过栈(stack)这种数据结构完结的,每当进入贰个函数调用,栈就能够加一层栈帧,每当函数再次来到,栈就能减一层栈帧。由于栈的轻重不是但是的,所以,递归调用的次数过多,会招致栈溢出。能够试行fact(1000):

递归函数
阅读: 310046
在函数内部,能够调用其余函数。假使贰个函数在中间调用自己本人,那些函数正是递归函数。
比方,大家来总计阶乘n! = 1 x 2 x 3 x ... x n
,用函数fact(n)
意味着,能够见见:
fact(n) = n! = 1 x 2 x 3 x ... x (n-1) x n = (n-1)! x n = fact(n-1) x n
所以,fact(n)
能够象征为n x fact(n-1)
,唯有n=1时内需新鲜处理。
于是,fact(n)
用递归的办法写出来正是:
def fact(n): if n==1: return 1 return n * fact(n - 1)

上面就是贰个递归函数。能够尝试:

fact(1)1>>> fact(5)120>>> fact(100)93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

一经大家总结fact(5)
,可以依据函数定义看见总结进程如下:
===> fact(5)===> 5 * fact(4)===> 5 * (4 * fact(3))===> 5 * (4 * (3 * fact(2)))===> 5 * (4 * (3 * (2 * fact(1))))===> 5 * (4 * (3 * (2 * 1)))===> 5 * (4 * (3 * 2))===> 5 * (4 * 6)===> 5 * 24===> 120

递归函数的亮点是概念轻便,逻辑清晰。理论上,全部的递归函数都得以写成循环的法门,但循环的逻辑不比递归清晰。
行使递归函数供给在乎防备栈溢出。在微型Computer中,函数调用是透过栈(stack)这种数据结构完成的,每当步向二个函数调用,栈就能够加一层栈帧,每当函数重回,栈就能够减一层栈帧。由于栈的尺寸不是Infiniti的,所以,递归调用的次数过多,会变成栈溢出。能够试试fact(一千)

fact(1000)Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 4, in fact ... File "<stdin>", line 4, in factRuntimeError: maximum recursion depth exceeded in comparison

减轻递归调用栈溢出的格局是由此尾递归优化,事实上尾递归和巡回的效应是平等的,所以,把循环看成是一种特殊的尾递归函数也是足以的。
尾递归是指,在函数再次来到的时候,调用本身本身,况且,return语句无法包罗表明式。那样,编写翻译器只怕解释器就能够把尾递归做优化,使递归自己无论调用多少次,都仅占用三个栈帧,不会冒出栈溢出的情形。
上面的fact(n)
函数由于return n * fact(n - 1)
引进了乘法表达式,所以就不是尾递归了。要改成尾递归情势,须求多或多或少代码,重假如要把每一步的乘积传入到递归函数中:
def fact(n): return fact_iter(n, 1)def fact_iter(num, product): if num == 1: return product return fact_iter(num - 1, num * product)

可以见见,return fact_iter(num - 1, num * product)
仅重返递归函数自己,num - 1
和num * product
在函数调用前就能够被总括,不影响函数调用。
fact(5)
对应的fact_iter(5, 1)
的调用如下:
===> fact_iter(5, 1)===> fact_iter(4, 5)===> fact_iter(3, 20)===> fact_iter(2, 60)===> fact_iter(1, 120)===> 120

尾递归调用时,假设做了优化,栈不会增加,由此,无论多少次调用也不会招致栈溢出。
不满的是,大大多编制程序语言未有对准尾递归做优化,Python解释器也绝非做优化,所以,尽管把地点的fact(n)
函数改成尾递归格局,也会促成栈溢出。
小结
应用递归函数的长处是逻辑轻松清晰,弱点是过深的调用会促成栈溢出。
针对尾递归优化的语言能够透过尾递归幸免栈溢出。尾递归事实上和巡回是等价的,没有循环语句的编制程序语言只好通过尾递归完成循环。
Python标准的解释器未有针对尾递归做优化,任何递归函数都设有栈溢出的难题。
练习
汉诺塔的移动能够用递归函数极其简单地完毕。
请编写move(n, a, b, c)
函数,它接受参数n
,表示3个柱子A、B、C中第二个柱子A的物价指数数量,然后打字与印刷出把富有盘子从A借助B移动到C的秘技,比方:

标题:有多少个数字:1、2、3、4,能组成多少个互分歧样且无重复数字的二个人数?各是多少?
程序分析:可填在百位、10个人、个位的数字都以1、2、3、4。组成全部的排列后再去 掉不满足条件的排列。
程序源代码:

<pre>
for i in range(1,5):
for j in range(1,5):
for k in range(1,5):
if( i != k ) and (i != j) and (j != k):
print i,j,k
</pre>

主题材料:公司发放的奖金依据利益提成。受益(I)低于或等于10万元时,奖金可提十分之一;利益大于10万元,低于20万元时,低于10万元的有的按十分之一提成,高于10万元的局地,可提成7.5%;20万到40万里头时,高于20万元的片段,可提成5%;40万到60万里面时超越40万元的一对,可提成3%;60万到100万以内时,高于60万元的一些,可提成1.5%,高于100万元时,超越100万元的某个按1%提成,从键盘输入下个月收益I,求应发放奖金总额?
程序剖析:请利用数轴来分界,定位。注意定义时需把奖金定义成长整型。
程序源代码:

<pre>

i = int(raw_input('净利润:'))
arr = [1000000,600000,400000,200000,100000,0]
rat = [0.01,0.015,0.03,0.05,0.075,0.1]
r = 0
for idx in range(0,6):
if i>arr[idx]:
r+=(i-arr[idx])rat[idx]
print (i-arr[idx])
rat[idx]
i=arr[idx]
print r
</pre>

难题:二个正整数,它丰盛100和增加268后都以贰个全然平方数,请问该数是有个别?
程序解析:在一千0以内判定,将该数加上100后再开药方,加上268后再开药方,若是开药方后的结果满意如下条件,就是结果。请看具体解析:
程序源代码

<pre>
import math
for i in range(10000):
#中间转播为整型值
x = int(math.sqrt(i + 100))
y = int(math.sqrt(i + 268))
if(x * x == i + 100) and (y * y == i + 268):
print i
</pre>

标题:斐波那契数列。
程序分析:斐波那契数列(Fibonacci sequence),又称白银分割数列,指的是这么一个数列:0、1、1、2、3、5、8、13、21、34、……。
在数学上,费波那契数列是以递归的格局来定义:

<pre>
def fib(n):
a,b = 1,1
for i in range(n-1):
a,b = b,a+b
return a

public int factorial { if  { return 1; } else { return n * factorial; }}

输出了第拾二个斐波这契数列

print fib(10)
</pre>

<pre>

测量检验代码:

运用递归

def fib(n):
if n==1 or n==2:
return 1
return fib(n-1)+fib(n-2)

int i = 5;Recursion r = new Recursion();System.out.println(i + "的阶乘等于:" + r.factorial;

输出了第12个斐波那契数列

print fib(10)
</pre>

题目:输出 9*9 乘法口诀表。
次第解析:分行与列惦记,共9行9列,i调控行,j调控列。
程序源代码:

<pre>
for i in range(1, 10):
print
for j in range(1, i+1):
print "%d%d=%d" % (i, j, ij),
</pre>

主题素材:古典难点:有一对兔子,从出生后第2个月起各类月都生一对兔子,小兔子长到第2个月后种种月又生一对兔子,要是兔子都不死,问每一种月的兔子总的数量为多少?
次第分析:兔子的规律为数列1,1,2,3,5,8,13,21....
程序源代码:

<pre>

f1 = 1
f2 = 1
for i in range(1,22):
print '%12ld %12ld' % (f1,f2),
if (i % 3) == 0:
print ''
f1 = f1 + f2
f2 = f1 + f2
</pre>

难点:判定101-200时期有稍许个素数,并出口全数素数。
程序深入分析:剖断素数的法门:用二个数分别去除2到sqrt(那一个数),假若能被整除,则注脚此数不是素数,反之是素数。
<pre>

运营结果:<pre>5的阶乘等于:120</pre>

!/usr/bin/python

亲自去做代码2:用递归来算斐波那契数列的第n个数。

-- coding: UTF-8 --

h = 0
leap = 1
from math import sqrt
from sys import stdout
for m in range(101,201):
k = int(sqrt(m + 1))
for i in range(2,k + 1):
if m % i == 0:
leap = 0
break
if leap == 1:
print '%-4d' % m
h += 1
if h % 10 == 0:
print ''
leap = 1
print 'The total is %d' % h
</pre>

public int fibonacci { if  { return 0; } else if  { return 1; } else { return fibonacci + fibonacci; }}

测量试验代码:

int i = 5;Recursion r = new Recursion();System.out.println("斐波那契数的第" + i + "为:" + r.fibonacci;

运维结果:<pre>斐波那契数的第5为:3</pre>

正文代码下载:百度网盘

本文由ag旗舰厅官网发布于网络编程,转载请注明出处:递归方法

关键词: