搜索

day05 数组


发布时间: 2022-11-24 21:54:01    浏览次数:34 次

day05数组

数据结构

划分

  • 存储结构 (存储对应的数据的)
  • 逻辑结构(逻辑的体现)
  • 算法

存储结构的相关的内容

线性结构(有顺序)

数组 (顺序表)

栈 (先进后出)

队列 (先进先出)

非线性结构 (没有顺序)

链表 (单向链表 双向链表)

图 (有向图 无向图)

树 (二叉树)

hash

所有的存储结构 必须具备增删改查的方法

数组

概述:

数组是一种数据结构,它里面的存储的数据是有顺序的(又称为顺序表)。数组它里面存储的数据一般情况下是单一类型的数据。但是我们也可以存储多种类型。数组是一个存储数据比较简易的一个容器,所以它可以实现其他的相关数据结构。

数组的声明(引用数据类型)

使用[] 来声明

//第一种声明
var array = [1, 2, 3] //数据里面存储的数据采用,分割
console.log(typeof array) //object 数组是引用数据类型
console.log(array) 

使用new Array关键词声明

//第二种声明方式 采用new关键词 反是采用new 关键词构建的都是引用数据类型
var array = new Array() //没有指定长度的数组
//当你传递一个参数的时候 就是构建对应的长度的数组
var array1 = new Array(10) //new 后面的方法的首字母要大写 指定长度为10的数组
console.log(array1);
//当你传递多个参数的时候 就是将对应的参数放入对应的数组内
var array2 = new Array(1,2,3,4)
console.log(array2);

数组的特性

  • 下标 从0开始到length-1 可以通过[下标] 来访问对应的数组里面的值
  • length 长度(数组里面的值的个数)

数组的遍历

传统for循环进行遍历

var array = new Array()
for(var i=0;i<array.length;i++){
	console.log(array[i])
}

for in 遍历 (一般用于遍历对象)

//for in来遍历 key 也就是对应数组的下标 (一般用于遍历对象 不仅是遍历数组 它还可以遍历其他的对象)
for(var index in array){ //index这个key在array里面
    console.log(array[index]);
}

for of 遍历 (专门遍历数组)

//for of来遍历数组 遍历的是值
for(var value of array){ //value这个值存在于array中
    console.log(value);
}

数组的操作(方法)

添加方法(add push save set...)
push 添加到末尾

//数组的方法三步骤
// 1.方法的作用
// 2.方法的参数
// 3.方法的返回值

//添加方法 会改变原本的数组
//添加方法 会返回添加后的长度
// push方法  `往数组最后一个位置添加元素 参数可以是1个或者多个逗号隔开 返回的是数组的新长度`
var arr = [1,2]
var v = arr.push(3,4) //在末尾追加3 4
console.log(v);
console.log(arr.length); //4
console.log(arr); //[1,2,3,4]
unshift ``
// unshift `往数组的第一个位置添加成员,参数可以是1个或者多个逗号隔开 返回的是数组的新长度`
var m = arr.unshift(5,6,7)
console.log(m);
console.log(arr.length); //7
console.log(arr); //[5,6,7,1,2,3,4]

数组的添加方法返回对应的新的长度

删除方法 (delete(完全删除 硬删) remove(移出 软删)pop 移出...)
pop 删除数组最后一个成员,没有参数 ,返回被删除的成员
//删除方法 删除末尾的第一个 返回的是删除的元素
console.log(arr.pop()); //4
console.log(arr); //[5,6,7,1,2,3]
shift 删除数组第一个成员,没有参数 ,返回被删除的成员
//shift 删除 删除开头的第一个
console.log(arr.shift());//返回5
console.log(arr); //[6,7,1,2,3]

删除方法 添加修改和删除 splice(会影响之前的数组)

var arr1 = [1,2,3,4]
//开始下标 删除个数
//删除操作
var spliceArr = arr1.splice(0,1) //删除完成功内容 一个数组
console.log(spliceArr);//[1]
console.log(arr1);//[2,3,4]
//添加操作
console.log(arr1.splice(0,0,5));//[]
console.log(arr1);//[5,2,3,4]
//修改操作
console.log(arr1.splice(0,1,1)); //删除原本5 将1放到5的位置 5
console.log(arr1);//[1,2,3,4]

返回对应的删除的元素

修改方法
//数组修改就是重新賦值 数组没有修改方法
arr[2] = 0 //修改當前第三個元素 下标为2的元素的值
indexOf 下标索引,根据对应的值查询下标(有就返回对应的下标 没有返回-1)
var arr1 = [1,2,3,1]
//默认查询 从开头查到结尾 返回的是第一个查找到的下标
console.log(arr1.indexOf(1));//0
//根据对应的值返回下标 找不到返回-1
console.log(arr1.indexOf(4));//-1
//indexOf可以规定开头查找的位置
console.log(arr1.indexOf(1,1));//返回3
lastIndexOf 从后往前查找 找到第一个对应的下标 没有找到返回-1
//从后往前找 找到第一个 默认是从最后开始
console.log(arr1.lastIndexOf(1));//3
//根据对应的值返回下标 找不到返回-1
console.log(arr1.lastIndexOf(4));//-1
//lastIndexOf可以规定开头查找的位置 从下标1开始
console.log(arr1.lastIndexOf(1,1));//返回0
console.log(arr1.lastIndexOf(3,1));//返回-1
sort排序的方法

