java 改进冒泡排序,1.0.1冒泡排序的三种改进方式

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

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

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

for(int i=low;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]

temp= a[j];

a[j]= a[j-1];

a[j-1]= temp;

}

}

++low;}

return a;

}

5.复杂度

前两种改进方式只对于近似排列好的数组有很大作用，完全随机数测试意义不大，但是第三种改进算法差不多减少了一半的运行时间。不过实际上复杂度依旧没变。

6.优缺点及适用范围

对于小型数据排序，冒泡算法能起到一定的作用(因为它非常可靠)

但是缺点依旧是太慢，