day05数组
数据结构(存储结构,逻辑结构)
概述:只要能存储数据的就是数据结构
存储结构
-
顺序存储结构(查找的时候,数据越多,时间复杂度越高)
-
链式存储结构
-
索引存储结构
-
散列存储结构(最快查找)
逻辑结构
线性结构
-
数组
又称之为顺序表,通过索引下标进行访问
-
队列
先进先出的容器
-
栈
先进后出
非线性结构
-
链表
通过对应指针来指向
-
图
对应指针的指向
-
树
二叉树
-
散列表
hash表(hashxode来进行编码的)
-
广义表
-
...
数组
概述:数组是一种线性的数据结构可以存储对应的数据 通过对应的索引下标进行数据访问 一般情况下数组内存储的数据类型是一样的.(可以存储不一样数据类型的数据)
数组的定义
使用 [] 赋值来定义
var arr = [] //数组是一个对象
console.log(arr)
var arr = [1,2,6] //初始数据传入
console.log(arr)
使用new关键词进行定义
var arr = new Array()
console.log(arr)
// 传入一个参数表示的是他的长度length,这个数组里面有8个值 empty
var arr = new Array(8)
console.log(arr)
//这个数组里面有三个值分别为1,2,8
var arr = new Array(1,5,8)
console.log(arr)
数组的特性
数组具备下标 可以通过下标进行赋值
数组具备length属性 length重新修改 大于可以扩容 小于的时候可以进行删除操作
var arr = [1,2,3,4,5]
//通过下标访问 下标从0开始
console.log(arr[0])//访问第一个元素
arr[3] = 18
console.log(arr)
//可以做到 自动扩容
arr[10] = 20
console.log(arr)
//通过length来访问对应的长度
console.log(arr.length)
//length可以赋值 大于会进行扩容操作 小于的时候会进行删除操作
arr.length = 2
console.log(arr)
console.log(arr.length)
数组的遍历
使用普通循环
var arr = [1,2,3]
for(var i=0;i<arr.length;i++){
console.log(arr[i])
}
使用es5新增的for in关键词
//for in es5新增关键词 是为了遍历对象 数组也是对象
//for in 遍历的下标 对象是key
for(var index in arr){
console.log(index) //打印下标
console.log(arr[index])
}
使用es6新增的for of关键词
//for of es6 专门遍历数组(伪数组) 不能遍历对象
for(var value of arr){
console.log(value) //值
}
for in 和 for of 区别
for in 使用于遍历对象,遍历对象的key es5
for in 使用于遍历数组 遍历的是数组的值 es6
练习
将一个数组中底二个元素和底三个元素进行位置互换
var arr = [2,3,1,5,6,7,3]
function fn(arr){
//假设第一个是最大值 同时也最小值
var max = 0
var min = 0
//将对应的最大值和最小值和他比较 如果比最大值还大这个就是最大值,如果比最小值还小,这个就是最小值
for(var i=1;i<arr.length;i++){
if(arr[max]<arr[i]){ //如果比最大值还大,这个就是最大值
max = i
}
if(arr[min]>arr[i]){ //如果比最小值还小,这个就是最小值
min = i
}
}
var temp = arr[min]
arr[min] = arr[max]
arr[max] = temp
return arr
}
console.log(fn(arr))
传入某个数组,返回第二大的数
function fn1(arr){
if(arr.length<2){
return arr[0]
}
//得到最大值
var max = arr[0] > arr[1]?arr[0]:arr[1]
//得到第二大的值
var twomax = arr[0] < arr[1]?arr[0]:arr[1]
//再去比对
for(var i = 2;i < arr.length;i++){
if(arr[i]>max){ //如果比最大值还大,这个就是最大值,将最大值变为第二大的值
twomax = max
max = arr[i]
}else{
if(arr[i]>twomax){ //如果比最大值还小,那么比较这个值是否大于第二大的值
twomax = arr[i]
}
}
}
return twomax
}
console.log(fn1([3,8,5,4,2,8,7,10,9,11]))
!数据的相关方法
所有的存储空间都具备增删改查的方法
增加(add push set)
删除(delete(删除就会回收) remove(删除后还在内存中) pop)
push 添加都后面(返回新的数组长度)
var arr = [1,2]
var newLength = arr.push(3)
console.log(newLength)//3
console.log(arr) //[1,2,3]
pop 删除最后一个(返回删除的元素)
var arr = [1,2]
var deleteItem = arr.pop()
console.log(deleteItem)//1
console.log(arr) //[1]
shift 删除第一个(返回删除的元素)
var arr = [1,2]
var deleteItem = arr.shift()
console.log(deleteItem)//1
console.log(arr) //[2]
unshift 添加到第一个(返回新的数组长度)
var arr = [1,2]
var deleteItem = arr.unshift(3)
console.log(deleteItem)//3
console.log(arr) //[3,1,2]
修改(replace set....)
覆盖
arr[0] = 新的值
先删再加 splice
var arr = [1,2,3]
//将下标为1的数值删除,删除一个,插入一个4和5
arr.splice(1,1,4,5)
console.log(arr) //[1,4,3]
splice删除操作
var arr = [1,2,3,4]
//省略个数 删除到最后
arr.splice(1)
console.log(arr)
var arr = [1,2,3,4,5]
arr.splice(1,2) //从下标为1的位置开始删,删除两个(包含下标1)
console.log(arr)
splice增加操作
var arr = [1,2,3,4]
arr.splice(2,0,4,5) //从下标为2的位置 删除位置给0就是添加 添加4和5
console.log(arr)
splice 返回的是删除的数据组成的数组
查询(query select get ...)
indexOf 根据传入的值查询第一次出现下标
根据索引查询 indexOf 返回的就是index(传入对应元素,返回下标,如果没有返回-1)
var arr = [2,4,7,6,8,4]
console.log(arrOf(4))//1
console.log(arrOf(4,2))//查询数值为4 并且从下标为2开始查询
简单实现indexOf
var arr = [1,2,3,4,5,6,7,8,9,10]
function myIndexOf(value,start){
if(value == undefined){
throw new Error('为传入参数')
}
if(start == undefined){
start = 0
}
for(var i = start;i<arr.length;i++){
if(arr[i] == value){
return i
}
}
return -1
}
console.log(myIndexOf(4,8)) //10
反向
var arr = [1,2,3,4,9,10,4]
function myIndexOf(value,last){
if(value == undefined){
throw new Error('未传入参数')
}
if(last == undefined){
last = arr.length
}else if(typeof last != 'number'){
throw new Error('不是number类型')
}
for(var i = last;i>=0;i--){
if(arr[i] == value){
return i
}
}
return -1
}
console.log(myIndexOf(4,5))//3
以上方法会对于原本数值有影响
不影响原本的数组的方法(一定有返回值)
数组拼接 concat
var arr1 = [1,2]
var arr2 = [3,4]
//数组的concat方法传入的参数必须是数组
var concatArr = arr1.concat(arr2)
console.log(arr1)//[1,2]
console.log(arr2)//[3,4]
console.log(concatArr) //[1,2,3,4]
slice 截取 返回新的数组
var arr = [1,2,3,4,5,6]
//传入一个开始下标 结束下标(没有结束下标默认截取到末尾)不包含结束下标
var sliceArr = arr.slice(4,5)
console.log(sliceArr)
join 将对应的数组转为字符串
var arr = [,1,2,3,4,5]
//join如果不传入参数默认使用,来进行分割每一个元素
var str = arr.join('a')//传入一定是字符串
console.log(str)
位置排序方法
var arr = [2,3,4,5,8,7,2]
//默认情况下 sort方法是按照ASCII码排序
arr.sort()
//高阶函数用法 将函数作为参数的函数叫做高阶函数
var newArr = arr.sort(function(a,b){
return a-b //正序
})
console.log(arr)
console.log(newArr)
console.log(newArr == arr)
//反转方法
var arr1 = arr.reverse
console.log(arr)
console.log(arr1 == arr)
排序算法
常用的排序算法 (On2)
冒泡排序 (逐层冒泡)
选择排序 (选择一个数跟其他的进行比较)
插入排序 (在插入数据的时候的排序)
希尔排序 (快速插入排序)
快速排序 (快速冒泡排序 数据不大的情况下最快)
归并排序 (大数据处理最快)
堆排序
桶排序
冒泡排序
前一个和后一个比较 两两相比较,比较晚就交换位置,知道所有内容比较完
function bubleSort(arr){
for(var i = 0;i<arr.length-1;i++){
for(var j = 1;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
}
选择排序
选择一个下标和所有的数进行比较 如果比较完发现这个下标不是之前的下标就换位置
function selectorSort(arr) {
for (var i = 0; i < arr.length - 1; i++) {
//指定max为当前遍历的下标
var max = i
//max要跟其他所有的未排序的比较
for (var j = i + 1; j < arr.length; j++) {
if (arr[max] < arr[j]) {
max = j
}
}
//如果最大值不是原本的下标位置就需要交换位置了
if (max != i) {
var temp = arr[max]
arr[max] = arr[i]
arr[i] = temp
}
}
}
快速排序(二分排序)
function quiKSort(arr){
//如果你的数组长度只有一个 或者没有就直接返回这个数组
if(arr.length<=1){
return arr
}
//中间值去第一个
var mid = arr[0]
//左边容器
var left = []
//右边容器
right = []
//循环比较
for(var i=1;i<arr.length;i++){
arr[i]>mid?right.push(arr[i]):left.push(arr[i])
}
//递归调用无限去中间值
return quiKSort(left).concat(mid).concat(quiKSort(right))
}
console.log(quiKSort([50,41,20,32,58,99]))
标签：arr,console,log,day05,数组,var,下标
From： https://www.cnblogs.com/buyAVnub/p/17132209.html