0.算法改进解决的问题
由于冒泡算法的效率很低，时间复杂度过高，因此需要改进。
1.输入&输出
输入：一个无序的数组
输出：排序后的数组
2.改进思路
0.每次循环立一个标志，本次产生交换，记录下来。如果没有交换，证明数组已经是排好序的了，直接输出。
1.记录最后一次交换的位置，这个位置后的元素其实都是有序的，不需要再次比较
2.利用冒泡的思想，每次不但找到剩余元素中最大的放在右边，并且找出最小的元素放在左边，结合上一条改进，循环次数减少一大半。
3.伪代码&注释
3.0.
在冒泡算法的基础上，与temp同时定义flag值每次循环开始前（或结束前）判断上一次循环是否进行过交换，如果没有，直接结束并输出排好序的数组。
3.1.
在冒泡算法的基础上，与temp同时定义last exchange的值，每次排序的次数由lastexch值决定。排序次数更少。
3.2.
每次循环先找出一个最小值放在左边，再找出一个最大值放在右边。直到两边元素相遇停止循环。
4.java代码实现
4.0
public static int[] Bs(int[]a){
int temp = 0;
boolean flag = false;
//这里立了个 flag，无交换，flag ＝ true,直接跳出循环。
for(int i=a.length-1;i>0;i--){
if(flag == true) break;
flag = true;
for(int j=0;j<i;j++){
if(a[j]>a[j+1])
{temp = a[j];
a[j]=a[j+1];
a[j+1]=temp;
flag = false;//有交换flag ＝ false；
}
}
}
return a;
}
4.1
public static int[] Bs(int[]a){
int temp = 0;
int lastexch = a.length -1;
//标志位的初始值在末位，证明没有元素是排好序的
for(int i=lastexch;i>0;i--){
i = lastexch;
for(int j=0;j<i;j++){
if(a[j]>a[j+1])
{temp = a[j];
a[j]=a[j+1];
a[j+1]=temp;
lastexch = j;
//每次交换过后，lastexch（last exchange）的值变为j的值，证明a[j]以后的元素都是有序的，不需要再排列了。
}
}
}
return a;
4.2
public static int[] Bs(int[]a){
int temp = 0;
int low = 0;
int high = a.length-1;
int counter = 1;
while(low<high){
for(int i=low;i<high;++i){ //正向冒泡，确定最大值
if(a[i]>a[i+1]){ //如果前一位大于后一位，交换位置
temp= a[i];
a[i]= a[i+1];
a[i+1]= temp;
}
}
--high;
for(int j=high;j>low;--j){ //反向冒泡，确定最小值
if(a[j]<a[j-1]){ //如果前一位大于后一位，交换位置
temp= a[j];
a[j]= a[j-1];
a[j-1]= temp;
}
}
++low;}
return a;
}
5.复杂度
前两种改进方式只对于近似排列好的数组有很大作用，完全随机数测试意义不大，但是第三种改进算法差不多减少了一半的运行时间。不过实际上复杂度依旧没变。
6.优缺点及适用范围
对于小型数据排序，冒泡算法能起到一定的作用（因为它非常可靠）
但是缺点依旧是太慢，
