数组以及数组排序

一 数组

      1  什么是数组？

数组：存储一组相同数据类型的数据

var arr = [1,3,5,,2] ; 


方括号中的值即是数组。 

  var arr[index]   

index代表数组的下标，即是数组有多少个内容

     

 var arr[length]



  var arr = [1,2,3] ;
  arr[10] = 20 ;
     // 实际上变相的加长了数组的长度
    // [1,2,3,,,,,,,20]

length 代表数组的长度，数组中有几个值，length就是几。

当我们给一个超出数组长度的下标赋值后，数组会自动延长到赋值的下标，其中没有声明和赋值的内容会由空白显示，数据类型是 undefined。

        数组一般只保存一个类型的值（纯数字，纯字母，纯字符串），但是也可以保存不同类型的值，但是这样不是很规范。

2 ，数组的声明

    var arr = [1,2,3]    // 字面量声明



        // // 数组是一个对象

        // var arr = new Array(1,2,3) ;  // 实例化一个对象  Array构造函数(用于创建对象的)



        // console.log(arr.length);

            此时数组的长度等于3





        // var a = 1 ;    // 字面量声明



        // var b = new Number(2) ;   // 实例化一个对象







        // var c = 'hello' ;    // 字面量声明

        // var d = new String('hello') ;   // 实例化一个对象




        // // 当Array只有一个参数的时候，表示数组的长度

        // var arr2 = new Array(10) ;

        // console.log(arr2);





        // 声明一个空数组，向数组中追加值

        var arr = [] ;

        arr[0] = 'a' ;

        arr[1] = 'b' ;

        arr[2] = 'c' ;

        arr[10] = 'f' ;

 数组的声明方式有两种，字面量声明和具体化声明，即实例化声明，常用的一般是字面量声明

        2 生成10个随机数，存入数组

 
      //  利用函数随机生成一个随机数，随机数的范围由min 和max决定
function rand(min, max) {
            return parseInt(Math.random() * (max - min) + min)
        }
        // 生成10个数，存入数组
        //    生一个，存一个

        // 创建一个空数组
        var arr = [];
           // 利用循环生成随机数，循环十次，生成十个
           // 数组的下标从0开始，所以i初始是0 结束是9
        for (var i = 0; i < 10; i++) {
              //  通过循环给数组的每一个角标赋值一个0-100的随机数
            // arr[i] = rand(0,100) ;
            arr[arr.length] = rand(0, 100);
        }

//将生成的随机数打印在控制台
        console.log(arr);

先生成一个空对象，通过方括号注明这是一个数组，再利用函数生成一个随机数，

利用循环生成十个0-100的随机数，且每一个都赋值在对应的角标上。

          3 数组的遍历，浏览数组中所有的数

 // 遍历：读取数组中的每一个值

        var arr = [1,2,3,4,,,,5] ;
         console.log(arr[0]);
         console.log(arr[1]);
         console.log(arr[2]);
            常规打印需要将数组中每一个值打印出来，效率太低

        //    循环遍历
         for(var i = 0 ; i < arr.length ; i++) {
             console.log(arr[i]);
         }

        // for in  用于遍历对象的角标 -- bug(自动过滤掉空值)
         for(var i in arr) {
             console.log(arr[i]);
         }

        // for of 遍历对象 的值
        for(var v of arr) {
            console.log(v);
        }

循环遍历有三种办法

1，常规循环，声明一个 i等于0  小于数组的长度，i自增，

再在每一次循环中将数组的值打印出来。

2    for of 循环  明一个 v   of  要遍历的数组  再在每一次循环中将数组的值打印出来，

空对象也不会漏过。

3，for in 循环，声明一个 i   in 要遍历的数组  同样再将数组中每一个值的角标输出出来，

注意！！！ for in 输出的是 角标，即该值在数组中的位置而不是该值的实际内容，另外 for in

会自动跳过空对象，不识别

         4 存入十个随机数进数组，再求出十个数字的平均数

     // 创建一个函数
        function shuzu(min,max){
            //  哇一个 长度为10的数组
            var a = new Array(10)
            //  给数组里面的每一个赋值一个0-100的随机数
            for(var i = 0 ; i <a.length;i++){
                a[i] = parseInt(Math.random()*(max-min)+min)
            }
            // 输出数组结果
            return a
        }
        // 取一个求和数初始为0
        var sum =0
        // 用循环将数组里的每一个值相加，sum等于求和数


        // for(var j of shuzu(0,100)){
        //     sum += j
        // }

            for (var j in shuzu(0,100)){
                sum += shuzu(0,100)[j]
            }
            // 用求和数除以 数组的长度,结果就是数组的平均数, 注意 这里不能用  a.length, 
            // 因为a 是局部变量 在外面获取不到他的值,需要用函数名
        console.log((sum/shuzu(0,100).length))

        创建一个长度为10的数组，再创建一个随机生成0-100的随机数的函数，

