冒泡排序

#### 冒泡排序

原理：数组中有 `n` 个数，比较每相邻两个数，如果前者大于后者，就把两个数交换位置；这样一来，第一轮就可以选出一个最大的数放在最后面；那么经过 `n-1`（数组的 length - 1） 轮，就完成了所有数的排序。

```js
var arr=[3,4,2,1];
function order(arr){
    var temp;
    for(var i=0;i<arr.length;i++){
        for(var j=0;j<arr.length-1;j++){
            if(arr[j]>arr[j+1]){
                temp = arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
    }
    return arr
}
order(arr)
```

函数的执行结果是[1,2,3,4]

这一次的执行结果将最大数放在最后面 下一次遍历的时候就不需要考虑这个数了 因为已经是最大的了 所以内层循环改成arr.length-1-i才合适

```js
function order(arr){
    var temp;
    for(var i=0;i<arr.length;i++){
        for(var j=0;j<arr.length-1-i;j++){
            if(arr[j]>arr[j+1]){
                temp = arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
    }
    return arr
}
```

当arr=[2,1,3,4]的时候 遍历一次之后数组已经排序完成  不需要继续执行剩下的循环 

可以添加一个标志位 当每次循环执行完成后如果没有数据交换 标志位为true  跳出循环  提升性能 减少不必要的排序

```js
function order(arr){
    var temp;
    for(var i=0;i<arr.length;i++){
    var flag=true;
        for(var j=0;j<arr.length-1;j++){
            if(arr[j]>arr[j+1]){
                temp = arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
        flag=false;
            }
        }
    if(flag){
      break;
    }
    }
    return arr
}
```

总结：

1. 外层循环控制循环的次数
2. 内层循环通过交换相邻的两个元素，找出最大的数放在最后面
3. 通过设置标志位减少不必要的排序

**时间复杂度：** `平均时间复杂度O(n*n) 、最好情况O(n)、最差情况O(n*n)`
**空间复杂度：** O(1)
**稳定性：**稳定

时间复杂度指的是一个算法执行所耗费的时间
空间复杂度指运行完一个程序所需内存的大小