JS之数组

一.数组的概念及定义
数组的概念 ：数据是一个容器，可以同时存放多个数据，一组任意类型或者相同类型的数据集合。

数组的定义：ECMAScript 中的 数组类型和其他语言中的数组有着很大的区别。 虽然数组都是有序排列， 但 ECMAScript中的数组每个元素可以保存任何类型。

二.关于数据结构
数据结构顾名思义 就数据的结构 （逻辑结构 存储结构 算法），是数据之间存在一种或多种特定关系的数据元素集合

存储结构 （数据存储的结构方式）
线性结构

数组（顺序表）
队列
栈
堆
链表
非线性结构

树
图
hash（散列表）
只要是能存数据的容器 就必须具备增删改查的方法

三.数组的声明及操作方法（引用数据类型）
声明：
第一种是 new 运算符（构造函数）;

var arr = new Array(5) //里面参数指定对应的长度 如果你没有写 表示长度为0
var arr1 = new Array(1,2,3,4) //当前数组里面的数据有 1 2 3 4

第二种是字面量表示法（使用[]声明数组）;

//里面的数据以,进行分隔
var arr = [1,2,3]
操作方法：
1.通过length属性来访问对应的长度（数组长度可改变）

var arr = new Array()
//通过length来访问数组的长度
console.log(arr.length);//默认为0
arr.length = 10 //设置对应的长度
console.log(arr);

2.通过下标可以访问数组的任意元素（数组下标从0开始）

console.log(arr[0])//获取第一个
//可以允许字符串
console.log(arr['0']); //获取第一个

3.数组的赋值

arr[0] = 10//通过下标直接赋值
console.log(arr[0]) //10
// 给数组里面的元素随机给值
var arr = new Array()
for(var i=0;i<10;i++){
arr[i] = Math.random() //[0,1)的随机数
}
console.log(arr);

4.数组遍历

(1)for循环遍历

var arr = [1,2,3,4,5]
//利用顺序表的特点 有序
for(var i=0;i<arr.length;i++){
console.log(arr[i])//依次打印出1,2,3,4,5
}

(2)for in遍历 (用来遍历对象 )

var arr = [1,2,3,4,5]
for(var index in arr){ //index表示的为下标
console.log(arr[index])
}

(3)for of进行遍历（用来遍历数组 ，通过迭代器来实现的）

//使用for of遍历(只能遍历数组)
for(var value of arr){ //value表示的是数组存放的值
console.log(value)
}

四.数组的方法
数组是一个顺序表存储结构（具有增删改查的操作）

1.添加 (add push append…)

栈方法 （先进后出 后进先出）push 入栈 pop出栈操作
push方法（添加到数组最后面）

var arr = [1]
arr.push(2)
console.log(arr) //[1,2]
pop方法(删除数组最后面的一个)

var arr = [1,2,3]
arr.pop() //下标不写
console.log(arr) //[1,2]

2.删除 (delete(硬删) remove(软删)…)

队列方法（先进先出 后进后出）
unshift方法（添加到数组最前面）

unshift方法（添加到第一个）
var arr = [1]
arr.unshift(2)
console.log(arr) //[2,1]
shift方法（删除数组第一个）

var arr = [1,2,3]
arr.shift()
console.log(arr) //[2,3]

反转 reverse（让数组的元素反过来）

//改变原本的数组
var arr = [1,2,3,4,5]
var arr1 = arr.reverse(); //返回一个数组 这个数组就是反转后的数组
console.log(arr1)//反转后的结果[5,4,3,2,1]
arr1.unshift(6) //返回的反转后的数组其实就我们原本的数组
console.log(arr) //反转并添加后的结果 [6,5,4,3,2,1]
console.log(Object.is(arr1,arr));//true

不影响原本数组的方法

concat （连接）

//不会影响原本数组的方法 返回新的数组
var arr = [1,2,3,4]
var arr1 = [1,2,3,4]
var arr2 = [1,2,3,4]
var arr3 = [1,2,3,4]
// concat 连接 把多个数组变成一个数组 返回 ...扩展运算符 打开数组取出里面的值(...证明可以写任意个) ? 表示可写可不写
var newArr = arr.concat(arr1,arr2,arr3)
console.log(newArr);//[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]