通过 for循环每生成一个随机数就将值赋给数组，

        再哇一个 sum作为空箱子 利用for in 或者for of 循环将数组的十个值累加到sum里，

注意！！！ 此处 for of 可以直接累加，但是 for in 遍历出来的只是数组的角标，需要将J放到函数的方括号里才能累加

        最后 用sum值除于数组的长度即可得到数组的平均值。

          5  在一串数组中随机取出6位数字作为验证码

 //创建一个取随机数的函数
                     function suiji(min,max){
                   return  parseInt(Math.random()*(max-min)+min)
                    }
                    // 哇一个 数组，内容各式各样
                  var arr = ['a','b','c','d','e','A','B','C','D','E','1','2','3','4','5','6']  

                  // 哇一个res为空字符串
                    var  res = ''
                    // 利用循环在0到数组的长度之间选取数字作为数组的角标
                    // 再通过角标选出字符串中的值后用res字符串拼接。
                    for(var i = 0 ;i < 6 ; i++){
                        res += arr[suiji(0,arr.length)]
                    }
                    console.log(res)
    </script>

创建一个数组，输入内容，也可以用函数随机输入，

哇一个res为空字符串，主要做拼接用

利用循环在数组中随机取出四位数字，通过字符串拼接后输出。

        6 找到数组中的最大值或者最小值 

 var arr = [6,3,2,11 , 34,8] ;

        // // 假设第一个值最大
         var max = arr[0] ;
        // // 拿他和后面的所有数比较
         for(var i = 1 ; i < arr.length ; i++) {
        //     // 如果这个数比后面的数要小
            if(max < arr[i]) {
                // max 只存储最大的那个数
                max = arr[i]
             }
         }
         console.log(max);

1 哇一个数组，赋值一堆数字，

2 用假设法来对比，假设第一个数字最大，拿他和后面的每一个值做比较，

 假如遇到一个比他大的数字，则将MAX的值替换成这个数字，再用这个数字

和余下的值做比较，直到比完，最后留下的这个值便是这个数组的最大值，

最小值同理。

         7 找到数组中是否存在某个值

function includes(arr , n) {  

            // 因为找到他存在的证据很容易
             var flag = false ;

            // 遍历数组
            for(var v of arr) {
                if(n === v) {
                    
                    // 如果已经找到了就不需要继续找
                    // break ;
                    return true
                }
            }
            // 比较结束以后，才能说找不到
            
            return false 
        }


        var res = includes([1,2,3,4] , 12)
        console.log(res);

1 创建一个函数，形参分别是数组和要找的那个值，

2 先假设这个值在数组中没有，所以哇一个 flag等于 false

3 再通过 for of 循环遍历整个数组，用要找的那个值和数组中的每一个值做对比

4 假如找到这个值 就输出一个 flag等于true 否则就输出 flase 

         8数组拼接成字符串，中间用符号隔开

   // 创建一个函数，行参是数组和隔开的符号
function join(arr , f) {  
                    //遍历整个数组
            for(var i = 0 ; i < arr.length ; i++) {
                // 最后一个不加逗号
                  哇一个res通过字符串拼接将数组的每个值拼接在一起，
                    并且在每个值的后面加一个符号隔开
                    通过三目运算符识别最后一个数组不加符号
              var  res += i < arr.length - 1 ? arr[i] + f : arr[i]
            }
            console.log(res);
            return res
        }

        
        join([1,2,3,4] , '')

1 创建一个函数，行参是数组和隔开的符号，遍历整个数组，

 2 哇一个res通过字符串拼接将数组的每个值拼接在一起，
                    并且在每个值的后面加一个符号隔开
                    通过三目运算符识别最后一个数组不加符号

3 再函数输出res

         9 数组的冒泡排序

     var arr = [8,5,3,2,1] ; 
