作为一个入门级的排序方法
    算法流程：
    1、双重循环遍历序列
    2、通过两两比较交换内层循环的两个相邻的值直到得到一个排序序列

    代码

    1. function BubbleSort(nums){
    2.     for (let i = 0; i < nums.length - 1; i++) {
    3.       for (let j = 0; j < nums.length - 1; j++) {
    4.         if(nums[j] > nums[j + 1]){
    5.           swap(nums, j, j + 1)
    6.             }            
    7.     }
    8.     }
    9.   return nums
    10. }
    12. function swap(nums, i, j){
    13.   let tmp = nums[i]
    14.   nums[i] = nums[j]
    15.   nums[j] = tmp
    16. }

    时间复杂度(O(n^2))
    空间复杂度(O(1))

    上面是实现算法实际上可以进行改进，我们对冒泡排序进行改良
    1、记录一个标记位用来标记是否发生了交换，如果没有交换说明已经排序好了
    2、记录一个标记位用来每次排序最后一次发生交换位置，每次遍历不用全部遍历完

    代码
    **

    1. function BubbleSort(nums){
    2.   let lastChange = nums.length - 1
    3.   for (let i = 0; i < nums.length - 1; i++) {
    4.     let isSort = true, end = lastChange
    5.     for (let j = 0; j < end; j++) {
    6.       if(nums[j] > nums[j + 1]){
    7.         isSort = false // 存在交换没有排序好
    8.         lastChange = j // 记录最后交换位置 最后一次交换以后，说明后面的已经不需要交换了
    9.         swap(nums, j, j + 1)
    10.       }            
    11.     }
    12.     if(isSort) break // 如果不有任何交换说明已经排序好了
    13.   }
    14.   return nums
    15. }

    时间复杂度(O(n) - O(n^2)) 平均(O(n^2))
    空间复杂度(O(1))
    **
    最好的情况：已经是一个排序序列了
    最换的情况：逆序序列