常见算法

常见算法

1.累加/累积

累加：将一系列的数据加到一个变量里，最后得到累加的结果。

比如：从1累加到100。

var sum = 0;
for(var i=1; i<=100; i++){
    sum+=i;
}
alert(sum);

输出：5050

 

var height = 100;
var s = 0;
for(var i=1;i<=10;i++){
    height = height/2
    s+=height;
}
s = s*2+100;
alert(s);

输出：200.8046

累积：n*(n-1)*(n-2)*...*1

var n = 10;
var result= 1;
for (var i = 1; i <= n; i++) {
    result *= i;
}
alert(result);

一般形式：

累加：v += e;

累积：v *= e；

v代表累加/累积，e代表累加/累积项

算法要点：

（1）初始化

v的初始化：

累加：v = 0；

累积：v = 1；

e的初始化，如果累加/累积项比较复杂，可能会分解为几个子项分别初始化。

（2）循环的控制条件

一种是固定次数，一种是不固定次数。

（3）确定累加/累积项的变化

2.迭代

迭代法也叫辗转法

规律：就是可以不断的用旧的值得到新的值，一直到我们想要得到的结果

遇到了迭代问题怎么去解决：

（1）找到迭代的变量（旧的值）

（2）确定迭代的关系

（3）知道想要的结果是什么（结束循环的条件）

   ①知道最终的结果

   ②循环的次数

例子：求两个数的最小公约数。

function Gcd(x, y) {
    var z = 0;//余数
    if (x >= y) {
        while(x % y != 0) {
            z= x % y;
            x = y;
            y = z;
        }
        returny;
    } else {
        while(y % x != 0) {
            z= y % x;
            y = x;
            x = z;
        }
        returnx;
    }
}

 

3.递推

 解决思路：

   找到数学规律，通过公式计算到下一项的值，一直到我们要的结果为止。

例如：兔子产子，幼崽两个月后可以产仔，通过前两项得到第三项

月份    0  1   2   3  4   5   6
幼崽    1   1  1   2   3  5   8
成年    0   0  1   1   2   3   5
总共    1   1  1   3   5   8   13

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]);

递推分为顺推和逆推。

4.穷举

穷举方法的特点是简单，但是计算量大，但是计算机的运行速度快，运行100次和1000次没什么区别，所有有时候用穷举可以取得不错的办法。

遇到一个问题，找不到更好的解决办法（找不到数学公式或者规律）时，使用穷举，利用计算机计算速度快的特点，将所有的可能性全部列举出来，并将我们想要的结果记录下来。

例如：百钱买百鸡

/*
* 公鸡五块钱，母鸡三块钱。三只小鸡一块钱
* 百钱买百鸡
*
* */
for(varcock=0; cock<=20; cock++){
    for(var hen=0; hen<=33; hen++){
        var chick = 100-cock-hen;
        if(cock*5 + hen*3 + chick/3 == 100){
            document.write("鸡翁一共:"+cock+"母鸡一共:"+hen+"小鸡一共:"+chick+"<br>");
        }
    }
}

 

5.递归

所谓递归，在函数内部又去调用自己

例如，求阶乘问题，在fact函数内部又去调用fact函数了。

alert(fact(5));
function fact(n){
    if(1 == n){
        return 1;
    }
    return n*fact(n-1);
}

递归算法如果按照常规思路去理解是非常复杂的，函数调用一层一层嵌套调用，然后又一层层返回。可以换个思路去理解递归。

递归实际上就是将规模为n的问题降价为n-1的问题进行求解。也就是去找n和n-1之间的关系。