数组与数据结构初识

数据结构

数据结构主要是数据的一个存储和逻辑结构的体现。只要能存储结构的一个结构我们就称为数据结构。

相关知识点

1. 数组 又被称为顺序表主要通过索引下标来进行访问（排序）

2. 队列 先进先出的容器

3. 栈 先进后出

4. 树 二叉树

5. 图 对应的指针的指向

6. 链表 通过对应的指针来进行指向

7. 散列表 hash表（hashcode来进行编码的）

8. ...

数组

概述

数组是一种线性的数据结构，他可以存储对应的数据，一般通过对应的索引下标进行数据的访问。在一般情况下我们在数组里面存储的数据类型是一致的。（数组也可以存储不同数据类型的数据）

数组的定义

使用 [] 赋值来定义

var arr = []
//里面的数据使用,隔开
var arr = [1,2,3]

使用new关键词来新建一个对象定义

var arr = new Array();//没有数据的数组定义
//传入一个参数 表示定义的长度
var arr = new Array(10);//表示当前长度为10
//传入多个参数 表示赋值填入
var arr = new Array(1,2,3)//表示这个数组里面有三个值 分别为1,2,3

数组的特性

• 数组具备下标 可以通过下标来访问和赋值操作

• 数组具备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,4] 
for(var i=0;i<arr.length;i++){
    console.log(arr[i])
}

使用es5新增的for in关键词

//使用es5新增的for in循环 （for in循环是为了遍历对象 数组也是一个对象）
//for in遍历的是下标（对象的key）
for(var index in arr){
    // console.log(index)
    console.log(arr[index])
}

使用es6新增的for of关键词

//在for in基础上进行改版的 for of （专门遍历数组的）es6
//for of不能遍历对象 只能遍历数组（伪数组）
for(var value of arr){
    console.log(value)//值
}

for in 和 for of的区别

1. for in是es5版本时给出的方法，用于遍历对象的 他遍历的是对象的key

2. for of是es6版本时新出的方法，用于遍历数组的 他遍历的是数组的值

3. 二者各有优势且有专攻,for in用于遍历对象的,他遍历的是对象的key;for of用于遍历数组的 他遍历的是数组的值

示例：

//将一个数组中的第二个元素和第三个元素进行位置互换
var arr = [1,2,3,4,5]
//传入的对应的需要互换的位置
function fn(pos1,pos2,arr){
    //保存第一个位置的值
    var temp = arr[pos1-1]
    //将第一个位置的值进行覆盖
    arr[pos1-1] = arr[pos2-1]
    //将保存的第一个位置的值赋给第二个位置
    arr[pos2-1] = temp
}
fn(2,3,arr)

示例2

//将数组 [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([2,3,1,5,6,7,3]))

示例3

//传入某个数组 返回第二大的数
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([9,2,3,10,8,1]))

数组的相关方法（所有的存储空间都具备增删改查的方法）

添加（add push set...）删除 (delete (删除直接回收) remove（删除完还在内存中） pop...)

1. push 添加到后面（返回新的长度）

//添加到最后一个
        var arr=[1,2,3,5]
        arr.push(1)
        console.log(arr)

2. pop 删除最后一个 （返回删除的元素）

//删除最后一个
        var arr=[1,2,3,4]
        arr.pop()
        console.log(arr)

3. unshift 添加到第一个 （返回的新的长度）

//添加到第一个
        var arr=[1,2,3,4,5]
        arr.unshift(11)
        console.log(arr)

4. shift 删除第一个 （返回删除的元素）

//删除第一个
        var arr=[1,2,3,4]
        arr.shift()
        console.log(arr)

修改 （replace set...）

覆盖

arr[0] = 新的值（给一个数组赋一个新的值）

先删再加 splice

var arr = [1,2,3]
//从下标为1的位置删除 删除一个 插入一个4和5
arr.splice(1,1,4,5)//新的数组 这个数组其实就原本的数组
console.log(arr)

splice的删除的操作

var arr = [1, 2, 3, 4]
//省略个数 删到最后（包含下标1）
arr.splice(1)
console.log(arr)
var arr = [1, 2, 3, 4]
//从下标1开始 删除俩个（包含下标1）
arr.splice(1,2)
console.log(arr)

splice的添加

//添加
var arr = [1,2,3,4]
arr.splice(2,0,5)
console.log(arr)

