• 欢迎光临~

数组

开发技术 开发技术 2022-07-29 次浏览

数据结构

            数据结构顾名思义 就数据的结构 (逻辑结构 存储结构 算法)
  •         存储结构 (数据存储的结构方式)
  •         线性结构:   数组(顺序表) 队列  栈  堆  链表
  •         非线性结构:   树  图  hash(散列表)
        只要是能存数据的容器 就必须具备增删改查的方法

数组

        JS数组的概念:字面意思就是一组数据(一般情况下是相同类型的数据, 不一定都是数字)

        数组的定义

        1.使用[] 声明数组

            var arr = [1,2,3,4,5];

        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);

        下标访问(下标可以是变量或表达式 从0开始 最后一个元素的下标为: arr.length – 1)

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

        数组的赋值 (给数组赋值,就是给数组的元素赋值,需要通过给数组的每个元素一一赋值,)

            arr[0] = 10;//让数组的第一个元素的值为10
            console.log(arr[0]) //10
            // 给数组里面的元素随机给值
            var arr = new Array()
            for(var i=0;i<10;i++){
                arr[i] = Math.random() //0-1 包含0 不包含1的
            }
            console.log(arr);

        数组遍历

            for循环遍历

                var arr = [1,2,3,45,12]
                //利用顺序表的特点 有序
                for(var i=0;i<arr.length;i++){
                    console.log(arr[i])
                }

            for in遍历 (对象 下标 迭代器 next)

                var arr = [1,2,3,45]
                for(var index in arr){ //index表示的为下标(可以随便设)
                    console.log(arr[index])
                }

            for of进行遍历(数组 迭代器来实现的)

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

        数组的方法(函数)

            添加 (add push append..)

                栈方法 (先进后出 后进先出)push 入栈 pop出栈操作
                push方法(数组末尾添加一个元素,并且返回长度)
                    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  从小到大排序 ,  原数组也被升序排序
                    //sort方法排序 //默认情况下他是根据第一个字符的ACSII码进行排序 (ACSII码排序)
                    var arr2 = [15,20,11,4,5]
                    arr2.sort() //返回一个数组 这个数组是排序好的数组 他跟上面一样 就是返回的这个数组其实就是原本的数组
                    console.log(arr2);
                    // 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);

        数组操作的方法(不影响原本数组)

            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)
                }
程序员灯塔
转载请注明原文链接:数组
喜欢 (0)