数组

数组

数据结构

—— 数据的结构（逻辑结构 存储结构 算法）

1.逻辑结构

2.存储结构

线性结构：

数组 、 队列 、 栈 、 堆 、 链表

非线性结构：

数 、 图 、 hash（散列表）

只要能存数据包的容器，必须具备增删改查的方法

3.算法

数组

概述：数组是固定一类数据存储组合（一般情况下数组存放的数据类型一致）

数组声明 —— 引用数据类型

1.使用[ ]声明数组，数据以“ , ”进行分隔

var arr = [1,2,3]

2.用new关键词进行声明（对象）

var arr = new Array(20)//Array里面参数指定对应的数组长度 没写则长度为零

length属性来访问对应的长度（也可以进行设置）

var arr = new Array()
//通过length来访问数组的长度
console.log(arr.length);
arr.length = 11 //设置对应的长度
console.log(arr);

下标访问

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

数组的赋值

arr[0] = 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）

for(var index of arr){//index表示的是下标
    console.log(arr[index])
}

for of遍历（迭代器实现）

使用for of遍历——只能遍历数组

for(var value of arr){//value表示的是里面的值
    console.log(value)
}

数组的方法

数组是一个存储结构——增删改查的操作

添加 —— add push append

删除——delete（硬删） remove（软删）

栈方法——先进后出 后进先出 push入栈 pop出栈

push方法——将内容追加到最后面（对应的返回值是长度）

pop方法——删除最后面（对应的返回值是被删除的那个值）

队列方法——先进先出 后进后出

unshift方法——将内容追加到最前面

shift方法——删除第一个

修改 —— replace替换 update 更新

反转 reverse ——将最后一个变到第一个 一个个对应的换位置

var arr = [1,2,3,4]
arr.reverse()//返回一个数组 这个数组就是反转后的数组（原本的数组）
console.log(arr)//反转后的结果[4,3,2,1]

排序 sort

默认情况下是根据第一个字符的ACSII码进行排序（ACSII码排序）

sort 是一个高阶函数 高阶函数就是里面用函数作为参考的函数

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)

var arr=[1, 5, 6, 3, 2, 8, 9, 4]
for(var i=1;i<arr.length;i++){
   for(var j=0;j<arr.length-i;j++){
       if(arr[j]>arr[j+1]){
          var s=arr[j]
          arr[j]=arr[j+1]
          arr[j+1]=s
       }
   }
}
console.log(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))
}

var arr = [12,5,7,11,36,48,6,2]
console.log(quick(arr));//[2,5,6,7,11,12,36,48]

4.希尔排序 ——插入排序的进阶

5.插入排序 ——插入数据表的时候进行排序

6.归并排序 —— 大数据吧排序的常用排序算法

......