数组，字符串算法题

最新推荐文章于 2024-03-19 19:41:24 发布

原创最新推荐文章于 2024-03-19 19:41:24 发布 · 446 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#网页版计算器 #数组和字符串算法 #冒泡排序和递归算法 #slice和splice区别

unreachable code after return statement，是什么错误？

即由于return会阻止其后的语句执行

在return语句之后的不可执行的语句会在下列情形中产生：

· 在return 语句之后出现其他表达式；

· 在省略分号的return语句之后直接接一个表达式。

当一个表达式出现在一个有效的 return 表达式之后时，会出现这个警告，用以说明在 return 语句之后的表达式不可达，即这条语句之后的表达式永远不会运行。

在省略分号的 return 语句之后，开发者想要终止当前函数的执行还是返回return之后表达式的结果的意图是不明确的这个警告表明这种情况下 return 语句的表述具有二义性。

当在省略分号的return语句之后出现下列语句时，不会出现警告：

· throw· break· var· function；

闭包函数的注意事项

闭包函数可以将每上一次执行的结果存起来，即重复调用时，每一个调用都会记住上一次调用后的值

var a5 = fun(0);    /!*undefind 此时0没有赋值，n=0*!/
a5.fun(1);           /!*0 赋值的是m的值m=1 *!/
a5.fun(2);            /!*0 m=2*!/
a5.fun(3);            /!*0 m=3*!/!*!/
/!*var b = fun(0).fun(1).fun(2).fun(3);    undefined 0 1 2 赋值的是n的值*!/
var c = fun(0).fun(1);   /!*undefined 0*!/
c.fun(2); c.fun(3); */     /*1 1*/

数组相关算法

冒泡排序

外层循环不变，内层循坏length-i-1

/*var a=new Array(1,2,4,5,6,3,0,9,7,8,10)
var jian="";
for( i=0;i< a.length;i++){
for(j=0;j< a.length-i-1;j++){
if(a[j]>a[j+1]){
jian=a[j];
a[j]=a[j+1];
a[j+1]=jian;
}
}
}
console.log(a)*/

数组去重

方法1：利用在原数组中删除重复元素，注意删除后元素的下标会变，所以可能出现相邻元素不能完全删除的情况，
所以每删除后改变之前k的值，让其重新从此元素相邻位置开始查找*/
/*var m=new Array(1,2,2,2,2,4,5,5,5,6,7,8,9,9)
for(a=0;a< m.length;a++){
for(b=a+1;b< m.length;b++){
if(m[a]==m[b]){
m.splice(b,1);
b--; /!*注意*!/
}
}
}
console.log(m)*/

方法2，创建一个空数组利用indexOf方法将找出来的单个字符串全部放入新数组中
var m=new Array(1,2,2,2,2,4,5,5,5,6,7,8,9,9);
var n=[];
for(var i=0;i< m.length;i++){
    if(n.indexOf(m[i])==-1){
        n.push(m[i]);
    }
}
console.log(n);

找出数组中重复出现的最大值和下标。用ascii比较

平衡数组利用奇偶性

var a=[10,1000,10000,100,100000];

字符串相关算法

1.例子（如果用字母n来代表一个整数，阶乘代表着所有小于或等于n的整数的乘积。阶乘通常简写成 n! ；例如: 5! = 1 * 2 * 3 * 4 * 5 = 120）
要求：factorialize(0)?应该返回 1.*/
/*方法1*/
function fn(n)
{
var m=1;
for(i=1;i<=n;i++)
{
m=m*i;
}
return(m)
}
console.log(fn(5));
/*方法2*/
function fn1(n)
{
if(!n==0)
{
var m = 1;
for (i = 1; i < n; i++)
{
m = m * (i + 1);
}
return (m);
}
else
{
return(1)
}
}
console.log(fn1(5));

