迭代学习算法的定义

① 神经网络控制的书籍目录

第1章神经网络和自动控制的基础知识
1.1人工神经网络的发展史
1.1.120世纪40年代——神经元模型的诞生
1.1.220世纪50年代——从单神经元到单层网络，形成第一次热潮
1.1.320世纪60年代——学习多样化和AN2的急剧冷落
1.1.420世纪70年代——在低迷中顽强地发展
1.1.520世纪80年代——AN2研究热潮再度兴起
1.1.620世纪90年代——再现热潮，产生许多边缘交叉学科
1.1.7进入21世纪——实现机器智能的道路漫长而又艰难
1.2生物神经元和人工神经元
1.2.1生物神经元
1.2.2人工神经元
1.3生物神经网络和人工神经网络
1.3.1生物神经网络
1.3.2人工神经网络
1.4自动控制的发展史
1.4.1从传统控制理论到智能控制
1.4.2智能控制的产生与基本特征
1.4.3智能控制系统
1.5模糊集与模糊控制概述
1.5.1模糊集
1.5.2模糊隶属函数
1.5.3模糊控制
1.6从生物神经控制到人工神经控制
1.6.1生物神经控制的智能特征
1.6.2人工神经控制的模拟范围
1.7小结
习题与思考题
第2章神经计算基础
2.1线性空间与范数
2.1.1矢量空间
2.1.2范数
2.1.3赋范线性空间
2.1.4L1范数和L2范数
2.2迭代算法
2.2.1迭代算法的终止准则
2.2.2梯度下降法
2.2.3最优步长选择
2.3逼近论
2.3.1Banach空间和逼近的定义
2.3.2L2逼近和最优一致逼近
2.3.3离散点集上的最小二乘逼近
2.4神经网络在线迭代学习算法
2.5Z变换
2.5.1Z变换的定义和求取
2.5.2Z变换的性质
2.5.3Z反变换
2.6李雅普诺夫意义下的稳定性
2.6.1非线性时变系统的稳定性问题
2.6.2李雅普诺夫意义下的渐进稳定
2.6.3李雅普诺夫第二法
2.6.4非线性系统的稳定性分析
2.7小结
习题与思考题
第3章神经网络模型
3.1人工神经网络建模
3.1.1MP模型
3.1.2Hebb学习法则
3.2感知器
3.2.1单层感知器
3.2.2多层感知器
3.3BP网络与BP算法
3.3.1BP网络的基本结构
3.3.2BP算法及步长调整
3.4自适应线性神经网络
3.5自组织竞争型神经网络
3.5.1自组织竞争型神经网络的基本结构
3.5.2自组织竞争型神经网络的学习算法
3.6小脑模型神经网络
3.6.1CMAC的基本结构
3.6.2CMAC的工作原理
3.6.3CMAC的学习算法与训练
3.7递归型神经网络
3.7.1DTRNN的网络结构
3.7.2实时递归学习算法
3.8霍普菲尔德（Hopfield）神经网络
3.8.1离散型Hopfield神经网络
3.8.2连续型Hopfield神经网络
3.8.3求解TSP问题
3.9小结
习题与思考题
第4章神经控制中的系统辨识
4.1系统辨识基本原理
4.1.1辨识系统的基本结构
4.1.2辨识模型
4.1.3辨识系统的输入和输出
4.2系统辨识过程中神经网络的作用
4.2.1神经网络辨识原理
4.2.2多层前向网络的辨识能力
4.2.3辨识系统中的非线性模型
4.3非线性动态系统辨识
4.3.1非线性动态系统的神经网络辨识
4.3.2单输入单输出非线性动态系统的BP网络辨识
4.4多层前向网络辨识中的快速算法
4.5非线性模型的预报误差神经网络辨识
4.5.1非动态模型建模，
4.5.2递推预报误差算法
4.6非线性系统逆模型的神经网络辨识
4.6.1系统分析逆过程的存在性
4.6.2非线性系统的逆模型
4.6.3基于多层感知器的逆模型辨识
4.7线性连续动态系统辨识的参数估计
4.7.1Hopfield网络用于辨识
4.7.2Hopfield网络辨识原理
4.8利用神经网络联想功能的辨识系统
4.8.1二阶系统的性能指标
4.8.2系统辨识器基本结构
4.8.3训练与辨识操作
4.9小结
习题与思考题
第5章人工神经元控制系统
5.1人工神经元的PID调节功能
5.1.1人工神经元PID动态结构
5.1.2人工神经元闭环系统动态结构
5.2人工神经元PID调节器
5.2.1比例调节元
5.2.2积分调节元
5.2.3微分调节元
5.3人工神经元闭环调节系统
5.3.1系统描述
5.3.2Lyapunov稳定性分析
5.4人工神经元自适应控制系统
5.4.1人工神经元自适应控制系统的基本结构
5.4.2人工神经元自适应控制系统的学习算法
5.5人工神经元控制系统的稳定性
5.6小结
习题与思考题
第6章神经控制系统
6.1神经控制系统概述
6.1.1神经控制系统的基本结构
6.1.2神经网络在神经控制系统中的作用
6.2神经控制器的设计方法
6.2.1模型参考自适应方法
6.2.2自校正方法
6.2.3内模方法
6.2.4常规控制方法
6.2.5神经网络智能方法
6.2.6神经网络优化设计方法
6.3神经辨识器的设计方法
6.4PID神经控制系统
6.4.1PID神经控制系统框图
6.4.2PID神经调节器的参数整定
6.5模型参考自适应神经控制系统
6.5.1两种不同的自适应控制方式
6.5.2间接设计模型参考自适应神经控制系统
6.5.3直接设计模型参考自适应神经控制系统
6.6预测神经控制系统
6.6.1预测控制的基本特征
6.6.2神经网络预测算法
6.6.3单神经元预测器
6.6.4多层前向网络预测器
6.6.5辐射基函数网络预测器
6.6.6Hopfield网络预测器
6.7自校正神经控制系统
6.7.1自校正神经控制系统的基本结构
6.7.2神经自校正控制算法
6.7.3神经网络逼近
6.8内模神经控制系统
6.8.1线性内模控制方式
6.8.2内模控制系统
6.8.3内模神经控制器
6.8.4神经网络内部模型
6.9小脑模型神经控制系统
6.9.1CMAC控制系统的基本结构
6.9.2CMAC控制器设计
6.9.3CMAC控制系统实例
6.10小结
习题与思考题
第7章模糊神经控制系统
7.1模糊控制与神经网络的结合
7.1.1模糊控制的时间复杂性
7.1.2神经控制的空间复杂性
7.1.3模糊神经系统的产生
7.2模糊控制和神经网络的异同点
7.2.1模糊控制和神经网络的共同点
7.2.2模糊控制和神经网络的不同点
7.3模糊神经系统的典型结构
7.4模糊神经系统的结构分类
7.4.1松散结合
7.4.2互补结合
7.4.3主从结合
7.4.4串行结合
7.4.5网络学习结合
7.4.6模糊等价结合
7.5模糊等价结合中的模糊神经控制器
7.5.1偏差P和偏差变化率Δe的获取
7.5.2隶属函数的神经网络表达
7.6几种常见的模糊神经网络
7.6.1模糊联想记忆网络
7.6.2模糊认知映射网络
7.7小结
习题与思考题
第8章神经控制中的遗传进化训练
8.1生物的遗传与进化
8.1.1生物进化论的基本观点
8.1.2进化计算
8.2遗传算法概述
8.2.1遗传算法中遇到的基本术语
8.2.2遗传算法的运算特征
8.2.3遗传算法中的概率计算公式
8.3遗传算法中的模式定理
8.3.1模式定义和模式的阶
8.3.2模式定理（Schema）
8.4遗传算法中的编码操作
8.4.1遗传算法设计流程
8.4.2遗传算法中的编码规则
8.4.3一维染色体的编码方法
8.4.4二维染色体编码
8.5遗传算法中的适应度函数
8.5.1将目标函数转换成适应度函数
8.5.2标定适应度函数
8.6遗传算法与优化解
8.6.1适应度函数的确定
8.6.2线性分级策略
8.6.3算法流程
8.7遗传算法与预测控制
8.8遗传算法与神经网络
8.9神经网络的遗传进化训练
8.9.1遗传进化训练的实现方法
8.9.2BP网络的遗传进化训练
8.10小结
习题与思考题
附录常用神经控制术语汉英对照
参考文献
……

