学习数据结构与算法（二）

Hello,everyone !
想以一个轻松愉悦的心情来开始我的每一篇文章。
这是每一次的整理和缩影，希望大家可以发表意见，促进成长。

正值这个特殊时期，在家里开始研究数据结构与算法的问题，若有不对的地方，请各位指教！~~~

接下来主要看一下数组。

一.使用

1.创建数组
最简单的方法就是通过 [ ] 操作符来声明一个变量（推荐这种方法）

var  numbers=[];
print(numbers.length);      //0

还可以用Array的构造函数创建数组

var  numbers=new Array(1,2,3);
print(numbers.length);        //5

在脚本语言里很常见的一个特性，数组中的元素不必是同一种数据类型，这一点和很多编程语言不同。

var  sbjects=["Joe",1,true,null];

可以通过Array.isArray 来判断一个对象是否是数组。

2.读写数组（这里不做介绍）
3.由自负床生成数组 .split()

var  sentence="12454314";
var  array=sentence.split("4");
for(var i=0;i<array.length;++i){
    print("word"+i+":"+array[i]);
}
//word 0：124
//word 1：54
//word 2：314

4.对数组的整体性操作
可以将数组赋给另外一个数组

var  nums=[];
for(var i=0;i<10;++i){
    nums[i]=i+1;
}
var samenums=nums;

但当把一个数组赋给另外一个数组时，通过引用改变了数组的之，另外一个引用也会感知到这个变化。
这种行为称为浅复制，新数组仍指向原来的数组。
可以用深复制。

var  nums=[];
for(var i=0;i<10;i++){
    nums[i]=i+1;
}
var same=[];
copy(nums,same);
nums[0]=400;
print(same[0]);    //1
var nums=[1,2,3,4,5];
print(nums);       //1,2,3,4,5

二.存取函数

访问数组元素的函数
1.查找元素
📖indexOf() 查找传进来的参数在目标函数中是否存在
如果不包含，就返回-1；
如果包含，返回该元素在数组中的索引；
🍗如果数组中包含多个相同的元素
indexOf()函数总是返回第一个与参数相同的元素索引
而
lastIndexOf()该函数返回相同元素中最后一个元素的索引
如果没找到相同元素，则返回-1.
🍗includes()函数，返回布尔值，存在返回真。
2.数组的字符串表示
join() 和 toString()

var  names=["David","Lucy"];
var  namestr=names.join();
print(namestr);           //David,Lucy

事实上，当直接对一个数组使用print()函数时，系统会自动调用 toString()方法。
3.由已有数组创建新数组
concat()和splice()
concat() 可以合并多个数组创建一个新数组

