数组

数据结构

数据结构顾名思义 就数据的结构 (逻辑结构 存储结构 算法)

存储结构 (数据存储的结构方式)

线性结构

数组(顺序表)
队列


链表
非线性结构

hash(散列表)

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

数组(个人简介就是一个地址吧很多东西都存起来)

数组概述:数组固定一类数据的组合(一般情况下我们数组里面的数据类型一致)(多个数据)

数组的声明(引用数据类型)

1.使用[] 声明数组

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

2.使用new 关键词进行声明 (对象)

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

删除 (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 = [1,2,3,4,8]
var 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 = [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);

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)

//冒泡排序核心点 俩个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
}

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))
}

练习习题

 //第二题冒泡函数
    function fn(arr) {
        for (var j = 0; j < arr.length - 1; j++) {
            for (var i = 0; i < arr.length - j - 1; i++) {
                if (arr[i] > arr[i + 1]) {
                    var temp = arr[i]
                    arr[i] = arr[i + 1]
                    arr[i + 1] = temp
                }
                console.log(arr);
            }
        }
    }
    var arr = [9, 3, 6, 2, 4, 1, 8, 5, 7]
    fn(arr)
    //第三题
    var sum = 0
    for (var i in arr) {
        sum += arr[i]
    }
    console.log(sum);
    //第四题
    var max = -Infinity
    var min = +Infinity
    for (var i in arr) {
        if (min > arr[i]) {
            min = arr[i]
            minsubscript = i
        }
        if (max < arr[i]) {
            max = arr[i]
        }
    }
    console.log('数组之中最大数是' + max + '最小数是' + min);
    //第五题
    // 给定一个不存在重复元素的整数数组,例如[6,4,7,2,5,8]和一个数字,例如10,请设计
    // 一个函数找出两个元素(或同一个元素加自身),并且使这两个数的和为给定数字,并打印出来
    // 例如[6,4,7,2,5,8]和数字10. 打印结果为: 6,4  2,8  5,5 
    function fn1(arr, a) {
        for (var j = 0; j < arr.length; j++) {
            for (var i = 0 + j; i < arr.length; i++) {
                if (arr[j] + arr[i] == a) {
                    console.log(arr[j] + ',' + arr[i]);
                }
            }
        }
    }
    var arr1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    fn1(arr1, 10)
    //第六题 随机给出一个10位以内的数,然后输出该数共有多少位,并将每位的数字保存到数组中. 
    //  如:1342, 位数为:4, 数组为:[1,3,4,2]
    // var su1=parseInt(10000000000*Math.random());
    // console.log(su1);
    function fn6(){
        var su1=parseInt(10*Math.random());
        console.log(su1);
        var m=0
        var su2=1
        var arr =[]
        for(var i =0;i<su1;i++){
            su2*=10
        }
        console.log(su2);
        var su3 =parseInt(su2*Math.random());
        console.log(su3);
        for(var j = 0 ;j<su1;j++){
            // arr.push(parseInt(su3%10))
            // su3/=10
            // if(parseInt(su3)==0){
            //     console.log(sum);
            // }else if(parseInt(su3)!=0){
            //     sum++        
            // } 
            if(su3/10!=0){
                arr.push(parseInt(su3%10))
                su3/=10
            }else if(su3/10!=0&&parseInt(su3/100)==0){
                break
            }
        }
        arr.reverse()
        console.log(arr);
        console.log('此数为 '+su3*su2+' 位数为  '+su1+' 数组为 '+'['+arr+']');
    }
    fn6()
    // 7,  给定两个升序整型数组a和b,打印其共同元素,比如:a = [0, 1, 2, 3, 4],b = [1, 3, 5, 7, 9],输出 1, 3
    function fn7(a, b) {
        var i = 0,
            j = 0,
            sum = ''
        for (i = 0; i < a.length; i++) {
            for (j = 0; j < b.length; j++) {
                if (a[i] == b[j]) {
                    sum += a[i] + ' '
                }
            }
        }
        console.log(sum);
    }
    var arr7 = [0, 1, 2, 3, 4]
    var arr8 = [1, 3, 5, 7, 9]
    fn7(arr7, arr8)
    // 8,  有一个从小到大排好序的数组。现输入一个数,要求按原来的规律将它插入数组中,      
    //  如: [2,3,4,56,67,98]    //63, 100
    function fn8(n, a) {
        for (var i in n) {
            if (a <= n[i]) {
                n.splice(i, 0, a)
                console.log(n);
                break
            } else {
                n.push(a)
                console.log(n);
                break
            }
        }
    }
    var arr9 = [2, 3, 4, 56, 67, 98]
    fn8(arr9, 100)
    // 9, 取出数组[1,3,1,4,2,3,6,2,6,1,5]中的重复项,存入一个
    // 新的数组,并从大到小排序 
    function fn10(arr){
        arr.sort(function(a,b){
            return b-a
        })
        console.log(arr);
        var arr1 =[]
        for(var i = 0;i<arr.length-1;i++){
            if(arr[i]==arr[i+1]){
                arr1.push(arr[i+1])
            }
        }
        console.log(arr1);
        for(var m = 0 ;m<arr1.length;m++){
            for(var j = 1 + m; j < arr1.length ; j++){
                if(arr[m]==arr[j]){
                    arr1.splice(m,1)
                    console.log(arr1);
                }
            }
        }
    } 
    var arr =[6,1,3,1,4,2,3,6,2,6,1,5]
    fn10(arr)
    // 10, 生成13位条形码(对之前的知识综合练习)
    //   Ean-13码规则:第十三位数字是前十二位数字经过计算得到的校验码。
    //    例如:690123456789  -> [6,9,0,1,2,3,4,5,6,7,8,9]
    //   第十三位计算其校验码的过程为:
    //       1,前十二位的奇数位和6+0+2+4+6+8=26
    //         2,前十二位的偶数位和9+1+3+5+7+9=34
    //             3,将奇数和与偶数和的三倍相加26+34*3=128
    //                 4,取结果的个位数:128的个位数为8
    //                 5,用10减去这个个位数10-8=2  
    //                  所以校验码为2(注:如果取结果的个位数为0,那么校验码不是(10-0=10),而是0
    //   实现函数ean13(n)计算验证码,输入12位条码,返回带验证码的条码。
    //   例如:输入:692223361219输出:6922233612192
    function ean13(n) {
        var arr = []
        for (var i = 0; i < 12; i++) {
            arr.push(parseInt(n % 10))
            // console.log(parseInt(n%10));
            parseInt(n /= 10)
            // console.log(parseInt(n));
        }
        // console.log(arr);
        arr.reverse()
        // console.log(arr);
        var one = 0,
            two = 0,
            three = 0
        for (var j in arr) {
            if (j % 2 == 0) {
                one += arr[j]
            } else {
                two += arr[j]
            }
        }
        three = 10 - (one + two * 3) % 10
        if (three == 10) {
            arr.push(0)
        } else {
            arr.push(three)
        }
        console.log(arr);
    }
    ean13(690123456789)
    // 11, 开发一个标题为“FlipFlop”的游戏应用程序。它从1计数到100,
    // 遇到3的倍数就替换为单词“Flip”,5的倍数就替换为单词“Flop”,
    // 既为3的倍数又为5的倍数则替换为单词“FlipFlop”。
    function fn11(n){
        var arr=['FlipFlop']
        // console.log(arr);
        for(var i = 1 ;i<=n;i++){
            if(i%3==0&&i%5!=0){
                arr.splice(0,1,'Flip')
                console.log(i);
                console.log(arr);
            }else if(i%3!=0&&i%5==0){
                arr.splice(0,1,'Flop')
                console.log(i);
                console.log(arr);
            }else if(i%3==0&&i%5==0){
                arr.splice(0,1,'FlipFlop')
                console.log(i);
                console.log(arr);
            }
        }
    }
    fn11(100)
声明:本站所有文章,如无特殊说明或标注,均为本站原创发布。任何个人或组织,在未征得本站同意时,禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益,可联系我们进行处理。