数组

数据结构

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

存储结构（数据存储的结构方式）**

线性结构

数组（顺序表）

队列

栈

堆

链表

非线性结构

树

图

hash（散列表）

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

数组概述

数组是固定一类数据的存储组合（一般情况下数组里面的数据类型一致）

数组声明（引用数据类型）

1.使用[ ]声明

数据之间使用 ， 分隔

var arr = [ 1,2,3]
[1,2,3]==[1,2,3]    //false
//引用数据类型比较是地址的比较，只有常量才是固定地址（值类型是常量）

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

var arr = new Array(10)   //10 是长度 不写参数则表示没有长度，默认为0
//length属性访问对应的长度
var arr = [1,2,3]
arr.length=11  //设置数组长度
console.log(arr[0])      //输出数组的第一个内容
console.log(arr["0"])   //输出数组的第一个内容，说明可以写入字符串形式
//单个数据表示长度，多个数据表示数组内容
//相当于开了10个空间，但是没有进行赋值，默认是undefined

数组的赋值

arr [2] = 10  //让第三个元素为10
​
​
var arr= new Array()
for(i=0;i<10;i++){
    arr[i] = Math.random()  //返回[0,1)之间的值
}
console.log(arr)
//但其实每个数出现的概率不一样

数组遍历

for循环遍历（利用顺序表的特点 有序）

var arr = [1,6,5,8]
for(var i=0;i<arr.length;i++){
    console.log(arr[i])
}

for in遍历（对象 下标 迭代器next）

var arr = [1,6,8,9,0]
for(var i in arr){   //i表示的是下标
    console.log(arr[i])
}

for of 遍历（只能遍历数组）（数组 迭代器）

相当于一个一个名字的数，直到数到没有名字，靠迭代器实现

var arr = [1,6,8,9,0]
for(var value of arr){  //value 表示的是值
    console.log(value)
}

对数组能进行遍历操作的原因**：数组是一个顺序表，依赖于下标实现

数组的方法

添加（add push append）

栈方法（先进后出，后进先出）

将内容追加到最后面 push方法 返回值 长度

var arr= [1,2]
arr.push(3)
console.log(arr) //arr[1,2,3]

队列方法（先进先出，后进后出） 返回值 长度

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

var arr = [1,2,3]
arr.unshift(4)
console.log(arr) //arr[4,1,2,3]

删除（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= [2,3,4,6,8]
arr.reverse()   //返回反转后的数组，其实就是原本的数组
console.log(arr) //[8,6,4,3,2]
//arr .reverse  和 arr  是一个东西，即对arr.reverse 进行添加删除等操作，arr也会跟着改变，反转后产生的数组就是进行反转操作后打印出的数组

排序 sort 方法 默认情况根据第一个字符的ASCII码进行排序（ASCII码排序）

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

 var arr = [3,4,1,2,6,5]
 arr.sort()  //返回一个数组，这个数组就是排序好的数组
console.log(arr) 
var arr1 = [11,4,5,12,21]
arr.sort()
console.log(arr1) //[11,12,21,4,5]
var arr1= [11,4,5,31,23]
arr.sort(function(a,b){
   //1 和 -1 进行大小区分和排序规则
    return a-b  //a-b是正序  b-a是倒序
})console.log(arr1)
​

连接 concat()方法 追加数据, 返回一个新数组, 不改变原数组

var arr = [1,2,3]
var arr1 = [4,5]
var arr2 = [6,7]
//contact连接 把多个数组连接成一个数组，返回...扩展运算符(必须是数组)（...表明可以写任意个，不止三个）
var newArr = arr.contact(arr1,arr2)
console.log(newArr)

截取 slice()方法 不修改原数组, 将原数组中的指定区域数据提取出来,返回新的数组

var arr = [1,2,3]
var sliceArr = arr.slice() //全切
console.log(sliceArr)
var sliceArr1 = arr.slice(0)//从下标为0开始切到最后
console.log(sliceArr1)//[1,2,3]
var sliceArr2 = arr.slice(4) //当不存在这个下标值时，会返回一个空数组
console.log(sliceArr2)//空数组
var sliceArr3 = arr.slice(1,3)//不包含结束的下标，包含开始的下标
console.log(sliceArr3)//[2,3]

contact和slice方法返回的数组跟原本的数组不是一个对象，但是里面的值或者对象的地址是一样的

splice方法

会影响之前的数组 删除 截取

var arr= [12,15,18]
//参数  1.开始位置   2.删除的个数（可以不写,默认是数组的长度length）3加入的数值
var newArr = arr.splice(0) ； 
console.log(newArr);//[12,15,18]
console.log(arr);//[]
var arr1=[12,15,18]
var newArr1 = arr1.splice(1,1)
console.log(arr1) //[12,18]
console.log(newArr1)//[15]  获取删除的内容，其实就是截取里面的内容

查询****

堆和栈

栈：自动分配内存空间，系统自动释放，基本类型的值和引用类型（object）的地址

堆：动态分配的内存，大小不定，也不会自动释放。存放引用类型的值。

排序算法

1.冒泡排序

function bub (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.选择排序（选择最大值的下标（或者最小值）进行比较的排序）

逻辑原理：一共进行两层循环，先假定最小值（或最大值）的下标为外层循环的第一个数的下标，然后在第二层循环中遍历所有的数值，找到最小的值（或最大的值）所在下标，记住该下标，(此时先不进行交换值的操作)，如果第二层循环得到的最小的值的下标与最开始标记的下标不同则将这两个值进行交换

function select(arr){
    for(var i=0;i<arr.length;i++){
         var min = i
               for (var j = i + 1; j < arr.length; j++) {
                    if (arr[j] < arr[min]) {
                        min = j
                    }
                }
              if (min != i) {
                    var temp = arr[i]
                    arr[i] = arr[min]
                    arr[min] = temp
              }
    }return
}

3.快速排序（在数据量不多时是最快的 冒泡排序的进阶）

n log n

4.希尔排序（插入排序的进阶）

5.插入排序（插入数据的时候进行排序）

6.归并排序（大数据排序的常用方法）