var  strArr=["a","b","c"];
var  strSrr=["1","2',"3"];
var  StrAll=strArr.concat(strSrr);
print(StrAll);                              //a,b,c,1,2,3

splice()截取一个数组的子集创建新数组
该方法的第一个参数是截取的起始索引，第二个参数是截取的长度。

var  itDiv=["Mike","clayton","Terrill","Danny"];
var  dmpDept=itDiv.splice(1.3);
var  cisDept=itDiv;
print(dmpDept);               //clayton,Terrill,Danny
print(cisDept);                 //Mike

三.可变函数
1.为数组添加元素
push()和unshift()
push() 将一个元素添加到数组末尾

var  nums=[1,2,3,4,5];
print(nums);               //1,2,3,4,5
nums.push(6);
print(nums);               //1,2,3,4,5,6

和在数组的末尾加元素比起来，在数组的开头添加元素更难。

var  nums=[2,3,4,5];
var  newnum=1;
var  N=nums.length;
for(var i=N;i>=0;--i){
    num[i]=nums[i-1];
}
nums[0]=newnum;
print(nums);             //1,2,3,4,5

unshift() 可以将元素加在数组的开头

var  nums=[2,3,4,5];
print(nums);            //2,3,4,5
var  newnum=1;
nums.unshift(newnum);
print(nums);            //1,2,3,4,5
nums=[3,4,5];
nums.unshift(newnum,2);
print(nums);            //1,2,3,4,5

2.从数组中删除元素
📖使用pop()方法可以删除数组末尾的元素

var  nums=[1,2,3,4,5,9];
nums.pop();
print(nums);               //1,2,3,4,5

📖shift()方法可以删除数组中的第一个元素

var  nums=[9,1,2,3,4];
nums.shift();
print(nums);             //1,2,3,4

🍗注：
pop()和shift()都将删除的元素作为方法的返回值返回，因此可以使用一个变量来保存删除的元素。

var  nums=[6,1,2,3,4,5];
var first=nums.shift();    //6
nums.push(first);
print(nums);               //1,2,3,4,5,6

3.从数组中间位置添加和删除元素
splice()为数组添加元素
三个元素：起始索引
需要删除的元素个数（添加元素时该参数为0）
想要添加进数组的元素

var  nums=[1,2,3,7,8,9];
var  newElements=[4,5,6];
nums.splice(3,0,newElements);
print(nums);                //[1,2,3,[4,5,6],7,8,9]

要插入数组的元素，不必组织成一个数组，它可以是任意的元素序列

var  nums=[1,2,3,7,8,9];
nums.splice(3,0,4,5,6);  //3是起始索引，0是删除的元素个数，4,5,6是想要添加的元素
print(nums);      //[1,2,3,4,5,6,7,8,9]

下面是使用splice()方法从数组中删除元素

var  nums=[1,2,3,100,200,4,5];
nums.splice(3,2);
print(nums);          //1,2,3,4,5

4.为数组排序
reverse()将数组中元素的顺序进行翻转

var  nums=[1,2,3,4,5];
nums.reverse();
print(nums);      //5,4,3,2,1

如果元素是字符串类型，那么sort()就好使。

var  names=["David","Mike","Bryan"];
names.sort();
print(names);          //Bryan,David,Mike

如果数组元素是数字类型，sort()方法就不可以
🍗注：sort()方法是按照字典顺序对元素进行排序的。为了让sort()方法能排序数字类型的元素，可以在调用时传入一个大小比较函数；排序时，sort()方法将会根据该函数比较数组中的两个元素的大小，从而决定整个数组的顺序。对于数字类型，该函数可以是一个简单的相减操作，从一个数字中减去另外一个数字。
如果为负，被减数小于减数；
如果为0，被减数与减数相等；
如果为正，被减数大于减数。

function compare(num1,num2){
      return num1-num2;
}
var  nums=[3,1,2,100,4,300];
nums.sort(compare);
print(nums);              //1,2,3,4,100,300

四.迭代器方法

这些方法对数组中的每个元素应用一个函数，可以返回一个值、一组值或者一个新数组。
1.不生成新数组的迭代器方法
📖forEach()，接受一个函数作为参数，对数组中的每个元素使用该函数。

function  squre(num){
    print(num,num*num);
}
var nums=[1,2,3,4,5,6,7,8,9,10];
nums.forEach(squre);
//1 1
//2 4
//3 9
...
//10 100

📖every()，接受一个返回值为布尔类型的函数，对数组中的每个元素使用该函数。如果对于所有的元素，该函数均返回，则该方法返回true。

function  isEven(num){
     return num%2==0;
}
var nums=[2,4,6,8,10];
var even=nums.every(isEven);
if(even){
    print("all numbers are even");
}
else{
    print("not all numbers are even");
}
//all numbers are even
将数组改为[2,4,6,7,8,10]
//not all numbers are even

📖some()接受一个返回值为布尔类型的函数，只要有一个元素使得该函数返回true，该方法就返回true。

function isEven(num){
    return num%2==0;
}
var nums=[1,2,3,4,5,6,7,8,9,10];
var someEven=nums.some(isEven);
if(someEven){
     print("some numbers are even");
}
else{
    print("no numbers are even");
}
nums=[1,3,5,7,9];
someEven=nums.some(isEven);
if(someEven){
    print("some numbers are even");
}
else{
    print("no numbers are even");
}
//some numbers are even
//no numbers are even 

📖reduce()接受一个参数，返回一个值。该方法会从一个累加值开始，不断对累加值和数组中的后续元素调用该函数，直到数组中的最后一个元素，最后返回的是累加值。

function add(running,current){
    return running+current;
}
var nums=[1,2,3,4,5,6,7,8,9,10];
var sum=nums.reduce(add);
print(sum);                   //55

reduce()和add()方法一起，从左到右，依次对数组中的元素求和

//3 6 10 15 21 28 36 45 55

reduce ()也可以用来将数组中的元素连接成一个长的字符串。

function concat(accuml,item){
    return accuml+item;
}
var words=["the","quick","brown","fox'];
var sencence=words.reduce(concat);
print(sentence);                            //the quidk brown fox

注：reduceRight()和reduce()方法不同，他是从右往左执行。
2.生成新数组的迭代器方法
有两个迭代器可以产生新数组：
map()和filter()
map返回一个新的数组，该数组的元素是对原有函数应用某个函数得到的结果。

function curve(grade){
  return grade +=5;
}
var grades=[77,65,81,92,83];
var newgrades=grades.map(curve);
print(newgrades);      //82,70,86,97,88

filter()和every()类似，传入一个返回值为布尔类型的函数。和every()方法不同的是，当对数组中的所有元素应用该函数，结果均为true时，该方法并不返回true，而是返回一个新数组，该数组包含应用该函数后结果为true的函数。