默认按照ascii码排序

// sort() 排序 `它默认是根据ASCII码进行排序,比较的是第一位,只能排序10以内的值的数,超过要使用回调函数,根据回调函数内部返回a-b升序 或者b-a降序`
var arr = [20,18,25,15,1,2]
//传入一个比较的方法 返回排序好的数组
var arr1 = arr.sort() //会改变原本的数组
console.log(arr);//[1,15,18,2,20,25]
console.log(arr1);
//引用数据类型的比较 == === 返回的值是一样
console.log(arr == arr1);//true 对应的排序返回的数组其实就原本排序完成的数组

如果需要按照对应的值的大小进行排序 自定义比较方法 return a-b 就是正序 return b-a就是倒序

var arr = [20,18,25,15,1,2]
// sort方法默认按照ascii码排序
// 自定义对应比较方法传入 进行排序
arr.sort(function(a,b){
    //返回的是a-b 对应的是正序 如果返回的是b-a 那么对应的是倒序
    // return a-b
    return b-a
})
console.log(arr);//[1,2,15,18,20,25]

引用数据类型的比较的是地址值 值比较的就是对应的值([] ! = [])

reverse反转的方法
var arr1 = [1,2,3,4,5]
arr1.reverse()
console.log(arr1);//[5,4,3,2,1]

不会改变原数组的方法

join 返回指定格式的字符串,默认是用逗号,隔开。(不会影响原本的数组)
var arr1 = [5,4,3,2,1]
//join 将数组转为字符串 返回一个字符串 不会更改原本的数组
//join里面的参数为对应的分隔符 默认为,
var str = arr1.join(':')
console.log(str);//5:4:3:2:1
console.log(arr1);//[5,4,3,2,1]
合并(合并多个数组 返回的是一个新数组 不会改变原本的数组)
concat
// 做连接方法 concat
var arr1 = [1,2,3]
var arr2 = [4,5,6]
//concat返回一个新的数组
var newArr = arr1.concat(arr2)
console.log(newArr);//[1,2,3,4,5,6]
console.log(arr1);//[1,2,3]
//做拷贝的方法 concat
var arr1 = [1,2,3]
var arr2 = [].concat(arr1)
arr1[0]='BB'
console.log(arr1)
console.log(arr2)

截取 (slice sub..)
截取 slice (不会影响原本的数组)
var arr1 = [1,2,3,4]
//截取多个 返回对应的截取的内容 开始下标  结束下标(不包含结束下标)
var sliceArr = arr1.slice(0,2)
console.log(sliceArr);//[1,2]
console.log(arr1);//[1,2,3,4]

排序算法(常见的排序算法的时间复杂度 O(n2))

1.冒泡排序(俩俩(相邻的俩个)相比 位置交换)O(n2)

//冒泡排序
function bubleSort(arr){
    //冒泡排序 外层的轮数
    for(var i=0;i<arr.length-1;i++){
        //控制比较的次数
        for(var j=1;j<arr.length-i;j++){
            //j和j-1 俩俩进行比较
            if(arr[j]<arr[j-1]){
                //换位置
                var temp = arr[j]
                arr[j] = arr[j-1]
                arr[j-1] = temp
            }
        }
    }
    return arr
}

2.选择排序 (选择一个值 跟所有的值进行比较 然后这个值不是开始的 就换位置)O(n2)

//选择排序
function selectorSort(arr){
    for(var i=0;i<arr.length-1;i++){
        //将当前的i值当做最大值
        var max = i
        for(var j = i+1;j<arr.length;j++){
            //判断当前的最大值小于j下标所在的值
            if(arr[max]<arr[j]){
                max = j
            }
        }
        //判断当前的最大值不是开始设置的值 要进行位置交换
        if(max != i){
            var temp = arr[i]
            arr[i] = arr[max]
            arr[max] = temp
        }
    }
    return arr
}

3.快速排序(冒泡排序的进阶 二分法)O(nlogn)

//快速排序
function quikSort(arr){
    //当我们的数组里面只有一个元素或者一个元素都没有的时候 退出返回这个数组
    if(arr.length <= 1){
        return arr
    }
    //取基数值 取第一个
    var mid = arr[0]
    var left = []
    var right = []
    //for循环 拿出所有的值跟中间值比较
    for(var i=1;i<arr.length;i++){
        arr[i]>=mid?right.push(arr[i]):left.push(arr[i])
    }
    return quikSort(left).concat([mid],quikSort(right))
}

4.插入排序

5.希尔排序(插入排序的进阶)

6.堆排序

7.桶排序

8.基数排序

9.归并排序(大数据排序)

....

免责声明 day05 数组,资源类别:文本, 浏览次数:34 次, 文件大小:-- , 由本站蜘蛛搜索收录2022-11-24 09:54:01。此页面由程序自动采集,只作交流和学习使用,本站不储存任何资源文件,如有侵权内容请联系我们举报删除, 感谢您对本站的支持。 原文链接:https://www.cnblogs.com/jje105/p/16923566.html