• splice返回的是删除的数据组成的数组

查询（query select get...）

indexOf 根据传入的值查询第一次出现的下标

查询索引indexOf 传入对应的元素 返回的是index （如果没有返回-1）

var arr = [2, 4, 6, 8, 4]
console.log(arr.indexOf(4))
//从第三个开始数 从前往后数 第二个参数为查找坐标（从左到右）
console.log(arr.indexOf(4,2))//4

简单实现indexOf

var arr = [2, 4, 6, 8,4]
//模拟实现indexOf
function myIndexOf(value,start) {
    if (value == undefined) {
        throw new Error('参数未传递')
    }
    //如果没有传递start 那么应该为默认值0
    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))

简单实现lastIndexOf (从右到左)

//模拟实现indexOf
function myLastIndexOf(value, start) {
    if (value == undefined) {
        throw new Error('参数未传递')
    }
    //如果没有传递start 那么应该为默认值0
    if (start == undefined) {
        start = arr.length
    }else if(typeof start != 'number'){
        throw new Error('参数类型不正确')
    }

    //开始查询
    for (var i = start; i >= 0; i--) {
        if (arr[i] == value) {
            return i
        }
    }
    return -1
}
console.log(myLastIndexOf(4))
console.log(myLastIndexOf(4,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]
//可以传入数组也可以传入对应的值
var concatArr = arr1.concat(3,4)
console.log(concatArr) 

slice 截取 返回新的数组

var arr = [1, 2, 3, 4, 5, 6]
//传入一个开始下标 结束的下标（默认没有传入结束的下标截取到末尾）不包含结束的下标
var sliceArr = arr.slice(4,5)//[5]
console.log(sliceArr, arr)

join 将对应的数组转为字符串

var arr = [1, 2, 3, 4, 5]
//join如果不传参默认使用,来进行分割每个元素 如果传入参数那么使用参数来分割
var str = arr.join('a')//传入的参数一定是字符串
console.log(str)

位置变换的相关方法

sort 排序

//排序的相关方法
var arr = [2,3,5,10,4,6]
//默认情况下 sort方法是按照ascii码排序
// arr.sort()
//高阶函数用法 将函数作为参数的函数叫做高阶函数
var newArr = arr.sort(function(a,b){
    return a-b //正序 b-a就是倒序
})
console.log(arr)
console.log(newArr)
console.log(newArr == arr)

reverse 反转

//反转方法
var arr1 = arr.reverse()
console.log(arr)
console.log(arr1 == arr)

排序算法

常用的排序算法 (On2)

1. 冒泡排序 (逐层冒泡)

2. 选择排序 （选择一个数跟其他的进行比较）

3. 插入排序 （在插入数据的时候的排序法）

4. 希尔排序 （快速插入排序）

5. 快速排序 （快速冒泡排序 （数据量不大的情况下最快））

6. 归并排序 （大数据处理中最快的排序）

7. 堆排序

8. 桶排序

9. 基数排序

10. ...

冒泡排序(On^2)

function bubblesort(arr) {
            //轮次数
            for(var i=0;i<arr.length-1;i++){
                //比较次数
                for(j=1;j<arr.length-i;j++){
                    //后跟前比较
                    if (arr[j]<arr[j-1]) {
                        //如果小于前一个数，把后面的值传入暂存变量中，再把大的值传入后面的位置，把小的值再赋给前面的位置
                        var ex =arr[j]
                        arr[j]=arr[j-1]
                        arr[j-1]=ex
                    }
                }
            }
            return arr
        }
        console.log(bubblesort([1,3,6,2,5,10]))

选择排序(On^2)

//选择一个下标和所有的数进行比较 如果比较完发现这个下标不是之前的下标就换位置
function selectSort(arr) {
            for(var i=0;i<arr.length-1;i++){
                //指定max为当前遍历的下标
                var max=i
                //max要跟其他的所有未排序比较
                for(j=i+1;j<arr.length;j++){
                    if (arr[max]>arr[j]) {
                        max=j
                    }
                }
                //如果最大值不是原本的下标位置就需要交换位置了
                if (max!=i) {
                    var ex =arr[max]
                    arr[max]=arr[i]
                    arr[i]=ex
                }
            }
            return arr
        }
        console.log(selectSort([1,4,9,3,5,11]))

快速排序（二分排序）Onlogn

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([5,10,1,0,6,12,7]))