day05数组

数组

数组概述:数组固定一类数据的组合(一 般情况下我们数组里面的数据类型一致) (多 个数据)

1.使用声明数组

var arr=[1,5,8]

2.使用new关键词创建数组

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

length属性来访问对应的长度

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

对数组进行赋值

 var arr=new Array()
    for(u=0;u<10;u++){
        arr[u]=Math.random()
    }
    console.log(arr);

数组遍历

for循环遍历

    var nu=[1,5,8,4,7]
    for(i=0;i<nu.length;i++){
        console.log(nu[i]);
    }

 for in 遍历(遍历对象)

    var num1=[4,8,55,74,22]
    for(var index in num1){
        console.log(num1[index]);
    }

 for of 遍历（遍历数组）

    for(var value of num1){
        console.log(value);
    }

数组的方法

数组是一个存储结构（增删改查的操作）

添加 (add push append..)

栈方法 （先进后出 后进先出）push 入栈 pop出栈操作
push方法（添加到最后一个，3，2，1进入，1，2，3出来）

var arr = [1]
arr.push(10)
console.log(arr) //[1,10]

队列方法（先进先出 后进后出）
unshift方法（添加到第一个）

var arr = [1]
arr.unshift(10)
console.log(arr) //[10,1]

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

栈方法
pop方法(删除最后面)

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

队列方法
shift方法（删除第一个）

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

修改 （replace替换 update 更新）

反转 reverse（将最后一个变到第一个 一个个对应的换位置）

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

排序 sort

 var stv = [15, 2, 536, 55]
    stv.push(20)
    console.log(stv);
    stv.pop()
    // stv.reverse()
    stv.sort(function (a, b) {
      return a - b     //a-b是正序 b-a就倒序
    })
    console.log(stv);

不影响原本数组的方法
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);

slice （截取）

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

splice 方法 （删除）

会影响之前的数组

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

排序算法

1.冒泡排序 (最基础的排序) 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
}

2.选择排序 （选择最大值的下标（或者最小值的下标）进行比较的排序）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
}

3.快速排序 （在数据量不多最快的 冒泡排序的进阶）二分 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))
}