【数据结构一】数组

一、数组

有顺序的存储任意数据类型的数据

1、扩容效率低【要开辟新的数组】 c语言中
2、在数组的前面删除或插入数组元素性能是非常低的【后面的数组元素会依次往前或者往后移动】，如果数组元素有50万个就要移动50万次。
3、数组的查找效率是非常非常高的，indexOf()... , O(1)常数型

数组是一种常见的线性结构，并且可以在任意位置插入和删除数据
但是有时候，我们想实现某一个功能，必须对这种任意性加以限制
js中数组是如何实现的？
hash-maps 链表 正在向c语言实现数组的方式靠近

    //创建数据
    let arr=[1,2,3,4,5,6,7,8];//字面量法
    let arr1=new Array(1,2,3,4,5,6);//new操作符 调用构造函数
    console.log(arr)
    console.log(arr1)

    //索引值 --下标【有序的】
    let a=[1,2,3,4,5,6,7,8,9];
    for(var i=0;i<a.length;i++){
        console.log(a[i])
    }

    //数组方法 增加 删除
    //push pop unshift shift splice
    let arr2 =[10,20,30,40,50,60,70,80]
    // let a1=arr2.push(90);//在数组尾部添加数据元素，返回添加后数组的长度 【原数组改变】
    // let a1=arr2.pop();//在数组尾部删除一个数组元素，返回删除的数组元素  【原数组改变】
    // let a1=arr2.unshift(1);//在数组开始处添加数据元素，返回添加后数组的长度 【原数组改变】
    // let a1=arr2.shift();//在数组开始处添加数据元素，返回添加后数组的长度 【原数组改变】
    // let a1=arr2.splice(6,1,72);//在指定下标添加或删除数组元素，返回删除的数组元素 【原数组改变】
    let a1=arr2.splice(-2,1,72);//这样也可以实现上面同样操作 【下标为负数表示，从后面开始第几个】
    console.log(arr2)
    console.log(a1)

    //数组排序
    //sort 【原数组改变】
    // let arr3=[20,18,50,21,12,80,16];
    // arr3.sort((a,b)=>{
    //     return a-b;//按照大小排序
    // })

    // let arr3=['e','n','y','f','l']
    // arr3.sort((a,b)=>{
    //     return a.charCodeAt(0)-b.charCodeAt(0);//按照unicode编码排序
    // })

    // let arr3=['e','n','y','f','l','b','a']
    // arr3.sort((a,b)=>{
    //     return a.localeCompare(b);//对非ASCII编码排序 ['a', 'b', 'e', 'f', 'l', 'n', 'y']
    // })

    let arr3=[
        {
            name:'tom',
            age:19
        },
        {
            name:'peter',
            age:16
        },
        {
            name:'worker',
            age:23
        },
        {
            name:'liker',
            age:18
        }
    ]
    // arr3.sort((a,b)=>{
    //     return a.age-b.age;//按照数组中对象某个属性排序
    // })
    // arr3.sort((a,b)=>{
    //     return a.name.length-b.name.length;//按照数组中对象属性字符串长度排序
    // })
    console.log(arr3)

    //concat join reverse slice
    let p1=[1,2,3,4];
    let p2=[5,6,7,8];
    console.log(p1.concat(p2));//合并数组 【原数组不改变】
    console.log(p1.join(''));//分隔数组，将数组转字符串 【原数组不改变】
    console.log(p1.reverse());//旋转数组 【原数组改变】
    console.log(p2.slice(2));//截取数组 【原数组不改变】

    //迭代方法 map filter some every reduce reduceRight forEach
    let arr4=[21,22,23,24,25,26,20];
    // let a4=arr4.map(item=>{ //处理数组元素【原数组不改变】
    //     return item%2
    // })

    // let a4=arr4.filter(item=>{ //返回满足条件的数组元素 【原数组不改变】
    //     return item>22
    // })

    // let a4=arr4.some(item=>{ //有一个数组元素满足条件 就是true 【原数组不改变】
    //     return item==20
    // })

    // let a4=arr4.every(item=>{//必须所有数组元素都满足条件 才是true 【原数组不改变】
    //     return item>21
    // })

    // let a4=arr4.reduce((prev,val)=>{ //从开始处向后面缩进 【原数组不改变】
    //     return prev+val
    // })

    // let a4=arr4.reduceRight((prev,val)=>{ //从后面向开始处缩进 【原数组不改变】
    //     return prev+val
    // })

    arr4.forEach((item,index)=>{ // 【原数组不改变】
        item=item%2
        console.log(item,index)
    })
    console.log(arr4)
    // console.log(a4)

    //entries from
    let arr5={'0':21,'1':22,'2':23,'3':24,'4':25,'5':26,length:6};
    console.log(Array.from(arr5));//[21, 22, 23, 24, 25, 26] 对象不改变

    let arr6=[12,15,16,21,25];
    console.log(Object.entries(arr6))//{0: 21, 1: 22, 2: 23, 3: 24, 4: 25, 5: 26, length: 6} 【原数组不改变】
    for(var z of arr6.entries()){
        console.log(z) //[0 ,12] 下标+数组元素
    }
    for(var x of arr6.keys()){
        console.log(x);//下标
    }
    for(var l of arr6.values()){
        console.log(l);//数组元素
    }
    let o=arr6[Symbol.iterator]();//迭代器
    console.log(o)
    console.log(o.next())//{value: 12, done: false}
    console.log(o.next())
    console.log(o.next())
    console.log(o.next())
    console.log(arr6)

    //查找  【原数组不改变】
    // indexOf lastIndexOf find findIndex findLast findLastIndex includes
    let arr7=[12,13,14,15,16,17,13,18,19]
    console.log(arr7.indexOf(13));//从开始处向后查找数组元素 返回下标 查找不到返回-1
    console.log(arr7.lastIndexOf(13));//从后往前查找数组元素
    // let a6=arr7.find(item=>{ //返回查找到的第一个数组元素 【或符合条件的】
    //     return item>13
    // })

    // let a6=arr7.findIndex(item=>{ //返回查找到的第一个数组元素的下标
    //     return item>13
    // })

    // let a6=arr7.includes(13);//数组中是否有某一个数组元素 有就是true
    // let a6=arr7.findLast(item=>{ //返回从后面开始查找到的第一个数组元素
    //     return item>13
    // })

    // let a6=arr7.findLastIndex(item=>{ //返回从后面开始查找到的第一个数组元素下标
    //     return item>13
    // })


    // console.log(a6)

    //二维数组
    let arr8=[[1,23,4,5,21],[12,11]];
    console.log(arr8.flat(1));//推平多维数组 【原数组不改变】
    let arr9=new Array(6).fill(18);//替换数组元素 [18, 18, 18, 18, 18, 18]
    console.log(arr9)

    let arr10=[21,22,23,24,25,26,20]
    console.log(arr10.with(1,18))//修改某个数组元素 【原数组不改变】
    console.log(arr10.toReversed())//翻转数组元素 【原数组不改变】
    console.log(arr10.toSpliced(1,1,12));//返回添加或修改的数组元素 【原数组不改变】
    console.log(arr10.toSorted((a,b)=>a-b))//排序 【原数组不改变】
    console.log(arr10)