【学习笔记22】js算法整理

1.分别用while，for，do...while这三种方式递归算法实现10！

 //for循环
 var sum=1;
for(var i=1;i<=10;i++){
    sum*=i;
}
console.log(sum);
    //while循环
var i=10,sum=1;
while(i>0){
    sum*=i;
    i--;
}
console.log(sum);
//do...while循环
var i=1,sum=1;
do{
    sum*=i;
    i++;
}while(i<=10);
console.log(sum);

2.打印9*9乘法表

形式一：

1*1 = 1

1*2 = 2  2*2 = 4

1*3 = 3  2*3 = 6  3*3 = 9

...

1*9 = 9  2*9 = 18 3*9 = 27 ... 9*9 = 81

形式二：

1*9 = 9  2*9 = 18 3*9 = 27 ... 9*9 = 81

...

1*3 = 3  2*3 = 6  3*3 = 9

1*2 = 2  2*2 = 4

1*1 = 1

//方法1
        //正序乘法表
        var s='';
        for(var n=1;n<=9;n++){
            for(var m=1;m<=n;m++){
                s+=m+'*'+n+'='+m*n+'\t';
            }
            s+='\n';
        }
        console.log(s);
        //倒序乘法表
        var sum='';
        for(var n=9;n>=1;n--){
            for(var m=1;m<=n;m++){
                sum+=m+'*'+n+'='+m*n+'\t';
            }
            sum+='\n';
        }
        console.log(sum)
        //方法2
        //正序打印乘法表
        for (var i = 1; i <= 9; i++) {
            for (var j = 1; j <= i; j++) {
                document.write(j + "*" + i + '=' + i * j + '&nbsp;&nbsp;&nbsp;')
            if (i == j) {
                document.write("<br/>")
                } 
            }
        }
        //倒序打印乘法表
        document.write("<br/>");
        for (var i = 9; i >=1; i--) {
            for (var j = 1; j <= i; j++) {
                document.write(j + "*" + i + '=' + i * j + '&nbsp;&nbsp;&nbsp;')
            if (i == j) {
                document.write("<br/>");
                } 
            }
        }

3.有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？

//i为百位上数字，j为十位上数字，k为个位上数字  
      var i,j,k,sum;
        var n=0;
        for(i=1;i<=4;i++){
            for(j=1;j<=4;j++){
                for(k=1;k<=4;k++){
                    if(i!=j && i!=k && j!=k){
                        sum=i*100+j*10+k;
                        console.log(sum);
                        n++
                    }
                }
            }
        }
        console.log("一个有"+n+"个");

4.判断101-200之间有多少个素数，并输出所有素数（只能被1和它本身整除的自然数为素数）

        //方法1：假设是素数，若是真则返回true，反之返回false
        let count=0;
        for (let n=101;n<=200;n++){
            let tf=true;
            for(let i=2;i<n;i++){
                if(n%i==0){
                    tf=false;//不是素数
                }
            }
            if(tf){
                count++;
            }
        }
        console.log(count);
        //方法2
        var cont=0;
        for(var n=101;n<=200;n++){  //被除数n
            for(var m=2;m<n;m++){   //除数m
                if(n%m==0){          //若n能整除m,则说明n不是素数，m+1继续for循环
                    break;
                }
            }
            if(m==n){              //直到m=n时才跳出循环，说明n是素数。
                console.log(n);
                cont++;
            }
        }
        console.log("一个有"+cont+"个素数。");

5.打印出所有的“水仙花数”，所谓“水仙花数”是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个“水仙花数”，因为153=1的三次方＋5的三次方＋3的三次方。

// 1.三位数  100-999  i  
// 2.个十百位的三次方加起来等于它本身 bsg
// 3.逻辑：先把三位数全部循环出来，然后判断他的每一位是否符合我们需要的条件
// 4.外层循环：三位数的循环
// 5.表示个十百位：123  123%100  123%100/10  123%100%10

for(var i=100;i<=999;i++){      //取100-999之间的所有数
    var b =parseInt(i/100)      //取百位数
    var s= parseInt((i%100)/10)     //取十位数
    var g = i%100%10            //取个位数
    if(b*b*b+s*s*s+g*g*g==i){       //百 十 个 数的3次方全等于i结果为水仙花数
        console.log(i);
    }
}

