【数组与排序】

数组

数据结构

数据结构顾名思义 就是数据的结构（逻辑结构 存储结构 算法）

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

线性结构：

• 数组（顺序表）
• 队列
• 栈
• 堆
• 链表

非线性结构：

• 树
• 图
• hash（数列表）

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

数组

概述：数组是固定一类数据的组合（一般情况下 数组里面的数据类型一致）（多个数据）

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

1、使用 [] 声明数组

//里面的数据以,进行分隔
var arr = [1,2,3]

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

var arr = 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)	//0
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）

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 = [i]
arr.unshift(10)
console.log(arr)//[10,1]

删除（delete(硬删)remove(软删)…）

栈方法

pop方法（删除最后面）

var arr = [1,2,3]
arr.pop(0)//通过下标
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]
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 = [1, 2, 8, 3, 4, 5]
arr2.sort() //返回一个数组 这个数组是排序好的数组 他跟上面一样 就是返回的这个数组其实就是原本的数组
console.log(arr2);
// sort 其实就是一个高阶函数 高阶函数就是里面用函数作为参数的函数
var arr3 = [15, 20, 18, 11, 4]
arr3.sort(function (a, b) {
    //1和-1来进行大小区分和排序规则
    return a - b //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(1) //从1开始切到最后 如果下标不存在 返回一个空数组
console.log(sliceArr1);
var sliceArr2 = arr.slice(2, 3) //不包含结束的下标 但是包含开始的下标
console.log(sliceArr2);
//concat方法slice方法返回的数组跟原本的数组不是一个对象 但是里面的值或者对象他的地址是一样的（浅拷贝）
var obj = {
    name: "jack"
}
var objArr = [obj]
var objArr1 = objArr.concat()
var objArr2 = objArr.slice()
console.log(objArr[0].name); //jack
objArr1[0].name = '张三'
console.log(objArr2[0].name); //张三
console.log(objArr[0].name); //张三

splice方法（增加）

var arr2 = [1, 46, 74, 3, 5, 5]
arr2.splice(2,0,8) //下标 删除的个数  插入的值
console.log(arr2);//[1,46,8,74,3,5,5]

splice方法（删除）

//splice会影响之前的数组 删除 截取 插入
var arr = [12, 18, 38]
//参数有俩个 一个开始位置 一个删除的个数(可写可不写)    返回一个新的数组
// 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
}
var arr = [10,18,58,78,48,38]
console.log(bubble(arr));

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
}
var arr = [18, 58, 68, 38, 78, 28, 8]
console.log(selecter(arr));

3、快速排序（在数据量低于十万内最快的 在数据量不多的情况下最快的 是冒泡排序的进阶）二分O(nLogn)

function quick(arr){
    if(arr.length<=1){
        return arr
    }
    //定义左边的数组 右边的数组 基数
    var left = []
    var right = []
    var mif = 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])
}

4、希尔排序（由希尔发明的排序 是插入排序的进阶）

5、插入排序（在插入数据的时候进行排序 此时最快）

6、归并排序（大数据排序的常用算法）

…