数组、冒泡排序和选择排序

数组

一、数组基础

1. 什么数组

数组是一系列数据的集合

也就是我们把一些数据放在一个盒子里面，按照顺序排好,
这个东西就是一个数组，存储着一些数据的集合 例如 [1, 2, 3, ‘hello’, true, false]

2. 数组数据类型Array

3. 创建一个数组

   • 数组就是一个 [ ]

   • 在 [ ] 里面存储着各种各样的数据，按照顺序依次排好

     字面量创建一个数组

     //创建一个空数组
     var arr1=[]
     //创建一个有内容的数组
     var arr2=[10,20,30]
     

     内置构建函数创建一个数组

     //创建一个空数组
     var arr1=new Array()
     //创建一个长度为10的数组
     var arr2=new Array(10)
     //创建一个有内容的数组
     var arr3=new Array(10,20,30)
     

4. 数组的 length

    - length:  长度的意思
   
    - length 就是表示数组的长度，数组里面有多少个成员，length 就是多少
   
      ```js
      //语法
      var arr1=[10,20,30,40]
      document.write('数组的长度为：',arr1.length)	//数组的长度为：4
      ```
   

5. 数组的索引

   //创建一个数组
   var arr=['hello','world']
   document.write(arr[0])	//hallo
   document.write(arr[1])	//world
   

   上面这个数组中，第0个 数据就是字符串hello，第1个 数据就是字符串world想获取数组中的第几个就使用数组[索引]来获取，数组的下标（索引）是从0 开始

6. 数组的遍历

• 因为数组的索引就可以获取数组中的内容

• 数组的索引又是按照 0 ～ n 顺序排列

• 我们就可以使用 for 循环来循环数组，因为 for 循环我们也可以设置成 0 ～ n 顺序增加

• 我们把这个行为叫做 遍历

  //遍历数组
  var arr=[10,20,30,50,40]
  for(var i=0;i<arr.length;i++){
      document.write(arr[i],' ')	//10 20 30 50 40
  }
  

  • i < arr.length因为length就是数组的长度，就是一个数字，所以我们可以直接用它来决定循环次数
  • document.writr(arr[i])因为随着循环，i的值会从0开始依次增加
  • 所以我们实际上就相当于在打印arr[0] arr[1] arr[2]…

• 举个栗子

//有一个数组arr[3,6],交换数组元素顺序[6,3]
var arr = [3, 6]
    var temp
    temp = arr[0]
    arr[0] = arr[1]
    arr[1] = temp
    document.write(arr[0], ' ', arr[1])		//6 3

7. 数组常见错误

//数组的下标（索引）
var arr=[1,2,3,4]
	document.write(arr[4])	//数组下标是从0开始，在这里不存在arr[4]

二、数据类型之间存储的区别

• 我们的存储空间分成两种 栈 和 堆

• 栈： 主要存储基本数据类型的内容

• 堆： 主要存储复杂数据类型的内容

• 数据类型之间的比较

  • 基本数据类型是 值 之间的比较
  • 复杂数据类型是 地址 之间的比较

三、数组的常用方法

• push 是用来在数组的末尾追加一个元素

var arr=[1,2,3]
//使用push方法追加一个元素在末尾
arr.push(4)
console.log(arr)	//[1,2,3,4]

• pop 是用来删除数组末尾的一个元素

var arr=[1,2,3]
//使用pop放法删除末尾的一个元素
arr.pop()
console.log(arr)	//[1,2]

• unshift 是在数组最前面添加一个元素

  var arr = [1,2,3]
  //使用unshift方法在数组的最前面添加一个元素
  arr.unshift(4)
  console.log(arr)	//[4,1,2,3]
  

• shift 是删除数组最前面的一个元素

  var arr = [1,2,3]
  //使用shift方法删除数组最前面的一个元素
  arr.shift()
  console,log(arr)	//[2,3]
  

• splice 是截取数组中的某些内容，按照数组的索引 来截取

  • 语法： splice(从哪一个索引位置开始截取 , 截取多少个 , 替换的新元素) （第三个参数可以不写）

    var arr = [1,2,3,4,5]
    //使用splice方法截取数组
    arr.splice(1,2)	//从索引为1的开始，截取两个元素
    console.log(arr)	//[1,4,5]
    

  • arr.splice(1,2) 表示从索引1开始截取2个元素

  • 第三个参数没有写，就是没有新内容替换掉截取位置

      var arr = [1,2,3,4,5]
      //使用splice方法截取数组
      arr.splice(1,2,'我是替换内容')
      console.log(arr)	//[1,'我是替换内容',4,5]
    

  • arr.splice(1,2,'我是替换内容') 表示从索引1开始截取2个内容

  • 然后用第三个参数的元素把截取完空出来的位置填充

• reverse 是用来反转数组使用的

  var arr = [1,2,3]
  //使用reverse方法来反转数组
  arr.reverse
  console.log(arr)	//[3,2,1]
  