6.数组的增删

1）在尾部新增任意多个数据（即栈操作push）

核心代码引入：

arr1=[100,200,300];

arr1[arr1.length]=400;//即arr1[3]=400,此时，arr1=[100,200,300,400],长度为4

arr1[arr1.length0=500;//即arr1[4]=500,此时，arr1=[100,200,300,400,500];长度为5

相关代码：

function myAdd(){
	//内部实际参数的变量arguments
	//this指代的是arr数组
	for(var key in arguments){
		var value = arguments[key];
		this[this.length] = value;
	}
}

函数调用（注意：该函数没有在原型里面，所以无法用.方法的形式直接调用）

var arr4=[100,200];

myAdd.call(arr4,300,400,500,600);

console.log(arr4);

//结果：[100,200,300,400,500,600]

2)删除数组尾部数据，并返回删除的单个数据（即栈操作 pop）

算法思想：

①先保存最后一个元素的值；②让数组长度-1；③返回保存的被删除的值

Array.prototype.myRm=function(){
	//this指代的就是Array构造的对象  max=this.length-1
	var value=this[this.length-1];
	this.length--;
	return value;
}

函数调用：（注意与上一种方法的区别）

arr=[200,300,400,'zs','lisi'];

console.log(arr.myRm());

console.log(arr.myRm(),arr.length);

//结果：lisi         zs 3

3）在头部新增任意多个数据，并且返回最终数组长度（即队列操作 unshift）

算法思想：

新增的值依次做插入操作：

①数组长度值+1；②后序遍历 ，从后往前遍历，范围为1~max；③ 当前空间的值=前一个空间的值，即arr[i]=arr[i-1];④arr[0]=新增的值

（注意，其中arguments.length-1是指插入的实参的长度）

Array.prototype.myHeadAdd=function(){

        for(var key=arguments.length-1;key>=0;key--){

                var newvalue=arguments[key];

                this.length++;//this.length=this.length+1; 1.1

                for(var i=this.length-1;i>=1;i--){

                        this[i] = this[i-1];

                        }
                this[0] = newvalue;
        }
return this.length;
}

函数调用：

arr=[1,5,8,"lisi",99];

arr.myHeadAdd('hello');

console.log(arr);

arr.myHeadAdd('zs',22.22,'abc');

console.log(arr);

结果：

["hello", 1, 5, 8, "lisi", 99]
["zs", 22.22, "abc", "hello", 1, 5, 8, "lisi", 99]

4）在数组的头部删除数据，返回删除的单个值（即队列操作shift）

算法思想：

①保存数组第一个元素的值，即保存即将被删除元素的值，re=arr[0];

②正序遍历数组。arr[i]=arr[i+1],0~max-1；③数组长度-1，并返回re

Array.prototype.myHeadRm=function(){

    var result = this[0];

    var i=0;

    while(i<this.length-1){

        this[i]=this[i+1];

        i++;

    }

    this.length--;

    return result;

}

函数调用：

arr=["zs", 22.22, "abc", "hello", 1, 5, 8, "lisi", 99]

console.log(arr.myHeadRm()); //zs

console.log(arr.myHeadRm()); //22.22

console.log(arr.myHeadRm()); //abc

console.log(arr); //["hello", 1, 5, 8, "lisi", 99]

7.数组去重

算法思想：

准备一个空数组，对这个空数组进行遍历，若在空数组中能找到对应元素值，则继续查找下一个元素，若找不到则将这个不重复的元素放入这个空列表中。

var arr=[1,2,1,3,4,5,5];
var s=[];
for(var i=0;i<arr.length;i++){
    if(s.indexOf(arr[i])==-1){  //indexOf从数组开头向后查找，找不到=-1，找得到就！=-1，
        s.push(arr[i]);   //s.indexOf(arr[i]),在s中找不到arr[i]，则等于-1，则向s中加入该arr[i]元素     
            }
        }
console.log(s);

8.数组排序

var arr = [1, 2, 3, 6, 10, 5];
//  sort要以一个比较函数作为参数
console.log(arr.sort(function(a, b) {
    return a - b //[ 1, 2, 3, 5, 6, 10 ],升序
        }))
console.log(arr.sort(function(a, b) {
    return b - a //[ 10, 6, 5, 3, 2, 1 ]，降序
        }))