② 迭代法的算法

迭代是数值分析中通过从一个初始估计出发寻找一系列近似解来解决问题（一般是解方程或者方程组）的过程，为实现这一过程所使用的方法统称为迭代法（Iterative Method）。
一般可以做如下定义：对于给定的线性方程组（这里的x、B、f同为矩阵，任意线性方程组都可以变换成此形式），用公式 （代表迭代k次得到的x，初始时k=0)逐步带入求近似解的方法称为迭代法（或称一阶定常迭代法）。如果存在，记为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: );
scanf(%lf,&a);//因为a是double型数据，所以要用%lf，而不是%f
if(a<0)
printf(Error! );
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: );
printf(sqrt(%g)=%g ,a,x1）；
}
求平方根的迭代公式：x1=1/2*(x0+a/x0）。
算法：1.先自定一个初值x0，作为a的平方根值，在我们的程序中取a/2作为a的初值；利用迭代公式求出一个x1。此值与真正的a的平方根值相比，误差很大。
⒉把新求得的x1代入x0中，准备用此新的x0再去求出一个新的x1.
⒊利用迭代公式再求出一个新的x1的值，也就是用新的x0又求出一个新的平方根值x1，此值将更趋近于真正的平方根值。
⒋比较前后两次求得的平方根值x0和x1，如果它们的差值小于我们指定的值，即达到我们要求的精度，则认为x1就是a的平方根值，去执行步骤5；否则执行步骤2，即循环进行迭代。
迭代法是用于求方程或方程组近似根的一种常用的算法设计方法。设方程为f(x)=0，用某种数学方法导出等价的形式x=g(x），然后按以下步骤执行：
⑴ 选一个方程的近似根，赋给变量x0；
⑵ 将x0的值保存于变量x1，然后计算g(x1），并将结果存于变量x0；
⑶ 当x0与x1的差的绝对值还小于指定的精度要求时，重复步骤⑵的计算。
若方程有根，并且用上述方法计算出来的近似根序列收敛，则按上述方法求得的x0就认为是方程的根。上述算法用C程序的形式表示为：
【算法】迭代法求方程的根
{ x0=初始近似根；
do {
x1=x0；
x0=g(x1）； /*按特定的方程计算新的近似根*/
} while (fabs(x0-x1）>Epsilon）；
printf（“方程的近似根是%f ”，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的问题，设法将它分解成规模较小的问题，然后从这些小问题的解方便地构造出大问题的解，并且这些规模较小的问题也能采用同样的分解和综合方法，分解成规模更小的问题，并从这些更小问题的解构造出规模较大问题的解。特别地，当规模N=1时，能直接得解。
【问题】 编写计算斐波那契（Fibonacci）数列的第n项函数fib（n）。
斐波那契数列为：0、1、1、2、3、……，即：
fib(0)=0;
fib⑴=1;
fib(n)=fib(n-1）+fib(n-2） （当n>1时）。
写成递归函数有：
int fib(int n)
{ if (n==0) return 0;
if (n==1） return 1;
if (n>1） return fib(n-1）+fib(n-2）；
}
递归算法的执行过程分递推和回归两个阶段。在递推阶段，把较复杂的问题（规模为n）的求解推到比原问题简单一些的问题（规模小于n）的求解。例如上例中，求解fib(n），把它推到求解fib(n-1）和fib(n-2）。也就是说，为计算fib(n），必须先计算fib(n-1）和fib(n- 2），而计算fib(n-1）和fib(n-2），又必须先计算fib(n-3）和fib(n-4）。依次类推，直至计算fib⑴和fib(0），分别能立即得到结果1和0。在递推阶段，必须要有终止递归的情况。例如在函数fib中，当n为1和0的情况。
在回归阶段，当获得最简单情况的解后，逐级返回，依次得到稍复杂问题的解，例如得到fib⑴和fib(0）后，返回得到fib⑵的结果，……，在得到了fib(n-1）和fib(n-2）的结果后，返回得到fib(n）的结果。
在编写递归函数时要注意，函数中的局部变量和参数知识局限于当前调用层，当递推进入“简单问题”层时，原来层次上的参数和局部变量便被隐蔽起来。在一系列“简单问题”层，它们各有自己的参数和局部变量。
由于递归引起一系列的函数调用，并且可能会有一系列的重复计算，递归算法的执行效率相对较低。当某个递归算法能较方便地转换成递推算法时，通常按递推算法编写程序。例如上例计算斐波那契数列的第n项的函数fib(n）应采用递推算法，即从斐波那契数列的前两项出发，逐次由前两项计算出下一项，直至计算出要求的第n项。
【问题】 组合问题
问题描述：找出从自然数1、2、……、n中任取r个数的所有组合。例如n=5，r=3的所有组合为：⑴5、4、3 ⑵5、4、2 ⑶5、4、1
⑷5、3、2 ⑸5、3、1 ⑹5、2、1
⑺4、3、2 ⑻4、3、1 ⑼4、2、1
⑽3、2、1
分析所列的10个组合，可以采用这样的递归思想来考虑求组合函数的算法。设函数为void comb(int m,int k）为找出从自然数1、2、……、m中任取k个数的所有组合。当组合的第一个数字选定时，其后的数字是从余下的m-1个数中取k-1数的组合。这就将求m 个数中取k个数的组合问题转化成求m-1个数中取k-1个数的组合问题。设函数引入工作数组a[ ]存放求出的组合的数字，约定函数将确定的k个数字组合的第一个数字放在a[k]中，当一个组合求出后，才将a[ ]中的一个组合输出。第一个数可以是m、m-1、……、k，函数将确定组合的第一个数字放入数组后，有两种可能的选择，因还未去顶组合的其余元素，继续递归去确定；或因已确定了组合的全部元素，输出这个组合。细节见以下程序中的函数comb。
【程序】
# include
# define MAXN 100
int a[MAXN];
void comb(int m,int k)
{ int i,j;
for (i=m;i>=k;i--)
{ a[k]=i;
if (k>1）
comb(i-1,k-1）；
else
{ for (j=a[0];j>0;j--)
printf（“%4d”，a[j]);
printf（“ ”）；
}
}
}
void main()
{ a[0]=3;
comb（5,3）；
}
【问题】 背包问题
问题描述：有不同价值、不同重量的物品n件，求从这n件物品中选取一部分物品的选择方案，使选中物品的总重量不超过指定的限制重量，但选中物品的价值之和最大。
设n 件物品的重量分别为w0、w1、…、wn-1，物品的价值分别为v0、v1、…、vn-1。采用递归寻找物品的选择方案。设前面已有了多种选择的方案，并保留了其中总价值最大的方案于数组option[ ]，该方案的总价值存于变量maxv。当前正在考察新方案，其物品选择情况保存于数组cop[ ]。假定当前方案已考虑了前i-1件物品，现在要考虑第i件物品；当前方案已包含的物品的重量之和为tw；至此，若其余物品都选择是可能的话，本方案能达到的总价值的期望值为tv。算法引入tv是当一旦当前方案的总价值的期望值也小于前面方案的总价值maxv时，继续考察当前方案变成无意义的工作，应终止当前方案，立即去考察下一个方案。因为当方案的总价值不比maxv大时，该方案不会被再考察，这同时保证函数后找到的方案一定会比前面的方案更好。
对于第i件物品的选择考虑有两种可能：
⑴ 考虑物品i被选择，这种可能性仅当包含它不会超过方案总重量限制时才是可行的。选中后，继续递归去考虑其余物品的选择。
⑵ 考虑物品i不被选择，这种可能性仅当不包含物品i也有可能会找到价值更大的方案的情况。
按以上思想写出递归算法如下：
try（物品i，当前选择已达到的重量和，本方案可能达到的总价值tv)
{ /*考虑物品i包含在当前方案中的可能性*/
if（包含物品i是可以接受的）
{ 将物品i包含在当前方案中；
if (i
try(i+1,tw+物品i的重量，tv);
else
/*又一个完整方案，因为它比前面的方案好，以它作为最佳方案*/
以当前方案作为临时最佳方案保存；
恢复物品i不包含状态；
}
/*考虑物品i不包含在当前方案中的可能性*/
if （不包含物品i仅是可男考虑的）
if (i
try(i+1,tw,tv-物品i的价值）；
else
/*又一个完整方案，因它比前面的方案好，以它作为最佳方案*/
以当前方案作为临时最佳方案保存；
}
为了理解上述算法，特举以下实例。设有4件物品，它们的重量和价值见表：
物品 0 1 2 3
重量 5 3 2 1
价值 4 4 3 1
并设限制重量为7。则按以上算法，下图表示找解过程。由图知，一旦找到一个解，算法就进一步找更好的佳。如能判定某个查找分支不会找到更好的解，算法不会在该分支继续查找，而是立即终止该分支，并去考察下一个分支。
按上述算法编写函数和程序如下：
【程序】
# include
# define N 100
double limitW,totV,maxV;
int option[N],cop[N];
struct { double weight;
double value;
}a[N];
int n;
void find(int i,double tw,double tv)
{ int k;
/*考虑物品i包含在当前方案中的可能性*/
if (tw+a.weight<=limitW)
{ cop=1;
if (i
else
{ for (k=0;k
option[k]=cop[k];
maxv=tv;
}
cop=0;
}
/*考虑物品i不包含在当前方案中的可能性*/
if (tv-a.value>maxV)
if (i
else
{ for (k=0;k
option[k]=cop[k];
maxv=tv-a.value;
}
}
void main()
{ int k;
double w,v;
printf（“输入物品种数 ”）；
scanf（（“%d”，&n);
printf（“输入各物品的重量和价值 ”）；
for (totv=0.0,k=0;k
{ scanf（“%1f%1f”，&w,&v);
a[k].weight=w;
a[k].value=v;
totV+=V;
}
printf（“输入限制重量 ”）；
scanf（“%1f”，&limitV);
maxv=0.0;
for (k=0;k find(0,0.0,totV);
for (k=0;k
if (option[k]) printf（“%4d”，k+1）；
printf（“ 总价值为%.2f ”，maxv);
}
作为对比，下面以同样的解题思想，考虑非递归的程序解。为了提高找解速度，程序不是简单地逐一生成所有候选解，而是从每个物品对候选解的影响来形成值得进一步考虑的候选解，一个候选解是通过依次考察每个物品形成的。对物品i的考察有这样几种情况：当该物品被包含在候选解中依旧满足解的总重量的限制，该物品被包含在候选解中是应该继续考虑的；反之，该物品不应该包括在当前正在形成的候选解中。同样地，仅当物品不被包括在候选解中，还是有可能找到比目前临时最佳解更好的候选解时，才去考虑该物品不被包括在候选解中；反之，该物品不包括在当前候选解中的方案也不应继续考虑。对于任一值得继续考虑的方案，程序就去进一步考虑下一个物品。
【程序】
# include
# define N 100
double limitW;
int cop[N];
struct ele { double weight;
double value;
} a[N];
int k,n;
struct { int ;
double tw;
double tv;
}twv[N];
void next(int i,double tw,double tv)
{ twv.=1;
twv tw=tw;
twv tv=tv;
}
double find(struct ele *a,int n)
{ int i,k,f;
double maxv,tw,tv,totv;
maxv=0;
for (totv=0.0,k=0;k
totv+=a[k].value;
next(0,0.0,totv);
i=0;
While (i>=0)
{ f=twv.;
tw=twv tw;
tv=twv tv;
switch(f)
{ case 1: twv.++;
if (tw+a.weight<=limitW)
if (i
{ next(i+1,tw+a.weight,tv);
i++;
}
else
{ maxv=tv;
for (k=0;k
cop[k]=twv[k].!=0;
}
break;
case 0: i--;
break;
default: twv.=0;
if (tv-a.value>maxv)
if (i
{ next(i+1,tw,tv-a.value);
i++;
}
else
{ maxv=tv-a.value;
for (k=0;k
cop[k]=twv[k].!=0;
}
break;
}
}
return maxv;
}
void main()
{ double maxv;
printf（“输入物品种数 ”）；
scanf（（“%d”，&n);
printf（“输入限制重量 ”）；
scanf（“%1f”，&limitW);
printf（“输入各物品的重量和价值 ”）；
for (k=0;k
scanf（“%1f%1f”，&a[k].weight,&a[k].value);
maxv=find(a,n);
printf（“ 选中的物品为 ”）；
for (k=0;k
if (option[k]) printf（“%4d”，k+1）；
printf（“ 总价值为%.2f ”，maxv);
}

③ 简述算法的定义和特征以及它在c语言编程中如何使用的

一、什么是算法

算法是一系列解决问题的清晰指令，也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。算法常常含有重复的步骤和一些比较或逻辑判断。如果一个算法有缺陷，或不适合于某个问题，执行这个算法将不会解决这个问题。不同的算法可能用不同的时间、空间或效率来完成同样的任务。一个算法的优劣可以用空间复杂度与时间复杂度来衡量。

算法的时间复杂度是指算法需要消耗的时间资源。一般来说，计算机算法是问题规模n 的函数f(n)，算法执行的时间的增长率与f(n) 的增长率正相关，称作渐进时间复杂度（Asymptotic Time Complexity）。时间复杂度用“O（数量级）”来表示，称为“阶”。常见的时间复杂度有： O（1）常数阶；O（log2n）对数阶；O（n）线性阶；O（n2）平方阶。

算法的空间复杂度是指算法需要消耗的空间资源。其计算和表示方法与时间复杂度类似，一般都用复杂度的渐近性来表示。同时间复杂度相比，空间复杂度的分析要简单得多。

二、算法设计的方法

1.递推法

递推法是利用问题本身所具有的一种递推关系求问题解的一种方法。设要求问题规模为N的解，当N=1时，解或为已知，或能非常方便地得到解。能采用递推法构造算法的问题有重要的递推性质，即当得到问题规模为i-1的解后，由问题的递推性质，能从已求得的规模为1，2，…，i-1的一系列解，构造出问题规模为I的解。这样，程序可从i=0或i=1出发，重复地，由已知至i-1规模的解，通过递推，获得规模为i的解，直至得到规模为N的解。

④ 迭代学习控制的简介

迭代学习控制（iterative learning control，简称ILC）由Uchiyama于1978年首先提出，不过因为论文由日文撰写，影响不是很大。1984年，Arimoto等人用英文介绍了该方法。它是指不断重复一个同样轨迹的控制尝试，并以此修正控制律，以得到非常好的控制效果的控制方法。
迭代学习控制是学习控制的一个重要分支，是一种新型学习控制策略。它通过反复应用先前试验得到的信息来获得能够产生期望输出轨迹的控制输入，以改善控制质量。与传统的控制方法不同的是，迭代学习控制能以非常简单的方式处理不确定度相当高的动态系统，且仅需较少的先验知识和计算量，同时适应性强，易于实现；更主要的是，它不依赖于动态系统的精确数学模型，是一种以迭代产生优化输入信号，使系统输出尽可能逼近理想值的算法。它的研究对那些有着非线性、复杂性、难以建模以及高精度轨迹控制问题有着非常重要的意义。
.

⑤ 什么叫算法算法有哪几种表示方法

算法（Algorithm）是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。计算机科学家往往将“算法”一词的含义限定为此类“符号算法”。“算法”概念的初步定义：一个算法是解决一个问题的进程。而并不需要每次都发明一个解决方案。

已知的算法有很多，例如“分治法”、“枚举测试法”、“贪心算法”、“随机算法”等。

(5)迭代学习算法的定义扩展阅读

算法中的“分治法”

“分治法”是把一个复杂的问题拆分成两个较为简单的子问题，进而两个子问题又可以分别拆分成另外两个更简单的子问题，以此类推。问题不断被层层拆解。然后，子问题的解被逐层整合，构成了原问题的解。

高德纳曾用过一个邮局分发信件的例子对“分治法”进行了解释：信件根据不同城市区域被分进不同的袋子里；每个邮递员负责投递一个区域的信件，对应每栋楼，将自己负责的信件分装进更小的袋子；每个大楼管理员再将小袋子里的信件分发给对应的公寓。

⑥ 迭代学习控制的学习因子怎么确定

迭代学习管控计算分析及在机械臂之应用
作者:lgg
本文是机械工程论文，目前，ILC的研究已经取得了很多成果，本文在此基础上对ILC作了进一步的探讨和研究，针对如何提高迭代学习的收敛速度设计了新的学习算法，理论分析了算法的

第 1 章 绪 论

1.1 引言
随着科学技术的发展以及生产力水平的提高，人们对一些复杂的、不确定的系统的控制要求不断提高。我们在生产实际中遇到的系统大多存在着非线性、强耦合以及不确定性等特点，从而导致系统的精确模型无从获取。因此，采用传统的基于模型的控制方法不能很好的对这些系统进行控制。智能控制应运而生，自 20 世纪 70年代形成至今不过 40 多年的时间，但其发展势头却异常迅猛。学习控制是智能控制的一个高级分支，相对于传统的智能控制方法而言，它具备了自己学习的能力。1978 年 Uchiyama[1]提出了一种控制高速运行的机械手的思想，此思想描述为：重复地对同一个运动轨迹进行跟踪控制，与此同时不断地调节控制律，依此便可以达到较好的控制效果。1984 年，Arimoto 等人在 Uchiyama 对机器人控制研究的基础之上，提出了迭代学习控制(ILC)的概念。迭代学习控制方法是利用控制系统之前得到的控制经验，并根据系统以往的控制输入信号、实际输出信号以及期望信号来寻找理想的控制输入信号。这里我们把以往的信息看成一种经验，迭代学习是利用经验知识使得被控对象产生期望的运动，由此不仅削弱了对模型的依赖，还改进了跟踪控制的性能。由于迭代学习控制自身的特点，比如要求系统较少的先验知识以及较少的计算量，并且一般情况下无需辨识系统的参数，因此能处理未知参数以及不确定性等复杂问题，同时还具备了很好的鲁棒性。这些特点使得迭代学习控制方法适用于一类机器人或其它机械装置系统，为其基于自主学习来调整运动性能提供了一种较好的方法。因此，它的研究对像机器人那样有着高度的非线性、难建模、强耦合等特点的系统实现高精度轨迹跟踪控制有着非常重要的实际意义。
………………

1.2 课题的研究背景及意义
迭代学习控制理论的提出是以工业机器人的跟踪控制为背景的，在实际的生产过程中，各种不确定因素的存在导致我们无法获得系统的精确数学模型，因此传统的以系统的数学模型为基础的分析方法便无法较好的解决这些实际问题。随着科技的发展和生产的需要，人们越来越关注如何采用合适的方法来处理实际中存在的不确定性问题，以期达到较好的跟踪控制效果。在实际的生产过程中，普遍存在着不断重复的控制过程，如包装机的包装过程，零部件批量生产的过程，机械手重复完成某种操作的过程等等。以包装机的工作过程为例，其包装过程就是一个典型的不断重复操作的过程，如果被包装物品的重量、尺寸以及其它相关参数都相同，就相当于假设了每次运行时的初始条件相同，那么整个包装机的运动轨迹就会基本上是完全一致。对于这样一类具有重复运动性质的被控对象，运用迭代学习控制能起到很好的控制效果。迭代学习控制不要求已知系统的精确模型，而是利用已有的先验知识不断地进行学习，也就是说，它是利用在重复中学习的方法，最终实现在有限时间区间上对期望轨迹的完全跟踪。它较为简单的形式以及广泛的实用价值引起了人们的大量关注。与此同时，怎样解决迭代学习算法的初始状态问题以及如何加快迭代学习的收敛速度成为很多学者研究的热点问题。如果系统能在较短的时间内实现对期望轨迹的跟踪有着较高的实用价值。
……………

第 2 章 迭代学习控制的理论基础

2.1 迭代学习控制的基本原理
机器人的诞生有着划时代的意义，它的发展为人类文明的进步作出了卓越的贡献，人们对机器人技术的研究也形成了一门新的学科——机器人学。它是一门综合性学科，其发展离不开机械电子学、仿生学、控制理论、信息科学、人工智能等学科。机器人的发展过程可以分为三个阶段，1959 年世界上第一台工业机器人问世，它是美国人英格伯格和德沃尔共同研制的成果，它的诞生标志着机器人历史的开始，同时它也是机器人成长的第一个阶段。第一批工业机器人被称为“尤尼梅特”，具有“万能自动”的含义。1962 年生产出的工业机器人，命名为“沃尔萨特兰”，有着“万能搬动”的意思。“尤尼梅特”和“沃尔萨特兰”也因此被认为是世界上最早的工业机器人，并且沿用至今。1970 年左右，第二代机器人产生，他们开始了外界环境的实用阶段，同时得到了较好的普及。随着智能控制等学科的发展，机器人不仅具备了“感知”能力，还具有独立判断和行动的能力，与此同时，它们还具备了记忆、推理和决策的能力，从而能够完成一些复杂的动作。这些机器人被称为第三代机器人，即智能机器人。如今，智能机器人被广泛应用于各行各业，不仅节约了大量的人力物力，同时提高了作业效率。机器人的应用情况体现了一个国家的综合国力。工业机器人在我国仅有 20 多年的发展历史，我国曾研发并制造出一系列工业机器人，如喷涂机器人、氩弧焊机器人、装卸载机器人等，并成功投入使用。虽然我国对机器人的研究起步晚，但现在也已走上了进步和发展的道路，与此同时我们也应该看到，与国外机器人的研究相比我们还有很长的路要走。今后我们要加深基础学科的研究，开展跨国区域交流合作，理论联系实际应用，争取早日跻身于世界先进之列。
……………

2.2 迭代学习控制过程的表述
本章主要对迭代学习控制作了理论上的介绍，详细介绍了迭代学习的基本原理，迭代学习控制过程的表述以及迭代学习算法的流程。最后，为迭代学习收敛性分析所用理论及数学知识作了介绍，迭代学习算法在收敛性证明时常用到 Banach 空间，向量和矩阵范数，λ 范数，Bellman-Gronwall 引理以及 Lipschitz 条件。这些理论知识都为后续学习律的设计，收敛性分析以及仿真研究等工作奠定了理论基础。目前，智能控制在机器人控制中应用最多的是神经网络控制和模糊控制。神经网络具有容错性、自学习和自适应等特点，因此在控制机器人时不要求机器人的精确数学模型，从而引起学者们的极大关注。模糊控制是以模糊数学、模糊语言形式以及模糊逻辑规则推理为基础的控制科学，模糊控制系统是利用计算机控制技术构成闭环结构的一种智能控制系统。它亦不需要建立被控对象的精确数学模型，因此能对具有高度非线性，无精确数学模型的机器人系统进行有效控制。
……………

第 3 章 机器人指数变增益快速迭代学习控制........20
3.1 引言 ....... 20
3.2 系统描述 ..... 21
3.3 主要结果 ..... 22
3.3.1 新算法的提出 ........ 22
3.3.2 考虑机械臂转角限位时算法的改进 ........ 22
3.4 收敛性分析 ....... 23
3.5 仿真研究 ..... 26
3.6 本章小结 ..... 29
第 4 章 带扰动的非线性系统的快速迭代学习控制......31
4.1 引言 ....... 31
4.2 问题的描述 ....... 32
4.3 主要结果 ..... 33
4.4 收敛性证明 ....... 34
4.5 仿真研究 ..... 36
4.6 本章小结 ..... 38
第 5 章 具有可变遗忘因子的迭代学习算法.....39
5.1 引言 ....... 39
5.2 新算法的提出 ......... 39
5.3 主要结果 ..... 41
5.4 可变遗忘因子的设计 ......... 44
5.5 系统模型转换 ......... 45
5.6 仿真研究 ..... 46
5.7 本章小结 ..... 48

第5章 具有可变遗忘因子的迭代学习算法及在机械臂中的应用

5.1 引言
ILC 算法自 1984 年由 Arimoto 等人提出以来就一直受到控制界的广泛关注。它适用于一类具有重复运动特性的被控对象，其任务是寻找最优的控制输入，使得被控系统的实际输出轨迹在有限时间区间上实现与期望输出轨迹的完全跟踪[66]。文献[67]对于重复运行的被控系统，设计了开环 P 型以及闭环 P 型迭代学习控制器，实现了在有限时间区间内对期望轨迹的跟踪。文献[68]中采用的开闭环 PD 型迭代学习律，与 P 型学习律相比增加了误差信息量，提高了收敛速度，但因导数信号的引入增加了测量难度。文献[67,68]的学习律都是因果型迭代学习律，即利用前一次迭代的t时刻的误差信息来调节下一次t时刻的学习律。文献[55]中综述了因果型迭代学习律与非因果型迭代学习律的区别，即非因果型学习律是利用前一次迭代中未来时刻的误差信息来调节学习律，非因果型学习律由于利用了前次迭代的未来时刻的误差信息，使得控制器具有提前补偿未来扰动的功能。文献[69]提出了带有遗忘因子的迭代学习律，削弱了系统模型不确定部分和非重复干扰对系统收敛性的影响，但文献中引入的遗忘因子被设为固定常数，从而不能随系统特性的变化而实时调整，使得迭代学习律无法得到令人满意的收敛效果。针对以上问题，本文提出了具有可变遗忘因子的非因果型迭代学习算法。该算法不要求迭代初态与期望初态一致，并且能利用前一次迭代控制中未来时刻的误差信息来调整下一次的控制律，既增加了信息量又避免了导数信号的使用；同时，引入的可变遗忘因子能根据系统特性的变化自行调节学习律，很好的处理了跟踪速度和稳态误差的矛盾。本文所提新算法兼备了 D 型控制算法的超前性和 P 型控制算法易于执行的特性。
………………

结 论

ILC 不要求已知被控对象的精确数学模型，并且只需系统较少的先验知识，从而引起学者们的广泛关注和探讨。本文对迭代学习控制的收敛速度问题进行了深入研究，主要开展了以下工作：
(1)对于含有初始误差的机器人的轨迹跟踪问题，首先将机器人系统的动力学方程转化为状态方程，然后采用指数变增益的非因果型迭代学习算法对其进行控制。学习增益在迭代过程中有效的变化，从而加快了迭代学习的收敛速度。
(2)由于迭代学习算法不需要精确的数学模型，且对未建模的系统有一定的鲁棒性，由此本文针对具有状态扰动和输出干扰的一类非线性系统的轨迹跟踪问题，采用了带角度修正的 ILC 算法。用输出向量的角度关系作为反馈系数，用来判断控制输入好坏，依此对学习律的变化趋势做出“奖惩”，因此收敛速度得到了有效提高。
(3)对于一般的非线性系统，采用了一种具有可变遗忘因子的非因果型迭代学习算法。非因果型迭代学习律相比于因果型学习律在迭代过程中使用了未来时刻的误差信息，不仅增加了信息量还使得控制器具有提前补偿未来扰动的功能；引入可变的遗忘因子可以根据系统所处的状态有效的调节控制输入同时沿迭代方向进行滤波，从而加快了收敛速度，并削弱了系统的不确定部分对收敛性的影响。最后将此方法应用于机械臂的轨迹跟踪控制，达到了较好的收敛效果。
……………
参考文献（略）

⑦ 什么是算法，它的五大特性是什么，算法和程序的关系是什么

算法（Algorithm）是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。
一个算法应该具有以下五个重要的特征：
有穷性（Finiteness）
算法的有穷性是指算法必须能在执行有限个步骤之后终止；
确切性(Definiteness)
算法的每一步骤必须有确切的定义；
输入项(Input)
一个算法有0个或多个输入，以刻画运算对象的初始情况，所谓0个输入是指算法本身定出了初始条件；
输出项(Output)
一个算法有一个或多个输出，以反映对输入数据加工后的结果。没有输出的算法是毫无意义的；
可行性(Effectiveness)
算法中执行的任何计算步骤都是可以被分解为基本的可执行的操作步，即每个计算步都可以在有限时间内完成（也称之为有效性）。
算法和程序的关系是：
算法就是程序的灵魂，一个需要实现特定功能的程序，实现它的算法可以有很多种，所以算法的优劣决定着程序的好坏。
程序就是遵循一定规则的、为完成指定工作而编写的代码。有一个经典的等式阐明了什么叫程序：程序
=
算法
+
数据结构
+
程序设计方法
+
语言工具和环境
。

⑧ 迭代学习控制算法和传统PID相比哪个抗干扰性更好一些

迭代学习控制算法只能应用在干扰小或者干扰重复出现的情况下，如果新来一个系统未知的新型干扰，系统要重新学习，在学习过程中系统刚度会受影响。而当系统学习完成后，如果此类干扰不再出现，系统白学啦。
传统的PID控制方法是对宽域的干扰都有免疫力，并且不要时刻调整，缺点是当控制对象发生变化后，系统仍然使用老PID参数（这当然已经不是最优的参数了），导致对象可控性变坏。
问开环与闭环的问题，开来你控制还没有入门，好好学吧。

⑨ 算法的定义

算法（algorithm）是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。如果一个算法有缺陷，或不适合于某个问题，执行这个算法将不会解决这个问题。不同的算法可能用不同的时间、空间或效率来完成同样的任务。一个算法的优劣可以用空间复杂度与时间复杂度来衡量。

⑩ 迭代法是什么

迭代算法是用计算机解决问题的一种基本方法。它利用计算机运算速度快、适合做重复性操作的特点，让计算机对一组指令（或一定步骤）进行重复执行，在每次执行这组指令（或这些步骤）时，都从变量的原值推出它的一个新值。

利用迭代算法解决问题，需要做好以下三个方面的工作：

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

二、建立迭代关系式。所谓迭代关系式，指如何从变量的前一个值推出其下一个值的公式（或关系）。迭代关系式的建立是解决迭代问题的关键，通常可以使用递推或倒推的方法来完成。

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

例 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 分钟后容器内充满了阿米巴。已知容器最多可以装阿米巴 2 20 个。试问，开始的时候往容器内放了多少个阿米巴？请编程序算出。

分析： 根据题意，阿米巴每 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

例 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

迭代法

迭代法是用于求方程或方程组近似根的一种常用的算法设计方法。设方程为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） 方程虽然有解，但迭代公式选择不当，或迭代的初始近似根选择不合理，也会导致迭代失败。
递归

递归是设计和描述算法的一种有力的工具，由于它在复杂算法的描述中被经常采用，为此在进一步介绍其他算法设计方法之前先讨论它。
能采用递归描述的算法通常有这样的特征：为求解规模为N的问题，设法将它分解成规模较小的问题，然后从这些小问题的解方便地构造出大问题的解，并且这些规模较小的问题也能采用同样的分解和综合方法，分解成规模更小的问题，并从这些更小问题的解构造出规模较大问题的解。特别地，当规模N=1时，能直接得解。
【问题】 编写计算斐波那契（Fibonacci）数列的第n项函数fib（n）。
斐波那契数列为：0、1、1、2、3、……，即：
fib(0)=0;
fib(1)=1;
fib(n)=fib(n-1)+fib(n-2) （当n>1时）。
写成递归函数有：
int fib(int n)
{ if (n==0) return 0;
if (n==1) return 1;
if (n>1) return fib(n-1)+fib(n-2);
}
递归算法的执行过程分递推和回归两个阶段。在递推阶段，把较复杂的问题（规模为n）的求解推到比原问题简单一些的问题（规模小于n）的求解。例如上例中，求解fib(n)，把它推到求解fib(n-1)和fib(n-2)。也就是说，为计算fib(n)，必须先计算fib(n-1)和fib(n- 2)，而计算fib(n-1)和fib(n-2)，又必须先计算fib(n-3)和fib(n-4)。依次类推，直至计算fib(1)和fib(0)，分别能立即得到结果1和0。在递推阶段，必须要有终止递归的情况。例如在函数fib中，当n为1和0的情况。
在回归阶段，当获得最简单情况的解后，逐级返回，依次得到稍复杂问题的解，例如得到fib(1)和fib(0)后，返回得到fib(2)的结果，……，在得到了fib(n-1)和fib(n-2)的结果后，返回得到fib(n)的结果。
在编写递归函数时要注意，函数中的局部变量和参数知识局限于当前调用层，当递推进入“简单问题”层时，原来层次上的参数和局部变量便被隐蔽起来。在一系列“简单问题”层，它们各有自己的参数和局部变量。
由于递归引起一系列的函数调用，并且可能会有一系列的重复计算，递归算法的执行效率相对较低。当某个递归算法能较方便地转换成递推算法时，通常按递推算法编写程序。例如上例计算斐波那契数列的第n项的函数fib(n)应采用递推算法，即从斐波那契数列的前两项出发，逐次由前两项计算出下一项，直至计算出要求的第n项。
【问题】 组合问题
问题描述：找出从自然数1、2、……、n中任取r个数的所有组合。例如n=5，r=3的所有组合为： （1）5、4、3 （2）5、4、2 （3）5、4、1
（4）5、3、2 （5）5、3、1 （6）5、2、1
（7）4、3、2 （8）4、3、1 （9）4、2、1
（10）3、2、1
分析所列的10个组合，可以采用这样的递归思想来考虑求组合函数的算法。设函数为void comb(int m,int k)为找出从自然数1、2、……、m中任取k个数的所有组合。当组合的第一个数字选定时，其后的数字是从余下的m-1个数中取k-1数的组合。这就将求m 个数中取k个数的组合问题转化成求m-1个数中取k-1个数的组合问题。设函数引入工作数组a[ ]存放求出的组合的数字，约定函数将确定的k个数字组合的第一个数字放在a[k]中，当一个组合求出后，才将a[ ]中的一个组合输出。第一个数可以是m、m-1、……、k，函数将确定组合的第一个数字放入数组后，有两种可能的选择，因还未去顶组合的其余元素，继续递归去确定；或因已确定了组合的全部元素，输出这个组合。细节见以下程序中的函数comb。
【程序】
# include
# define MAXN 100
int a[MAXN];
void comb(int m,int k)
{ int i,j;
for (i=m;i>=k;i--)
{ a[k]=i;
if (k>1)
comb(i-1,k-1);
else
{ for (j=a[0];j>0;j--)
printf(“%4d”,a[j]);
printf(“\n”);
}
}
}

void main()
{ a[0]=3;
comb(5,3);
}
【问题】 背包问题
问题描述：有不同价值、不同重量的物品n件，求从这n件物品中选取一部分物品的选择方案，使选中物品的总重量不超过指定的限制重量，但选中物品的价值之和最大。
设n 件物品的重量分别为w0、w1、…、wn-1，物品的价值分别为v0、v1、…、vn-1。采用递归寻找物品的选择方案。设前面已有了多种选择的方案，并保留了其中总价值最大的方案于数组option[ ]，该方案的总价值存于变量maxv。当前正在考察新方案，其物品选择情况保存于数组cop[ ]。假定当前方案已考虑了前i-1件物品，现在要考虑第i件物品；当前方案已包含的物品的重量之和为tw；至此，若其余物品都选择是可能的话，本方案能达到的总价值的期望值为tv。算法引入tv是当一旦当前方案的总价值的期望值也小于前面方案的总价值maxv时，继续考察当前方案变成无意义的工作，应终止当前方案，立即去考察下一个方案。因为当方案的总价值不比maxv大时，该方案不会被再考察，这同时保证函数后找到的方案一定会比前面的方案更好。
对于第i件物品的选择考虑有两种可能：
（1） 考虑物品i被选择，这种可能性仅当包含它不会超过方案总重量限制时才是可行的。选中后，继续递归去考虑其余物品的选择。
（2） 考虑物品i不被选择，这种可能性仅当不包含物品i也有可能会找到价值更大的方案的情况。
按以上思想写出递归算法如下：
try(物品i，当前选择已达到的重量和，本方案可能达到的总价值tv)
{ /*考虑物品i包含在当前方案中的可能性*/
if(包含物品i是可以接受的)
{ 将物品i包含在当前方案中；
if (i
try(i+1,tw+物品i的重量,tv);
else
/*又一个完整方案，因为它比前面的方案好，以它作为最佳方案*/
以当前方案作为临时最佳方案保存;
恢复物品i不包含状态；
}
/*考虑物品i不包含在当前方案中的可能性*/
if (不包含物品i仅是可男考虑的)
if (i
try(i+1,tw,tv-物品i的价值)；
else
/*又一个完整方案，因它比前面的方案好，以它作为最佳方案*/
以当前方案作为临时最佳方案保存;
}
为了理解上述算法，特举以下实例。设有4件物品，它们的重量和价值见表：
物品 0 1 2 3
重量 5 3 2 1
价值 4 4 3 1

并设限制重量为7。则按以上算法，下图表示找解过程。由图知，一旦找到一个解，算法就进一步找更好的佳。如能判定某个查找分支不会找到更好的解，算法不会在该分支继续查找，而是立即终止该分支，并去考察下一个分支。

按上述算法编写函数和程序如下：
【程序】
# include
# define N 100
double limitW,totV,maxV;
int option[N],cop[N];
struct { double weight;
double value;
}a[N];
int n;
void find(int i,double tw,double tv)
{ int k;
/*考虑物品i包含在当前方案中的可能性*/
if (tw+a.weight<=limitW)
{ cop=1;
if (i
else
{ for (k=0;k
option[k]=cop[k];
maxv=tv;
}
cop=0;
}
/*考虑物品i不包含在当前方案中的可能性*/
if (tv-a.value>maxV)
if (i
else
{ for (k=0;k
option[k]=cop[k];
maxv=tv-a.value;
}
}

void main()
{ int k;
double w,v;
printf(“输入物品种数\n”);
scanf((“%d”,&n);
printf(“输入各物品的重量和价值\n”);
for (totv=0.0,k=0;k
{ scanf(“%1f%1f”,&w,&v);
a[k].weight=w;
a[k].value=v;
totV+=V;
}
printf(“输入限制重量\n”);
scanf(“%1f”,&limitV);
maxv=0.0;
for (k=0;k find(0,0.0,totV);
for (k=0;k
if (option[k]) printf(“%4d”,k+1);
printf(“\n总价值为%.2f\n”,maxv);
}
作为对比，下面以同样的解题思想，考虑非递归的程序解。为了提高找解速度，程序不是简单地逐一生成所有候选解，而是从每个物品对候选解的影响来形成值得进一步考虑的候选解，一个候选解是通过依次考察每个物品形成的。对物品i的考察有这样几种情况：当该物品被包含在候选解中依旧满足解的总重量的限制，该物品被包含在候选解中是应该继续考虑的；反之，该物品不应该包括在当前正在形成的候选解中。同样地，仅当物品不被包括在候选解中，还是有可能找到比目前临时最佳解更好的候选解时，才去考虑该物品不被包括在候选解中；反之，该物品不包括在当前候选解中的方案也不应继续考虑。对于任一值得继续考虑的方案，程序就去进一步考虑下一个物品。
【程序】
# include
# define N 100
double limitW;
int cop[N];
struct ele { double weight;
double value;
} a[N];
int k,n;
struct { int ;
double tw;
double tv;
}twv[N];
void next(int i,double tw,double tv)
{ twv.=1;
twv.tw=tw;
twv.tv=tv;
}
double find(struct ele *a,int n)
{ int i,k,f;
double maxv,tw,tv,totv;
maxv=0;
for (totv=0.0,k=0;k
totv+=a[k].value;
next(0,0.0,totv);
i=0;
While (i>=0)
{ f=twv.;
tw=twv.tw;
tv=twv.tv;
switch(f)
{ case 1: twv.++;
if (tw+a.weight<=limitW)
if (i
{ next(i+1,tw+a.weight,tv);
i++;
}
else
{ maxv=tv;
for (k=0;k
cop[k]=twv[k].!=0;
}
break;
case 0: i--;
break;
default: twv.=0;
if (tv-a.value>maxv)
if (i
{ next(i+1,tw,tv-a.value);
i++;
}
else
{ maxv=tv-a.value;
for (k=0;k
cop[k]=twv[k].!=0;
}
break;
}
}
return maxv;
}

void main()
{ double maxv;
printf(“输入物品种数\n”);
scanf((“%d”,&n);
printf(“输入限制重量\n”);
scanf(“%1f”,&limitW);
printf(“输入各物品的重量和价值\n”);
for (k=0;k
scanf(“%1f%1f”,&a[k].weight,&a[k].value);
maxv=find(a,n);
printf(“\n选中的物品为\n”);
for (k=0;k
if (option[k]) printf(“%4d”,k+1);
printf(“\n总价值为%.2f\n”,maxv);
}

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