JavaScript冒泡排序

冒泡排序原理：

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

3. 针对所有的元素重复以上的步骤，除了最后一个。

4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

举个例子：现有数组arr = [1,9,-5,8]，使用冒泡排序算法对其进行排序。

a. 比较数组第一个元素“1”和第二个元素“9”。“1”小于“9”，所以不做操作，进行下一次循环。

b. 接着，比较数组第二个元素“9”和第三个元素“-5”。“9”大于“-5”，所以将他们交换位置。此时，数组变为[1,-5,9,8]。

c. 比较新数组的第3个元素“9”和第四个元素“8”，“9”大于“8”，所以将他们交换位置。此时，数组变为[1,-5,8,9]。

a、b、c对应冒泡排序原理中的1、2。

显然，经过以上操作，数组还未完成排序。

d.接下来，将“c”中得到的数组的最后一位，同时也是数组的最大值“9”存入一个新数组finalArr中，并将“9”从arr数组中删除。

然后，arr中剩余的元素重复以上操作。

a、b、c属于内循环。一轮内循环结束后，执行d。

内循环 + d又组成了外循环。

每轮内循环次数 = 变化后的arr数组长度 - 1

外循环次数 = 原arr数组长度

每轮内循环都是为了取得当前arr数组的最大数。

每次外循环都会向finalArr数组中添加一个数，那外循环次数也就是原arr数组元素个数（长度）。

1.    let arr = [1,-8,3,2,9,5,1,0,-5,10];  //需要排序的数组
2.    let arrLength = arr.length;  //需要排序的数组的长度
3.    let finalArr = [];  //降序排序后的数组（从大到小）
4.    let temp;  //相邻元素比较、交换时，暂存元素的值
5.    for (let i = 0;i < arrLength;i++){
6.        for(let j = 0;j < arr.length - 1;j++){
7.            if(arr[j] > arr[j+1]){  //相邻元素比较大小，若前一元素比后一元素大，则交换这两个元素的值
8.                temp = arr[j+1];
9.                arr[j+1] = arr[j];
10.               arr[j] = temp;
              }
          }
11.       finalArr.push(arr[arr.length - 1]); //将这次循环得到的最大值存入finalArr
12.       arr.splice(-1,1); //从arr中删除这次循环得到的最大值
      }
      console.log("从大到小排序::",finalArr);

let arr = [1,-8,3,2,9,5,1,0,-5,10];
let arrLength = arr.length;
let finalArr = [];
let temp;
for (let i = 0;i < arrLength;i++){
    for(let j = 0;j < arr.length - 1;j++){
        if(arr[j] > arr[j+1]){
            temp = arr[j+1];
            arr[j+1] = arr[j];
            arr[j] = temp;
        }
    }
    finalArr.push(arr[arr.length - 1]);
    arr.splice(-1,1);
}
console.log("从大到小排序::",finalArr);

参考：https://baike.baidu.com/item/%E5%86%92%E6%B3%A1%E6%8E%92%E5%BA%8F/4602306?fr=aladdin