/*2.找到提供的句子中最长的单词，并计算它的长度。注意：函数的返回值为数字；
var a="The quick brown fox jumped over the lazy dog"
function fn3() {
var b = a.split(" ");        /*先将字符串以空格分开为多个字符串的数组集合。用下标调用 */
var kong = [];
kong[0] = "";
kong[1] = 0;
for (i = 0; i < b.length; i++)    /*此处的b[i].length为数组第一个字符串的长度注意.length也为字符串的属性，表示字符串的长度 */
{
if (b[i].length > kong[1])
{
kong[0]=b[i];
kong[1] = b[i].length;
}
}
var src=kong.join("");            /* 最后输出还要将数组转化为字符串输出*/
return(console.log(src));
}
fn3();

/*3实现每个字符串的首字母都大写*/
var x="I'm a little tea pot";
var y=x.split(" ");
function fn4()
{
    for (i = 0; i < y.length; i++)
    {
        y[i] = y[i].substr(0, 1).toLocaleUpperCase() + y[i].substr(1, y[i].length - 1)
    }
    /*两者是返回字符串，两者的区别一般数组用join*/
/*   console.log(y.toString(" "))       /!*I'm,A,Little,Tea,Pot*!/*/
    console.log(y.join(" "))              /* I'm A Little Tea Pot*/
}
fn4()

/*4.把一个数组arr按照置顶的数组大小size分割成若干数组块
例如:chunk([1,2,3,4],2)=[[1,2],[3,4]];
chunk([1,2,3,4,5],2)=[[1,2],[3,4],[5]];*/
/*方法1*/

var m=[1,2,3,4,5,6];
function fn10()
{
    var a=2;
    var n=[];
    for( var i=0;i< m.length;i++)
    {
     n.push(m.slice(i,i+a));
     i=i+a-1;
    }
    return(console.log(n));
}
fn10();
/*方法2*/
function fn9(a,s)
{
    var n=[];
    for(var i=0;i<a.length;i+=s)
    {
        n.push(a.slice(i,i+s));
    }
    return (console.log(n));
}
fn9(["a","b","n","m","c","d"],2);

/*5.重复一个指定的字符串num次，如果num是负数则返回空字符串*/
function fn8(a)
{
    var n = "你好，欢迎光临";
    var m="";
    if(a==0)
    {
/*        return(m);           /!*return之后的表达式终止不再执行所以错误*!/
        console.log(m);*/
        console.log(m);            /*或return(console.log(m))*/
    }
    else
    {
        m=n.repeat(a);  /*将一个字符串重复多次输出*/
        console.log(m);
    }
}
fn8(2);

数组字符串结合函数实现网页版计算器

实现效果如图所示

Html代码

<table>
    <tr>
        <td colspan="4"><input id="text" disabled value="0" type="text"/></td>    
    </tr>
    <tr>
        <td colspan="2"><button class="btn">AC</button></td>
        <td colspan="2"><button class="btn">DEL</button></td>
    </tr>
    <tr>
        <td><button class="btn">7</button></td>
        <td><button class="btn">8</button></td>
        <td><button class="btn">9</button></td>
        <td><button class="btn">/</button></td>
    </tr>
    <tr>
        <td><button class="btn">4</button></td>
        <td><button class="btn">5</button></td>
        <td><button class="btn">6</button></td>
        <td><button class="btn">*</button></td>
    </tr>
    <tr>
        <td><button class="btn">1</button></td>
        <td><button class="btn">2</button></td>
        <td><button class="btn">3</button></td>
        <td><button class="btn">-</button></td>
    </tr>
    <tr>
        <td><button class="btn">0</button></td>
        <td><button class="btn">.</button></td>
        <td><button class="btn">+</button></td>
        <td><button class="btn">=</button></td>
    </tr>
</table>

Js代码

