冒泡排序

冒泡排序:相邻的两个数进行比较，符号条件，交换位置
   9, 6, 15, 4, 2
   6, 9, 4 , 2, 15    4次
   6, 4, 2 , 9        3次
   4, 2, 6            2次
   2, 4               1次

   挨着的两个数进行比较，如果前一个比后一个大，就把两个数交换位置
   数组遍历一遍以后，最后一个数字就是最大的那个数
   进行第二遍遍历，按照之前的规则，第二个大的数字就会跑到倒数第二个位置了
   依次类推

*/
      var arr = [9, 6, 15, 4, 2]

      for (var i = 1; i < arr.length; i++) {
        //外层  遍历的次数 从第一次开始遍历
        for (var j = 0; j < arr.length - i; j++) {
          //内层  比较的次数  从第一个开始比较  第一个下标为0
          // arr[j] 前一个  arr[j+1]后一个
          if (arr[j] > arr[j + 1]) {
            // 交换位置
            var t = arr[j]
            arr[j] = arr[j + 1]
            arr[j + 1] = t
          }
        }
      }

      console.log(arr)

选择排序

 // 选择排序   依次取出第一个元素，与后面所有元素进行比较，符合条件 交换位置

      /*
      9, 6, 15, 4, 2
        2   9, 15, 6, 4      4次
            4  15, 9, 6     3次
                6  15,9     2次
                   9  15    1次
      */

      var arr = [9, 6, 15, 4, 2]

      for (var i = 0; i < arr.length - 1; i++) {
        //比较的轮数
        // 每一轮比较的次数
        for (j = i + 1; j < arr.length; j++) {
          if (arr[i] > arr[j]) {
            var t = arr[i]
            arr[i] = arr[j]
            arr[j] = t
          }
        }
      }
      console.log(arr)

ES5扩展

都不改变原数组

      indexOf(元素,start)
      作用:查找元素在数组中第一次出现时下标的位置，如果没有返回-1
      返回值:下标
      */
      // var arr = [1, 2, 3, 4, 5, 2, 3, 4, 5, 6, 2, 2, 3, 4, 5]
      // var res = arr.indexOf(2, 0)
      // console.log(res) //1

      //  思考?如何将数组中重复的元素去掉

      /*
            lastIndexOf(元素,start)
            作用:查找元素在数组中最后一次出现时下标的位置，如果没有返回-1

            如果指定第二个参数 start，则在一个字符串中的指定位置从后向前搜索
           返回值:下标
            */

      // var arr = [1, 2, 3, 4, 5, 2, 3, 4, 5, 6, 2, 2, 3, 4, 5]
      // var res = arr.lastIndexOf(2)   11
      // var res = arr.lastIndexOf(2, 10)
      // console.log(res) //10

      /*
            forEach 遍历数组
            arr.forEach(function(value,index,array) {

            }); */
      // var arr = [1, 2, 3, 4, 5, 2, 3, 4, 5, 6, 2, 2, 3, 4, 5]
      // arr.forEach(function (value, index, array) {
      //   // value  每一个数组元素
      //   // index  下标
      //   // array  数组
      //   console.log(value, index, array)
      // })

      /*
             映射 返回一个新数组
              map(function(value,index,array){ return ...})
            */

      // var arr = [1, 2, 3, 4, 5, 2, 3, 4, 5, 6, 2, 2, 3, 4, 5]
      // var newArr = arr.map(function (value, index, array) {
      //   // return的值是新数组的数组元素
      //   return value * 2
      // })
      // console.log(newArr)

      /* 
      
       filter(function(value,index,array){ return 过滤条件})
      */

      // var arr = [1, 2, 3, 4, 5, 2, 3, 4, 5, 6, 2, 2, 3, 4, 5]
      // // 过滤数组中值大于4的数组元素  返回过滤后的数组
      // var newArr = arr.filter(function (value, index, array) {
      //   return value >= 4
      // })

      // console.log(newArr)

      /* 
      reduce(function(累加器,当前值，索引，数组){return ...},累加器初始值)
      
      */
      var arr = [1, 2, 3, 4, 5, 2, 3, 4, 5, 6, 2, 2, 3, 4, 5]
      // 求和
      var sum = arr.reduce(function (s, value, index, array) {
        return s + value
      }, 0)
      console.log(sum) //51  数组中所有数组元素的和

JavaScript-数组排序算法

冒泡排序

选择排序

ES5扩展