最通俗易懂的冒泡排序原理

冒泡排序：

排序：指数据从小到大排列或者从大到小排列
数组中的排序：指的是将数组元素进行从小到大排列或者从大到小排列
冒泡排序算法简介：

1. 比较相邻的元素，前一个比后一个大（或者前一个比后一个小）调换位置
2. 每一对相邻的元素进行重复的工作，从开始对一直到结尾对，这步完成后，结尾为最大或
   最小的数.
3. 针对除了最后一个元素重复进行上面的步骤
4. 重复1-3步骤直到完成排序

//第一步 思路 先进行第一组排序 依次比较 交换位置
//内层循环 控制次数

javascript
 <script>
         //冒泡排序的原理:比较数组相邻的两个数 如果第一个数比第二个数大或者小  就交换

        //1.定义一个数组
        let arr = [10, 3, 7, 24, 6, 81, 5];
        //2.遍历数组  从索引0开始 到数组最后一位结束(从里往外推)
        for (let j = 0; j < arr.length; j++) {
            //3.第一步比较数组相邻的两位 10和3
            //数组中相邻的两位数是 arr[i] 和 arr[i+1]  
            if (arr[j] > arr[j + 1]) {
                //交换位置
                //1.声明临时变量
                let temp;
                //2.将arr[j]这个变量的值 赋值给temp
                temp = arr[j];
                //3.将arr[j+1]的值 赋值给arr[j]
                arr[j] = arr[j + 1];
                //4.将temp的值 赋值给 arr[j+1]
                arr[j + 1] = temp;
            }
        }
        console.log(arr);

//第二步 思路 给内层循环的外面 套一层循环 控制交换趟数
//(for循环外层控制行数 内层控制次数)
//外层循环走一次 内层循环走一圈

 <script>
      let arr = [10, 3, 7, 24, 6, 81, 5]
      // 依次的比较相邻的元素 如果前一个比后一个要大则交换他们的位置
      // 1. 遍历数组
      // 2. 比较 ？
      // 3. 交换位置  交换两个变量的值
      for (let i = 0; i < arr.length; i++) {
      //外层循环走一次 内层循环走一圈
      //i=0时  内循环里面的元素位置交换第一次
      //i=1时  内循环里面的元素位置交换第一次
        for (let j = 0; j < arr.length; j++) {
          if (arr[j] > arr[j + 1]) {
            // 1. 声明一个临时变量
            let temp
            // 2. 将 arr[j]这个变量 的值赋值为 temp
            temp = arr[j]
            // 3. 将 arr[j + 1]的值赋值为 arr[j]
            arr[j] = arr[j + 1]
            // 4. 将 temp 的值 赋值为 arr[j+1]
            arr[j + 1] = temp
          }
        }
      }
      console.log(arr)

//第三步 思路 优化

**外层循环 ：**七个数字 只需要交换6趟 arr.length-1.
**里层循环（同理） ：**七个数字 只需要交换6趟 arr.length-1

外层：i 表示趟数
里层：j表示次数

第1趟的时候，我们需要比较6次 就能将最大值放到数组的最后面
i = 0 表示第一趟 比较（j<7-1-0）6次
第2趟的时候，我们需要比较5次 就能将最大值放到数组的最后面
i = 1 表示第二趟 比较（j<7-1-1）5次
第3趟的时候，我们需要比较5次 就能将最大值放到数组的最后面
i = 2 表示第三趟 比较（j<7-1-2）4次
第i趟的时候，我们需要比较j次
结论：外层循环每交换一趟 内层循环次数每次都要在原有的基础上少一次 j < arr.length - 1 - i
//冒泡排序优化后的代码实现：

  <script>
        //1.定义一个数组
        let arr = [10, 3, 7, 24, 6, 81, 5];
        //需要比较多少次  数组长度为7,需要比较6次 比到第六次就可以确定最后的数为最大值  arr.length-1次;
		//外层循环 ：七个数字 只需要交换6趟  arr.length-1.
		//里层循环（同理） ：七个数字 只需要交换6趟 arr.length-1
   		 for (let i = 0; i < arr.length - 1; i++) {
      // 1. 里面的循环的
      // 第1趟的时候 我们需要比较 6次就能将 最大放到数组的最后面  i = 0 表示第一趟    j < 7 - 1 - 0
      // 第2趟的时候 我们需要比较 5次就能将 最大放到数组的最后面  i = 1 表示第二趟    j < 7 - 1 - 1
      // 第3趟的时候 我们需要比较 4次就能将 最大放到数组的最后面  i = 2 表示第三趟    j < 7 - 1 - 2
      // 第4趟的时候 我们需要比较 3次就能将 最大放到数组的最后面  i = 3 表示第四趟    j < 7 - 1 - 3
     	 for (let j = 0; j < arr.length - 1 - i; j++) {
       		 if (arr[j] > arr[j + 1]) {
         	 // 1. 声明一个临时变量
        	  let temp
        	  // 2. 将 arr[j]这个变量 的值赋值为 temp
        	  temp = arr[j]
      		  // 3. 将 arr[j + 1]的值赋值为 arr[j]
       	 	  arr[j] = arr[j + 1]
       	  	  // 4. 将 temp 的值 赋值为 arr[j+1]
       		  arr[j + 1] = temp
        }
      }
    }
    console.log(arr)     
    </script>