window.onload=function(){
    /!*定义一个空数组存放数字符号*!/
    var kong=[];
    var iskeyFu=0;     /!* 为了实现输入重复的符号默认为最后一个输入的代码，*!/
    /!*获取的是所有btn为一个数组*!/
    var obj=document.getElementsByClassName("btn");
    var a=document.getElementById("text");
    /!*js里面不能实现隐式迭代（js不能操作一堆对象）所以要用数组获取里面每一个元素用for*!/
    for(i=0;i<obj.length;i++){
        /!*     动态给对象添加事件   对象.事件=function(){}*!/
        obj[i].onclick=function(){
            //在js动态绑定事件里面，要使用当前对象用this    事件里面的this指代的是当前事件的执行对象
            /!*innerHTML 指的是标签的html内容*!/
            /!* a.value+=this.innerHTML;           /!*+=对于数字没意义，对于字符串起在之前的元素后面连接的作用*!/!*!/
            /!*实现只点击数字和点出现在屏幕上*!/
            if(!isNaN(this.innerHTML)||this.innerHTML==".")
            {     /!*判断屏幕上有没有0，再判断电击的值是点还是数字*!/
                iskeyFu=0;         /!* 当输入符号=0时，正常*!/
                if(a.value=="0")
                {
                    if(this.innerHTML==".")
                    {
                        a.value="0"+this.innerHTML;      /!*有0，且电击的值是点让其显示格式为0.几*!/
                    }
                    else{
                        a.value=this.innerHTML;         /!*有0，且电击的值是数字则正常只显示数字*!/
                    }
                }
                /!*对于有没有点进行逻辑判断如果屏幕有点则不上去点没有则上去点，即每次屏幕只能显示一个点*!/
                else{
                    if(a.value.indexOf(".")!=-1)   /!*如果屏幕上有点则判断点击的值是不是点*!/
                    {
                        if(this.innerHTML!=".")       /!*屏幕上有点且点击的值不是点则正常显示在屏幕上*!/
                        {
                            a.value+=this.innerHTML;
                        }
                        /!*屏幕上有点且点击的值也是点则保持屏幕上的值不变一直是点*!/
                    }
                    else{
                        a.value+=this.innerHTML;         /!* 屏幕上没点，则点击什么显示什么*!/
                    }
                }
            }
            /!*点击符号的样式*!/
            /!*如果点击运算符*!/
            if(this.innerHTML=="+"||this.innerHTML=="-"||this.innerHTML=="*"||this.innerHTML=="/")
            {
                iskeyFu++;             /!*每输入一个符号，值加1当值>2时，将数组符号位的值改为最后依次输入的值，否则跳出*!/
                if(iskeyFu>=2)
                {
                    kong[kong.length-1]=this.innerHTML;
                    return;
                }
                kong[kong.length]= a.value;
                kong[kong.length]=this.innerHTML;
                console.log(kong);
                a.value=0;       /!*实现每次安符号之后屏幕清0*!/
            }
            /!*如果点击=号*!/
            if(this.innerHTML=="=")
            {
                kong[kong.length]= a.value;         /!*为了实现连乘或其他连续运算*!/
                console.log(kong);
                a.value=eval(kong.join(""));          /!* eval内置函数实现字符串的运算但是前提是要将数组转化为字符串*!/
                kong=[];
            }
            if(this.innerHTML=="AC")           /!*实现清零功能注意也要将数组清空*!/
            {
                kong=[];
                a.value=0;
            }
            if(this.innerHTML=="DEL")
            {
                /!* substr 截取字符串的方法*!/
                a.value=a.value.substr(0,a.value.length-1);       /!*实现删除功能注意最后默认的0不能清掉*!/
                if( a.value.length==0)
                {
                    a.value="0";
                }
            }
        }
    }
}

总结问题：

slice和splice都是截取数组

区别：

splice截取后原有数组长度变化，下标也随之变化；

slice截取后原有数组下标长度不变，所以一般这个用起来方便，不用考虑截取后的变化

var m=[1,2,3,4,5,7,9,0];
       var e=(m.splice(0,2));
        console.log(e)              /!*Array [ 1, 2 ]*!/
        console.log(m);           /!* Array [ 3, 4, 5, 7, 9, 0 ]*!/
        console.log(m.length);                /!* 6*!/
        console.log(m[2]);                         /!*5*!/
var e=(m.slice(0,2));
console.log(e)              /!*Array [ 1, 2 ]*!/
console.log(m);            /!*Array [ 1，23, 4, 5, 7, 9, 0 ]*!/
console.log(m.length);                 /!*8*!/
console.log(m[2]);                 /!*3*!/