• sort 是用来给数组排序的

  var arr = [2,3,1]
  //使用sort方法给数组排序
  arr.sort()
  console.log(arr)	//[1,2,3]
  

• concat 是吧多个数组进行拼接

  • 和之前的方法有一些不一样的地方，就是concat 不会改变原始数组，而是返回一个新的数组

    var arr = [1,2,3]
    //使用concat方法拼接数组
    var newArr = arr.concat([4,5,6])
    
    console.log(arr)	//[1,2,3]
    console.log(newArr)	//[1,2,3,4,5,6]
    

• join 是把数组里面的每一项内容连接起来，变成一个字符串

  • 可以自己定义每一项之间连接的内容 jion(想要以什么内容连接)

  • 不会改变原始数组，而是把连接好的字符串返回

    var arr = [1,2,3]
    //使用join连接数组
    var str = arr.join('-')
    console.log(arr)	//[1,2,3]
    console.log(str)	//1-2-3
    

四、数组的排序

排序：就是把一个乱序的数组，通过我们的处理，让他变成一个有序的数组

常用的两种排序方法：冒泡排序 和 选择排序

冒泡排序

原理：

• 先遍历数组，让挨着的两个进行比较，如果前一个比后一个大，那么就把两个换个位置
• 数组遍历每一遍以后，都会把最大的一个数字冒泡到最后
• 然后进行第二遍的遍历，还是按照之前的规则，第二大的数字就会跑到倒数第二的位置
• 以此类推，最后就会按照顺序把数组排好了

var arr = [30, 20, 40, 10, 60, 50]
    var i, j, temp
    for (i = 0; i < arr.length-1; i++) {
        for (j = 0; j < arr.length - i - 1; j++) {
            //前后两个数进行比较，前面大于后面，交换元素
            if (arr[j] > arr[j + 1]) {
                temp = arr[j]
                arr[j] = arr[j + 1]
                arr[j + 1] = temp
            }
        }
    }
    document.write(arr)	//10 20 30 40 50 60 

选择排序

原理：

• 在要排序的一组数中，选出最小的一个数与第一个位置的数交换；
• 然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止
• 每一次排序，都会把最小的选择到最前面

    var arr = [30, 10, 20, 50, 40, 60]
    var temp, i, j, minIndex
	//minIndex	存储第一个元素的地址
    //遍历数组，将元素的地址赋值给minIndex
    for (i = 0; i < arr.length - 1; i++) {
        minIndex = i
        for (j = i + 1; j < arr.length; j++) {
            if (arr[minIndex] > arr[j]) {
                minIndex = j
            }
        }
        //交换元素
        temp = arr[minIndex]
        arr[minIndex] = arr[i]
        arr[i] = temp

    }
    document.write(arr)

五、ES6中数组常用方法

• indexOf 用来找到数组中某一项的索引（地址）

  • 语法： indeOf(你要找的数组中的项)

    var arr = [1,2,3,4,5]
    //使用indexOf方法找出数组中的某一项
    var index = arr.indexOf(3)
    var index1 = arr.indexOf(6)
    
    document.write(index)	//2
    document.write(index1)	//-1
    

  • 我们要找的是数组中数值为 3 的那一项

  • 返回的就是数值 3 那一项在该数组中的索引（地址）

  • 注意： 如果你要找的内容在数组中没有，那么就会返回 -1

• forEach

  • 和for循环一个作用，就是用来遍历数组的

  • 语法： arr.forEach(function(item,index,arr){})

    var arr = [1,2,3]
    //使用forEach遍历数组
    arr.forEach(function(item, index, arr){
        //item就是数组中的每一项
        //index就是数组的索引（地址）
        //arr就是原始数组
        document.write('数组第', index, '项的值是', item,'原始数组是', arr,'<br>')
    })
    

  • 使用forEach()的时候传递的那个函数，会根据数组的长度执行

  • 数组的长度是多少，这个函数就会执行多少次

• map 和forEach类似 ，只不过可以对数组中的每一项进行操作，返回一个新的数组

  var arr = [1,2,3]
  //使用map遍历数组
  var newArr = arr.forEach(function(item, index, arr){
      //item就是数组中的每一项
      //index就是数组的索引（地址）
      //arr就是原始数组
      document.write('数组第', index, '项的值是', item,'原始数组是', arr,'<br>')
  })
  

• filter

  • 和 map 的使用方式类似，按照我们的条件来筛选数组

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

   var arr = [1,2,3]
   //使用filter遍历数组
   var newArr = arr.filter(function(item, index, arr){
       //item就是数组中的每一项
       //index就是数组的索引（地址）
       //arr就是原始数组
       return item > 1
   })
   
   document.write(newArr)	//[2,3]
  

  • 我们设置的条件就是 > 1
  • 返回的新数组就会是原数组中所有 > 1 的项

• find 遍历数组返回数组中满足条件的第一个元素

var arr = [10,11,12,13,14,15]
//find() 遍历数组返回数组中满足条件的第一个元素
var newItem = arr.find(function(item, index){
    return item > 13
})
document.write(newItem)		//14