累加和与累积：
1. 累加：将一系列的数据加到一个变量里面，得到累加的结果。例如：将1到100的数求累加和。
```javascript
var h = 100;
var s = 0;
for (var i = 0; i < 10; i++) {
h = h / 2;
s += h;
}
s = s * 2 + 100;
```
2. 累积：将一系列的数据乘积到一个变量里面，得到累积的结果。常见的就是n的阶乘。
```javascript
var n = 100;
var result = 1;
for (var i = 1; i <= n; i++) {
result *= i;
}
```
算法要点：
- (1)初始化：初始化v和e。累加：v = 0;累积：v = 1。e的初始化，如果累加/积项比较复杂，可能会分解为几个子项分别初始化，比如计算圆周率的问题，累计项分解为符号、分子和分母三部分。
- (2)循环的控制条件：一种是固定的次数，比如计算弹跳距离的问题，计算数列前20项之和的问题。次数不固定，而是要满足某个条件：计算圆周率问题要求最后一项的绝对值，要小于10^-6。
- (3)确定累加/积项的变化：比如数列的前20项之和，是将当前的分子分母之和作为下一次的分母，当前的分母作为分子。再比如求圆周率问题，是将符号取反、分母加2,然后的出下一项。
- 迭代法：迭代法也就是辗转法。规律：就是可以不断地用旧的值得到新的值，直到我们想要的得到的结果。遇到迭代的问题怎么解决？(1)找到迭代的变量(旧的值);(2)确定迭代的关系；(3)知道想要的结果是什么(结束循环的条件)。(1)就是知道最终结果；(2)循环的次数。
以下是重构后的代码：
```javascript
function getGCD(num1, num2) {
if (num1 < num2) {
var t = num1;
num1 = num2;
num2 = t;
}
var remainder = num1 % num2;
while (remainder !== 0) {
num1 = num2;
num2 = remainder;
remainder = num1 % num2;
}
return num2;
}
function calculateRabbits(month) {
var initialRabbits = 1;
var initialLitters = 1;
var rabbitsPerMonth = [1, 1, 1, 2, 3, 5, 8];
if (month < 2) {
return initialRabbits * initialLitters;
} else {
for (var i = month; i >= 2; i--) {
initialRabbits = initialRabbits + initialLitters;
}
return initialRabbits * initialLitters;
}
}
```
```javascript// 思路1
var an_1 = an;
an = sum;
alert(sum);
// 思路2
var month = Number(prompt("输入月份"));
var rabbit = [1, 1];
for (var m = 2; m <= month; m++) {
rabbit[m] = rabbit[m - 1] + rabbit[m - 2];
}
alert(rabbit[month]);
// 穷举方法示例
/*
* 公鸡一值钱5,鸡母一值钱三，鸡仔三值钱一
* 百钱买百鸡，问公鸡，鸡母、鸡仔各几何？
* x y z
* x + y + z = 100
* x * 5 + y * 3 + z / 3 = 100*/
for (var cock = 0; cock <= 20; cock++) {
for (var hen = 0; hen <= 33; hen++) {
var chihen = 100 - cock - hen;
if (100 === cock * 5 + hen * 3 + chihen / 3) {
document.write("公鸡一共：" + cock + "鸡母一共：" + hen + "小鸡一共：" + chihen + "
");
}
}
}
```
递归算法的理解可以非常复杂，通常需要考虑函数的多层嵌套调用和返回。然而，我们可以尝试换一种思路来理解递归：将规模为n的问题转化为规模为n-1的问题进行求解，寻找n和n-1之间的关系。
以下是一些关于递归的基本总结：
* 递归算法是一种通过函数自身的调用来解决问题的算法。
* 在递归过程中，函数会不断将问题规模缩小，直到达到基本情况。
* 递归算法的关键在于找到问题的递归关系式，即将问题分解为更小的子问题。
* 递归算法通常具有较高的空间效率，因为它可以在每次调用时只处理一部分数据。
希望这篇文章能对您学习或工作有所帮助，谢谢您对我们的支持！
