数组的基础应用及冒泡排序算法

前两天提到了数组并学习了如何利用数组解决简单的问题。简单回顾一下：

  <script>


        // 创建一个学生成绩数组，存储所有学生的数学成绩，分别是89,78,90,99,67,59
        var scoreArr = [89, 78, 90, 99, 67, 59]

        //求所有学生的最高分并输出在界面
        //假设第一数为最高分
        var max = scoreArr[0]

        //依次与后面的分数相比，如果大于max,就赋值给max
        for (var i = 1; i < scoreArr.length; i++) {
            if (scoreArr[i] > max) {
                max = scoreArr[i]
            }
        }
        console.log('最大值',max)

        // if(scoreArr[1]>max){
        //     max=scoreArr[1]
        // }
        // if(scoreArr[2]>max){
        //     max=scoreArr[2]
        // }
        // if(scoreArr[3]>max){
        //     max=scoreArr[3]
        // }
        // if(scoreArr[4]>max){
        //     max=scoreArr[4]
        // }
        // if(scoreArr[5]>max){
        //     max=scoreArr[5]
        // }
        // console.log('最大值',max)


        //4.求不及格的学生有几个，打印到界面
        //    分析：遍历学生成绩数组，与60比较，小于则不及格，计数器加一
          var count=0
        for(var i=0;i<scoreArr.length;i++){
            if(scoreArr[i]<60){
                count++
            }
        }
        console.log('不及格人数',count)

    </script>

今天重点学习一下数组的存储结构：

var obj={
        name='rose';
        age=18
         }

var obj1=obj
obj1.age=20

请问此时obj的age为18还是20？

看了上面的图，不难发现此时age为20；

var arr=[10,20,30]
var arr1=arr
arr[1]=200
console.log(arr[1])

同样的道理，换成数组，同样arr【1】的值为200！

若是加上函数的调用来综合使用，例如：

 <script>
       var obj={
        name:'jack',
        age:18
        }

        function fun(obj1){
            obj1.age=20
            console.log('fun age',obj1.age);
        }

        fun(obj)
        console.log('age',obj.age)
 </script>

不难思考出，此时obj1.age和obj.age都为20 

 在思考以下输出：

        var m = 100
        function fun1(m){
            m = 200
            console.log(m)  //200
        }
        fun1(m)
        console.log(m)   //100

数组的常用方法：

 object对象

            数组对象

            属性和方法

            var arr=[10,20,30]

            vrr .length 属性

        方法1.push

             arr.push(40) //将40装入数组

             追加数据

           2.pop

            arr.pop()

            删除最后一个元素

            3.unshift()

           在数组最前面添加元素

           4.shift

           删除数组最前面添加元素

           5.1     splice(下标，元素个数)

           从下标为*开截取，截取*个元素

           5.2     splice(下标，元素个数，替换的内容)

           从下标为*开截取，截取*个元素，并替换

          6.  数组名.reverse

           反转数组输出

          7.sort

           数组排序

 

          8.concat

           多个数组进行拼接

           var=[1,2,3]

           var newArr=arr.concat([4,5,6])

         9.join

           把数组里面的每一项的内容链接起来，变成字符

           var arr=[1,2,3]

           var str=arr.join('-')

            输出1-2-3

        10.indexOf(你要找的数组中的项)

           找数组中某一项的索引

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

            var index=arr.indexOf(3)

            console.log(index)

            找的为数组中值为3的那个

            如果有则返回1

            没有会返回-1哟！！！

 

        11.includse

          检测数组中是否包含有所找的元素

           var arr=[10,20,30,40]

           console.log(arr.includes(20));

  var arr = [10, 20, 30]
        console.log(arr)

       // 追加40
        arr.push(40)
        console.log(arr)

       //删除40
        arr.pop()
        console.log(arr)

        //  队首添加
        arr.unshift(9)
        console.log(arr)
        
        //  队首删除 
        arr.shift()
        console.log(arr)
 
        //从下标为1开截取，截取两个元素
        arr.splice(1,2)
        console.log(arr)


        //从下标为1开截取，截取1个元素,替换成50
        arr.splice(1,1,50)
        console.log(arr)

      //反转数组
        arr.reverse()
        console.log(arr)

        console.log('======================')

        var arr1=[3,2,1]
        arr1.sort()//排序默认由低到高，排序规则，按字符编码
        console.log(arr1)

        console.log('======================')
        var arr2=[14,20,41,14,100]
        arr2.sort()//排序默认由低到高，排序规则，按字符编码
        console.log(arr2)

        // 改变排序规则：升序  从小到大
        var arr3=[14,20,41,14,100]
        var fun=function(a,b){ //
            if(a<b){
                //负数升序，正数降序 -1 和1都改！！！
                return -1   
            }
            if(a>b){
                return 1   
            }
            if(a==b){
                return 0  
            }
        }
        arr3.sort(fun)
        console.log(arr3)
        console.log('======================')
        var arr4=[1,20,41,14,100]
  
        var arr5=arr4.concat([4,5,6,])
        console.log(arr5)

        console.log('======================')
        var arr6=[1,2,3] //1-2-3
        var str=arr.join('-')
        console.log(str)

        
        console.log('===============================')
        var arr=['hello','html','vue','js','react']
        var newArr=arr.slice(3)
        console.log(newArr)
     
        console.log('===============================')
        var arr=[10,20,30,40]
        var index=arr.indexOf(20)//返回索引号  20对应为1，若元素不存在，返回-1
        console.log(index)

        // 判断值在数组是否存在
        console.log(arr.includes(20));

