day6 数组
一、数组
数组就是一组数据 （可以存放多个数据类型，但是一般建议存放一种数据类型）
数组可以容纳多个数据 如果数组里面没有数据就是空数组
1.数组的定义以及使用
1.数组定义 也是一个对象只是对应的数据结构不同
var arr1=new Array()//声明空数组 第一种方式
console.log(arr1.length);
var arr2=new Array(3)//指定数组的长度，具备三个元素
console.log(arr2.length);
var arr3=new Array(1,2,3)//指定数据的数据 包含三个数据
console.log(arr3.length);
对于数组 除了具备length属性同时还具备通过对应的下标来指定对应的元素（进行赋值以及获取）
数组下标从0开始到 length-1结束
console.log(arr3[0]);//获取arr3的第一个元素
arr3[1]=10//给第二个元素进行赋值
2.数组定义 使用[] 来直接赋值定义
var arr4=[]//定义一个空数组
arr4.length=4
console.log(arr4);//是empty 空实体 打印对应的值还是undefined
var arr5=['a','b','c']//定义一个有数据的数组
arr5[2]='d'//赋值
length属性是可以进行设置 也可以用来获取对应的数组长度
数组存在下标 下标从0开始到length-1结束 可以通过对应的下标来设置和获取对应的元素数据
// 练习
// 班机有红 明，绿，蓝 四位同学， 使用一个变量储存 打印第二位的名字 将小绿的名字变成小黑
var arr6=['小红','小明','小绿','小蓝']
console.log(arr6[1]);
arr6[2]='小黑';
console.log(arr6);
// 变量是一个容器 数组也是一个容器 可以装数据的统称为容器
// 存在增删改查的方法
二、数组的方法
数组增删改查的方法
1.增加的方法
unshift和push都会改变原来的数组 且返回的数据都是新的数组长度
//.push() 添加到后面
var arra=['a']
console.log(arra);
console.log(arra.push('b'));
// arra.push('b') 里面的类型为当前数组里面储存的数据类型 返回值为数组的新长度
// .unshift() 添加到前面 插入一个新的数据到开始位置
console.log(arra.unshift('c'))//返回数组的新长度
2.数组删除的方法
var arrb=new Array(10,20,30)
//.pop() 删除最后一个元素 返回被删除的元素
console.log(arrb.pop());//30
// shift() 删除第一个元素 返回被删除的元素
console.log(arrb.shift());//10
3.数组的排序方法
.sort() 排序 默认为从小到大 默认的排序方式是根据ASCII 码 如果是数值会自动转换为string 只取第一位
指定比较的方法进行比较
arr.sort(function(a,b){
return a-b //返回的是1 就是正序
return b-a//返回的是-1 就是倒序
})
sort 方法默认按照ASCII码进行比较 对应顺序为从小到大 返回为排序好的数组
里面可以指定参数 参数是一个function 里面有两个参数 a b 如果返回a-b 为1 就是正序 相反如果是b-a 就是-1 那就是倒序
.reverse() 反转 将数组元素倒过来 倒序
reverse会影响之前的数组 没有参数 返回值为倒转过来的数组
注意事项 reverse和sort两个其实是指向一个变量地址 所以操作reverse的数组也会影响sort的数组
sort的两个排序亦然
strArr 和 arr两个其实指向一个变量 所以操作strArr会影响arr 操作arr也会影响strArr
4.数组的连接方法和截取方法
// 连接方法
// concat 进行数组合并操作 对应的返回值为一个新的数组 不改变原本数组
// 传入的参数是一个数组 也可以是单个元素 连接到后面
// 截取方法
// slice 截取对应数组的某一段内容组成一个新的数组 返回的是一个新的数组
// 不会改变原本数组 参数为开始下标和结束下标（不包含结束下标）
5.数组的join方法
// join连接 连接成字符串 返回值为string
var arr=[1,2,3]
var str=arr.join()//可以不写 相当于全部连一块 默认以逗号分隔 arr.join()==arr.join(',')
console.log(str);
// 练习
var arr=[2,3,4,5]
var arr1=[9,8,0,6]
var conArr=arr.concat(arr1)
console.log(conArr);
console.log(arr);
var sliArr=arr.slice(arr.length-1,arr.length)//截取最后一个
var sliArr1=arr.slice(0)//全部截取
console.log(sliArr1);//全部截取
console.log(sliArr);
console.log(arr);
var joiArr=arr.join('-')
console.log(joiArr);
console.log(arr);
6.数组的splice方法
var arr=[1,2,3,4,5]
// 1.删除 两个参数 第一个参数是开始下标 第二个是删除的个数（可以被省略 删到最后）
// 会改变之前1的数组 返回的是一个新的数组
var splArr=arr.splice(0,2)//删除两个 1，2
console.log(splArr);//1,2
console.log(arr);//3,4,5
// 2将删除位置的数据替换
var arr2=[3,4,5,6]
var splArr1=arr2.splice(1,2,10,11)//删除 7 8 将10，11放到7，8的位置
console.log(splArr1);//7,8
console.log(arr2);//1,10,11,9
// 3.不删除 插入元素到指定位置
var arr3=[1,2,3]
var insArr=arr3.splice(1,0,'a')//不删除元素 插入a到数组中
console.log(insArr);//空数组
console.log(arr3);//插入到指定的位置 1 a 2 3
// 如果是一个参数，那么就是从这个指定的参数下标删到最后
// 如果是两个参数，那么就是从指定的参数下标位，删对应的指定个数
// 如果是3个参数或者以上的1参数，那么就是从指定的参数下标位删对应的指定个数，再将后面的数据填入对应的删除位
// 如果第二个参数为0 那么返回的是一个空数组 不删除 单纯的将对应的数据插入到指定的下标
// push pop unshift shift sort reverse splice 会改变原数组
// concat join slice 不会改变原数组
// splice练习
var arr=[1,2,3,4,5]
var splArr1=arr.splice(1)//从下标为1一直删到最后
console.log(splArr1);//2 3 4 5
console.log(arr);//1
var arr=[1,2,3,4,5]
var splArr2=arr.splice(1,3)//从下标为1开始删除三个
console.log(splArr2);//2 3 4
console.log(arr);//1 5
var arr=[1,2,3,4,5]
var splArr3=arr.splice(1,2,'a','b')//从下标为1开始删除两个并把a，b放入删除的两个的位置
console.log(splArr3);//2 3
console.log(arr); //1 a b 4 5
var arr=[1,2,3,4,5]
var splArr4=arr.splice(1,0,'哈哈','呵呵')//从下标为1的开始 不删除，直接插入到当前下标1
console.log(splArr4);//空数组
console.log(arr);//1 哈哈 呵呵 2 3 4 5
7.数组的indexof和lastindexof方法
//indexof 根据对应值找下标 找到了返回对应第一次出现的下标 找不到返回-1
var arr=['a','b','c','b']
console.log(arr.indexOf('b'));//indexof 找的是第一次出现的位置 默认从下标0开始找 没找到返回-1
console.log(arr.indexOf('b',0))//1
console.log(arr.indexOf('b',2))//从下标1开始 下标还是原本的下标
var arr1=[1,1,2,3,4,1]
console.log(arr1.indexOf(1))//0
console.log(arr1.indexOf(1,2))//5
console.log(arr1.indexOf(1,10))//-1
//lastIndexof 根据对应值找下标 找到了返回对应第一次出现的下标 找不到返回-1
console.log(arr1.lastIndexOf(1))//5
console.log(arr1.lastIndexOf(1,2))//1
三、四种排序方法
// 排序算法是属于数据结构的知识点 一般常见排序有10种
// 1.冒泡排序 逐个冒泡到上面去
var arr=[1,3,8,5,7,6,2]
function bubbleSort(array){
//记录冒泡的次数
for(var i=1;i<array.length;i++){
//记录比较次数
for(var 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
}
}
}
}
bubbleSort(arr)
console.log(arr);
// 逐层冒泡 第一次冒泡执行的比较次数当前的长度-1
// 冒泡的总次数为长度-1
// j和j+1 比较 比较完进行位置交换
// 冒泡的比较次数一次比一次少 最后到达一次结束
// 2.选择排序
// 每次选择当前的第一个数为最小值
// 这个值跟后面的所有值去比较 然后对应的比我这个值还小的 将这个下标赋值给min
// 判断min是否是我前面给的值 如果是就不做操作，如果不是交换位置
function selectSort(array){
for(var i=0;i<array.length-1;i++){
//设置第一个数为最小值
var min=i
for(var j=i+1;j<array.length;j++){
if(array[min]>array[j]){
min=j
}
}
if(min!=i){
var temp=array[i]
arr[i]=arr[min]
arr[min]=temp
}
}
}
// 2.插入排序
// 从后我往前比 下标从1开始
// 比较次数是递增的
// 外层循环从1开始 到arr.length-1结束
// 里层循环是减减操作 里层进行比较 每次比较完交换位置
// 有bug 如果前面插入一个大的数据就无法排序
var arr=[1,3,8,5,7,6,2]
function insertSort(array){
for(var i=1;i<array.length;i++){
for(var j=i;j>0;j--){
if(array[j-1]>array[j]){
var temp=array[j-1]
arr[j-1]=array[j]
arr[j]=temp
}
}
}
}
insertSort(arr)
console.log(arr);
var arr=[1,3,8,5,7,6,2]
function insetion(array){
for(var i=1;i<array.length;i++){
var preIndex=i-1//获取前一个下标
var current=array[i]//获取当前值
while(preIndex>=0 && current<array[preIndex]){
//如果前一个下标大于等于0
}
}
}
// 快速排序(冒泡升级版)
function quickSort(arr) {
if (arr.length <= 1) { //长度为1或者小于1退出
return arr
}
var centerIndex = Math.round(arr.length / 2) //取中间值下标
var center = arr.splice(center, 1)[0] //接收删除的中间值
var left = [] //左边的数组
var right = [] //右边的数组
for (var i = 0; i < arr.length; i++){ //循环遍历
if (arr[i] < center) { //小于中间值 加到左边
left.push(arr[i])
}else {
right.push(arr[i])//大于中间值 加到左边
}
}
return quickSort(left).concat([center], quickSort(right));//返回合并的数组
}
console.log(quickSort(arr));
浙公网安备 33010602011771号