slice （截取）

 // slice 切片 把一个数组里面东西提出 返回的新的数组
        var arr = [1,2,3,4,5,6,7,8]
        var sliceArr = arr.slice()//全切
        console.log(sliceArr);//[1, 2, 3, 4, 5, 6, 7, 8]
        var sliceArr1 = arr.slice(0)//从0开始切到最后 如果下标不存在返回一个空数组
        console.log(sliceArr1);//[1, 2, 3, 4, 5, 6, 7, 8]
        var sliceArr2 = arr.slice(2, 3)//包含下标2不包含下标3
        console.log(sliceArr2);//3

影响原本数组的方法

splice 方法 （删除）

//splice会影响之前的数组 删除 截取 插入
var arr = [12,13,45]
//参数 开始位置 删除的个数(可以写可以不写 数组的length) 返回一个新的数组
// var newArr = arr.splice(0) //从0开始删，删完
// console.log(newArr);
console.log(arr);
var newArr = arr.splice(1,2) //从1开始删，不包括2
console.log(newArr);//12,15
//获取删除的内容 其实就截取里面的内容(不足是会改变之前的数组)

五.数组的排序
1.sort（）方法

//sort方法排序 //默认情况下他是根据第一个字符的ACSII码进行排序 (ACSII码排序)
var arr2 = [5,9,4,6,2,7]
arr2.sort() //返回一个数组 这个数组是排序好的数组 他跟上面一样 就是返回的这个数组其实就是原本的数组
console.log(arr2);//[2,4,5,6,7,9]
// sort 是一个高阶函数 高阶函数就是里面用函数做为参数的函数
var arr3 = [15,20,11,4,5]
arr3.sort(function(a,b){
//1 和 -1来进行大小区分和排序规则
return b-a //a-b是正序 b-a就倒序
})
console.log(arr3);//[20,15,11,5,4]

2.冒泡排序 (最基础的排序) O(n^2)

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对,在这一点，最后的元素应该会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

//冒泡排序核心点 俩个for循环嵌套 第一个躺数 相当于length-1 第二个每躺比较是递减
//相邻的俩个相比 j和j+1相比
function bubble(arr){
//遍历数组
for(var i=1;i<arr.length;i++){
//判断对应的没有比较的值
for(var j=0;j<arr.length-i;j++){
//相邻的俩个进行比较
if(arr[j]>arr[j+1]){
//换位置
var temp = arr[j]
arr[j] = arr[j+1]
arr[j+1] = temp
}
}
}
return arr
}

3.选择排序 （选择最大值的下标（或者最小值的下标）进行比较的排序）O(n^2)

依次假设每一个值为最小值，然后用后续的值和最小值进行比较，如果假设的最小值比当前的值大，那么当

前值就是真正的最小值，这样既可求得真正的最小值的索引(数组依靠索引进行赋值)。

用真正的最小值的索引和当前假设的最小值的索引进行交换赋值。

依次执行上面的操作。

function selecter(arr){
//遍历数组
for(var i=0;i<arr.length;i++){
var min = i //记录最小下标 默认当前的i
for(var j=i+1;j<arr.length;j++){ //遍历后面的内容
//如果当前值比最小值还小
if(arr[j]<arr[min]){
//记录一下这个下标
min = j
}
}
//判断当前最小下标是否为开始的默认下标 不是就换位置
if(min!=i){
//换位置
var temp = arr[min]
arr[min] = arr[i]
arr[i] = temp
}
}
return arr
}
 

4.快速排序 （在数据量不多最快的 冒泡排序的进阶）二分 O(nLogn)

function quick(arr){
if(arr.length<=1){
return arr
}
//定义左边数组 右边数组 基数
var left = [],right = [] ,mid=arr[0]
//遍历数组
for(var i=1;i<arr.length;i++){
arr[i]>mid?right.push(arr[i]):left.push(arr[i])
}
return quick(left).concat([mid],quick(right))
}

5.插入排序

function insertSort(arr){
        for(var i = 1; i < arr.length; i++){
            var preIndex = i - 1;//获取前一个下标
            var current = arr[i] //保存当前值，防丢失
            while(preIndex>=0 && current < arr[preIndex]){
                //如果前一个下标大于等于0 和当前值小于上一个
                arr[preIndex+1] = arr[preIndex] // 将本身这个位置的值赋给上一个
                preIndex-- 
            }
            arr[preIndex+1] = current //当前位置的值等于原本位置的值
        }
    }