for(var j = 0 ; j < arr.length - 1 ; j++) {
            // 每两个相邻的值做比较
            for(var i = 0 ; i < arr.length - 1 - j ; i++) {
                // 前面的比后面的大，就交换
                if(arr[i] > arr[i + 1]) {
                    var t = arr[i] ;
                    arr[i] = arr[i + 1] ;
                    arr[i + 1] = t ;
                }
            }
            // 每一轮拿到一次最大值
            console.log(arr);
        }

        console.log(arr);

冒泡排序是拿一个数和后面的一位数做比较，如果第一个值比第二个值大，则交换数值，再拿第二个值和第三个值对比，如果第二个值比第三个值大，继续交换数值，如果前面值比后面值小则不交换，以此类推，一直到最后一个值，这样就能把最大的值排序到最后，

当最大的值找到后，继续找第二大的值，一直到找完为止。

1 先哇一个数组

2 第一层循环假设一个 j 等于0  j 小于数组的长度减一（因为数组的角标从0开始，长度减一即是数组的最后一位数）

3 第二层循环驾驶一个 i = 0   i小于数组的长度减去 j 和1 （第一层循环每走完一遍，代表已经找到一个值的位置，即不用再进行对比）

4 先拿出第一个数和第二个数对比，如果第一个数比第二个数大就互相交换数值，

5 如果第一个数比第二个数小就不交换。

6 再继续对比下去，直到比完一圈，第二层循环走完，此时第一层循环走一步，继续第二层循环继续重复以上步骤，直到最后，所有数值全部排列完毕。

         10 数组选择排序

var arr = [1,4,2,7,3,6];


        for(var i = 0 ; i < arr.length - 1 ; i++) {
            // 假设第i个位置上的数是最小的
            var min = i ;
            // 拿这个最小的值和后面所有的数进行比较
            for(var j = i + 1 ; j < arr.length ; j++) {
                // min对应的数比后面的数大
                if(arr[min] > arr[j]) {
                    min = j 
                }
            }
            console.log(min);
            // 拿到最小值以后，与第一个位置上的值交换
            if(min !== i) {
                var t = arr[i] ;
                arr[i] = arr[min] ;
                arr[min] = t ;
            }
        }


        console.log(arr);

 选择排序，从所有的数组中找到最小的那个通过交换数值的办法放在数组的第一位，

再找到第二小的一个数值，交换到数组的第二位，一直到所有的数值全部找到自己相应的位置（此方法对比冒泡排序，对程序的优化更好，所占用内存也更少，代码稍复杂）

1 先哇一个数组，数值若干
2 第一层循环，假设一个 i 等于0   i 小于数组的长度减一（因为数组的角标从0开始，长度减一即是数组的最后一位数）

3 哇一个 min为最小值 先将最小值暂定为 数组第个 i 值

4 第二层循环假设一个 j = i+1   j 小于数组的长度 （J代表数组的第J个值）

5 把之前假设的一个最小值min 和数组中的所有值做对比，假如有数值小于min，则将min的值的角标替换成这个值的角标

6 先判断这个min 是不是最初的 i   如果是，则不做变动，如果不是，则将这个角标为min的值替换到角标为I的位置上。

         11 数组的基本方法

 push(v1,v2,v3...)   向数组尾部追加值
         pop()  在数组尾部删除一个值

         unshift()   向数组的头部追加值
        shift()     向数组的头部删除一个值

 push(v1,v2,v3...)   向数组尾部追加值

       pop()  在数组尾部删除一个值

         unshift()   向数组的头部追加值

         shift()     向数组的头部删除一个值

         12 数组的 shift 封装以及 unshift 封装

 

    设置一个函数
 function shift (arr) {
       var一个空数组 利用循环把函数的实参输入数组中，因为i是从角标1开始
        所以第一个数就被删除了
        for(var i = 1,arr_new = [];i<= arr.length - 1;i++)
        arr_new[arr_new.length] = arr[i] 
        return arr_new
    }
    console.log(shift ([1,2,3,4]))


arguments是一个对象，且只能在函数中使用，可以在不声明形参的情况下接受实参
        设置一个函数
    function unshift (arr){
            设置一个i 等于 1   arguments接收的是所有的实参，第一个是被添加的对象，所以绕开
            第一个数，将后面的所有值添加到第一个值的前面，最后面的值添加到第一位。 
            for(i = 1;i <= arguments.length - 1;i++) 
                
            arr.unshift(arguments[i])
            return arr
        }
        console.log(unshift ([1,2,3,4],5,6,7))