做个学生信息的例子： 

 <script>
        //    1.创建一个学生成绩数组 [98,78,86,59,94]
        var scoreArr=[98,78,86,59,94]
        // 2.向数组中追加一个成绩100分
        scoreArr.push(100)

        // 3. 删除第1个不及格的成绩
        //      提示: 1. 删除数组元素，使用splice(索引号,1) 
        //            2. 遍历数组,查找不及格元素索引号
        
        for(i=0;i<5;i++){
            if(scoreArr[i]<60)
            // delete(scoreArr[i])
            scoreArr.splice(i,1)
        }
        console.log(scoreArr)
           
        

        // 4. 数组成绩由低到高排序输出
        var fun=function(a,b){
            if(a<b){
                return -1
            }
            if(a>b){
                return 1
            }
            if(a=b){
                return 0
            }
        }
        scoreArr.sort(fun)
        console.log(scoreArr)
    </script>

遍历数组

 forEach

        匿名函数

        function()

           arr.forEach (function(index,item){

            //形参1 //  数组元素

            //形参2   // 索引号（下标）

           } )

    var arr=[98,45,67,87,45,89]
         //遍历数组
        //  for(var i=0;i<=arr.length;i++){
        //     console.log(arr[i])
        //  }
        function testforEach(){
            arr.forEach(function(index,item,arr1){  //参数三会输出整个数组
            console.log('index:',index,'item:',item,arr1)
        })

        var arr=[98,45,67,87,45,89]
         //找最大值
        var max=0
        arr.forEach(function(item,index){
            if(item>max){
                max=item
            }
        })
        console.log('最大值',max)

        }

 map

         arr.map(function(item,index){

            return 新元素

         })

         [新元素1,新元素2,........]

         作用：遍历数组、返回新数组（映射新数组）return返回值

        

      var arr=[98,45,67,87,45,89]
      //所有分数统一-10
           function testMap(){
            var newArr=[]
             for(var i=0;i<arr.length;i++){
                newArr.push(arr[i]-10)
             }
             console.log(newArr)
        }
        // testMap()

  filter

         var newArr=arr.filter(function(item,index){

            return 条件

         })

         把原始数组中满足条件的筛选出来，组成一个新的数组返回

           var arr=[98,45,67,87,45,89]    
         // 查找大于70分的成绩
        function testFilter(){
            var newArr=arr.filter(function(item){
                return item>70
            })
            console.log(newArr)
        }

Find查找满足条件的元素，找到一个就结束！！！

        var arr=[98,45,67,87,45,89]    
        //查找分数大于80，找到一个则结束
        function testFind(){
            var newItem=arr.find(function(item){
                return item>80
            })
            console.log(newItem)
        }

 every：数组中是否每个元素都满足指定的条件, 全部满足返回true

         var arr=[98,45,67,87,45,89]
         //查看是否全部满足大于60 
         function testEvery(){
         var isok= arr.every(function(item){
                return item>60
            })
            console.log(isok)

some:数组中只要有一个满足条件，只要有一个就回返TRUE

        var arr=[98,45,67,87,45,89]
         //查看是否有小于60分
         function testSome(){
           var isok= arr.some(function(item){
                return item<60
            })
            console.log(isok)
        }
        testSome()

冒泡排序：

相邻两个数两两比较，若是前一个数大于后一个数，交换位置。

第一轮可以确定最后一位为最大的数

重复第一轮，找到第二大的数

.....................

有N个数，历经N-1轮.

var arr=[90,34,45,64,23,78]
//外层循环冒泡轮数
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 temp=arr[i]
      arr[i]=arr[i+1]
      arr[i+1]=temp
      }
  }
console.log(arr)
}
console.log('排序后：'，arr)

如有不正确的地方，望指正哦！