JavaScript之数组API、栈和队列、冒泡排序

API：已经实现的方法，我们开发人员可以直接调用，不需要知道源代码。

将数组转化为字符串

//1.
var str = arr.toString();

• 返回数组中的元素用逗号分隔。

var arr = ["s","t","r"];
var str = arr.toString();
console.log(str);//s,t,r

//2.
var str = arr.join("/*连接符*/");

有关join()的使用：
1.无缝拼接数组每个元素：var str = arr.join(“”);

• 如果括号内不加”“，等效于arr.toString()方法，用逗号分隔。

2.讲单词拼接为句子：var str = arr.join(“”);
3.将数组拼接为html元素。

var arr = ["Hello","World"];
var str = arr.join("");
console.log(str);//HelloWorld

优化：

• 数组拼接比字符串拼接效率更高；
• 凡是频繁的字符串拼接，都要两步：
  (1).先将要拼接的子字符放入一个数组中；
  (2).调用数组的join方法，一次性生成结果字符串。

拼接数组

var newArr = arr1.concat(arr2,值1,值2,...);

• concat不修改原数组，总是返回一个新数组。

var arr1 = [1,2,3];
var arr2 = [4,5,6];
var newArr = arr1.concat(arr2,7,8);
console.log(newArr);//[1,2,3,4,5,6,7,8]

获取子数组

var subArr = arr.slice(starti,endi+1);

• starti：开始获取的下标的位置；
• endi：表示获取到的下标的位置；
• 含头不含尾，所以slice方法的最后一个参数是endi+1；
• slice方法支持负参数，其实负数的下标是不存在的，假定的负数下标从-1开始。

var arr = [1,2,3,4,5];
var subArr = arr.slice(1,4);
console.log(subArr);//[2,3,4]

删除、插入、替换

1.删除

arr.splice(starti,n);

• splice方法直接修改原数组；
• 从starti位置开始，删除n个元素。

var arr = [1,2,3,4,5];
arr.splice(1,2)
console.log(arr);//[1,4,5]

2.插入

arr.splice(starti,0,新值1,新值2,...);

• 在starti位置开始插入新值1，新值2，…；
• 原starti位置及其之后的元素，被向后顺移。

var arr = [1,2,3,4,5];
arr.splice(2,0,7,8,9);
console.log(arr);//[1,2,7,8,9,3,4,5]

3.替换

arr.splice(starti,n,新值1,新值2,...);

• 新元素的个数和n不一定相等；
• 数组会自动调整元素的位置和长度。

var arr = [1,2,3,4,5];
arr.splice(1,2,7,8);
console.log(arr);//[1,7,8,4,5]

var arr = [1,2,3,4,5];
arr.splice(1,2,7,8,9);
console.log(arr);//[1,7,8,9,4,5]

颠倒数组中所有元素的位置

arr.reverse();

var arr = [1,2,3,4,5];
arr.reverse();
console.log(arr);//[5,4,3,2,1]

数组排序(sort方法及冒泡排序)

1.数组的sort方法

arr.sort();

• 默认按升序排列；
• 默认一切都转为字符串，再按字符串比大小。

var arr = [2,35,1,4,12];
arr.sort();
console.log(arr);//[1,12,2,35,4]
//我们想要的结果是：[1,2,4,12,35]

• 从上面的例子可以看出sort方法对数组排序是有一些问题的，由于一切都转为字符串，所以导致排序并不是想我们预想的那样。
• 所以我们要自定义排序规则：
  (1).定义比较器函数：专门比较任意两值大小的函数。
  规定两个参数(a,b),必须返回数字，如果a>b,就返回正数；如果a<b,就返回负数；如果a=b,就返回0.
  (2).将比较器函数对象作为参数传入sort方法中。
  arr.sort(比较器函数);——函数名不加圆括号。

function compare(a,b){
    return parseFloat(a)-parseFloat(b);
}     
var arr=[2,35,1,4,12];
console.log(arr.sort(compare));//[1,2,4,12,35]

2.冒泡排序

有关冒泡排序我就不多说了，一看这个名字，相信大家都明白。

for(var r=1;r<=arr.length-1;r++){
    for(var i=0;i<arr.length-r;i++){
        if(arr[i>arr[i+1]){
            arr[i]+=arr[i+1];
            arr[i+1]=arr[i]-arr[i+1];
            arr[i]-=arr[i+1];
        }
    }
}

---

栈和队列：其实都是数组，只不过使用了不同的方法；
栈：一端封闭，只能从另一端进出的数组。

LIFO——后进先出

1.结尾出入栈

入栈：arr.push(新值);
arr.push(新值) 相当于数组中的：arr[arr.length] = 新值;
出栈：var last = arr.pop();

• 无论出入栈影响已有元素的位置。——效率高

2.开头出入栈

入栈：arr.unshift(新值);
出栈：var first = arr.shift();

• 每次出入栈都会影响所有剩余元素位置顺序。——效率低

---

队列：只能从一端进入，必须从另一端出。

FIFO——先进先出

结尾入队列：arr.push(新值);
开头出队列：var first = arr.shift();