数组
数组主要属性
概念：
数组一般是由相同类型的元素组成的集合，也是对象；
一，定义：
方式 1，new 数组名 (参数，参数，…)
只有一个数字参数时是数组的长度（new 可以省略，但一般尽量写上）
var 数组名 = new Array(); //定义一个空数组
var 数组名 = new Array(10)； //创建一个包含 10 个元素的数组，没有赋值
var 数组名 = new Array("孙悟空",100)； //创建一个数组有两个元素
方式 2，var 数组名 = [1, 2, 3, 4, 5] 字面量定义方式
var onelist = ["one", 1, null]; //定义一个数组 onelist
二，数组元素的获取
arr[ 0 ] : 表示数组的第 1 个元素 ， 他是下标，从 0 开始也叫索引；
注意：下标可以是变量或表达式
arr.length length 属性，不仅是可读的，也可以设置；
var arr = []; //定义一个空数组
arr.length = 4; //可以将其长度改为4
console.log(arr); //输出 四个 空默认为实体类型 empty 打印的值仍是undefined
三，for……in 可遍历数组(一般用来遍历对象)
for (var i in 数组名) {
console.log(数组名[i]);
}
//例
var onelist = ["one", 1, null];
for (var i in onelist) {
console.log(onelist[i]);
}
输出如下图：
数组的常用方法（书写时别忘记后的小括号）
容器都能够进行 增删改查；变量是一个容器，数组也是一个容器；
一，栈方法 : push( ) 和 pop( )
栈：遵循 先进后出 的原则；
push() 增加值的方法 追加到后面，返回数组长度； push 英语意思为：推，推入，放入；
pop() 删除值的方法 删除最后一个元素，返回这个被删除的元素； pop 英语意思为：弹出；
二，队列方法 : shift( ) 和 unshift( )
队列：遵循 先进先出 的原则；
unshift() 增加的方法 放到最前面，返回数组长度； unshift 英语意思为：未移动，从数组头部；
shift() 删除的方法 删除第一元素，返回这个被删除的元素； shift 英语意思为：移位，从数组头部；
三，排序方法: reverse( ) 和 sort( )
sort() 排序：默认根据 ASCII 码 从小到大排序，两位或以上的数字会自动转换为 string 类型，只取第一位数。如 12 取 1 的 ASCII 码比较；
但我们可以通过比较函数进行排序：
arr.sort(function (a, b) {
return a - b; //返回为 正 为正序
});
arr.sort(function (a, b) {
return b - a; //返回为 负 为倒序
});
reverse() 反转：将之前的数组元素全倒过来，改变原有数组；没有参数；返回值为改变后的数组。
var arr = [1, 2, 3];
var arrResver = arr.reverser(); //它的返回值和原数组指向的同一个地址
arr == arrResver; //true
arr === arrResver; //true
四，数组操作的方法
concat() 连接，合并：两个或多个数组，可以连接值；追加数据,把连接的数组或值放在后面， 创建一个新数组, 不改变原数组
var arr1 = [1, 2, 3];
var arr2 = [4, 5, 6];
var newarr = arr1.concat(arr2);
console.log(newarr); //输出 [1,2,3,4,5,6]
join() 连接：连接成为字符串 有分割符，不会影响原来的数组，返回值为 string
var arr1 = [1, 2, 3];
var newarr = arr1.join(); //无分割符，默认 ，号分割
var newarr1 = arr1.join("/"); //以 / 为分割符
console.log(newarr); //输出 1,2,3
console.log(newarr1); //输出 1/2/3
slice() 截取: 不修改原数组，将原数组中的指定区域数据提取出来，返回的是一个新的数组；
var arr1 = [1, 2, 3];
var newarr = arr1.slice(0, 1);
// 0 代表开始截取位置 1 代表结束截取位置 不包含结束位置的值
console.log(newarr); //输出 [1]
splice() 增删改: 截取原数组中指定的数据, 会改变原数组
1,删除 (开始下标 删除的个数)（个数可以被省略，就是删到最后）
var arr = [1, 2, 3];
var newarr = arr.splice(0, 1); //返回 被删除元素组成的数组
console.log(newarr); //输出 [1]
console.log(arr); //输出 [2,3]
var arr1 = [1, 2, 3];
var newarr1 = arr.splice(0);
console.log(newarr1); //输出 [1,2,3]
console.log(arr1); //输出 []
2，插入 （开始下标，删除的个数，”新元素”）插入元素到指定位置，将删除个数改为 0 ，不删除元素，直接插入新元素；
var arr = [1, 2, 3];
var newarr = arr.splice(0, 0, 4); //返回 被删除元素组成的数组
console.log(newarr); //输出 []
console.log(arr); //输出 [4,1,2,3]
var arr1 = [1, 2, 3];
var newarr1 = arr1.splice(1, 0, 4);
console.log(newarr1); //输出 [] 空数组
console.log(arr1); //输出 [1,4,2,3]
3,替换 将删除位置的数据替换，删除数据位置要输入新的值
var arr = [1, 2, 3];
var newarr = arr.splice(0, 1, 4); //返回 被删除元素组成的数组
console.log(newarr); //输出 [1]
console.log(arr); //输出 [4,2,3] 已删除并替换掉
注意: splice 和 slice 的区别
indexOf() 查找： 根据对应的值找下标，找的是值第一次出现的位置，返回它的下标；默认从下标 0 开始找，没有找到则返回 - 1；
var arr = [1, 1, 2, 3, 4, 1];
arr.indexOf(1); //返回 0
arr.indexOf(1, 2); //返回 5
arr.indexOf(1, 10); //返回 -1
lastIndexOf() 查找： 从后往前找； 根据对应的值找下标，找的是值第一次出现的位置，返回它的下标；默认从最后一个开始找，没有找到则返回 - 1；
数组排序
排序算法是属于数据结构的知识点 一般常见的排序有 10 种
1，冒泡排序法：逐个冒泡到上面，从下往上。
逐层冒泡 第一次冒泡执行的次数为当前数组的长度减一；
冒泡的总次数为长度减一
j 和 j+1 比较 比较完后判断是否交换位置
冒泡的比较次数一次比一次少 最后到达一次结束
//冒泡排序法
function maopao(array) {
//冒泡执行的次数
for (i = 1; i < array.length - 1; i++) {
//冒泡每次执行比较的次数
for (j = 0; j < array.length - i; j++) {
//把第一位和后一位进行比较 逐层冒泡
if (array[j] > array[j + 1]) {
var temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
}
var arr = [2, 1, 4, 8, 7, 5, 4];
maopao(arr);
console.log(arr);
2，选择排序法
每次选择当前的第一个数为最小值；
这个值跟后面的所有值去比较 然后对应的比我这个值还小的 就把下标记起来 赋值给 min；
判断 min 是否是之前给到的值， 如果是 不做操作，如果不是 交换位置；
//选择排序
function selcetarr(array) {
//初始最小值得下标 和总选择次数
for (i = 0; i < array.length - 1; i++) {
var min = i; //每次比较值得下标 从左至右
for (j = i + 1; j < array.length; j++) {
//从第二个开始 然后在和声明好的min下标值比较
if (array[min] > array[j]) {
min = j;
}
}
if (min != i) {
//如果当前的最小值的下标不是之前的下标 就替换掉 因为需要下一个值得比较
var temp = array[i];
array[i] = array[min];
array[min] = temp;
}
}
}
3，插入排序法
从后往前比，初始下标为 1 ，
//插入排序（）第一种 会无法识别中途从第一位插入的数值
function insent(array){
//外层的循环次数 是从第二个数也就是下标为 1 的数开始，因为是从后往前比
for(i=1; i<array.length; i++){
//内部比较 记住是 从后往前比 就是所以是 j--
for(j=i; j>0; j--){
//比较大小 然后交换数值
if(array[j-1]>array[j]){
var temp = array[j-1]
array[j-1] = array[j]
array[j] = temp
}
}
}
}
//插入排序（第二种）一般选择它
function whileinsertion(array){
for(i=1; i<array.length; i++){
var arrindex = i-1 //获取前一个的下标
var cuont = array[i] //保存当前的值 防止丢失
while(arrindex>=0; && cuont < array[arrindex]){
//如果前一个的值大于等于 0 并且值小于上一个
array[arrindex+1] = array[arrindex] //交换
arrindex--
}
array[arrindex+1] = cuont
}
}
4，快速排序（冒泡升级）
核心 利用二分法和递归；
function quicksort(arr) {
//递归的边界；最终排到中间值就是自己，则结束；
if (arr.length <= 1) {
return arr;
}
//取出相对中间下标，和它的值；定义好两个数组；
let index = Math.round(arr.length / 2);
let centerNumber = arr.splice(index, 1);
let leftarr = [];
let rightarr = [];
for (let i = 0; i < arr.length; i++) {
//判断，比中间值小的，往左边放，大的往右边放；
if (arr[i] < centerNumber) {
leftarr.push(arr[i]);
} else {
rightarr.push(arr[i]);
}
}
//递归
return quicksort(leftarr).concat(centerNumber, quicksort(rightarr));
}