资料参考:
1、《大话数据结构》
1、基本思想
两两比较相邻关键字,如果反序则交换,直到没有反序的记录为止。
2、前期准备和说明
1、以下所有版本的都已升序为主。
2、存储排序值的类,是一个自定义的类型:
public class ArrayList {
private int MAXSIZE = 10; //链表的最大空间,可根据需要修改
private int length =0; //用于记录顺序链表的实际长度
private int[] nodes = null; //用于要存储节点的容器(数组)
public ArrayList(){
nodes = new int[MAXSIZE];
}
public ArrayList(int MAXSIZE){
this.MAXSIZE = MAXSIZE;
nodes = new int[MAXSIZE];
}
/**
* 插入数据
* @param value
*/
public void add(int value){
if(nodes.length==0){
nodes[0] = value;
length+=1;
}else if (length<MAXSIZE){
nodes[length] = value;
length+=1;
}else if (length==MAXSIZE){
nodes[length] = value;
}else{
try {
throw new Exception();
} catch (Exception e) {
System.out.println("空间满了");
}
}
}
public void update(int offset ,int value){
nodes[offset] = value;
}
/**
* 交换i,j的位置
*/
public void swap(int i,int j){
int temp = getNote(i);
update(i,getNote(j));
update(j,temp);
}
/**
* 获取指定下标对应的节点。
* @param offset
* @return
*/
public Integer getNote(int offset){
if(offset>=length || offset<0){
return null;
}
return nodes[offset];
}
public int getMAXSIZE() {
return MAXSIZE;
}
public int getLength() {
return length;
}
@Override
public String toString() {
StringBuffer str = new StringBuffer();
for(int node:nodes){
str.append(node).append(" ");
}
return str.toString();
}
}
3、最简单的实现版本
思路:让每一个关键字,都和他后面的关键字比较,如果大则交换。
说明:这种方式严格意义上说,不算是标准的冒泡排序算法,因为他不满足“两两比较相邻记录”的冒泡排序思想,它更应该是最最简单的交换排序而已。
代码:
// 输入:9 1 5 8 3 7 4 6 2
public void bubbleSort(ArrayList arrayList){
for(int i=0;i<arrayList.getLength();i++){
for(int j=i+1;j<arrayList.getLength();j++){
if(arrayList.getNote(i)>arrayList.getNote(j)){
arrayList.swap(i,j); //保证i一直都是最小的
}
}
}
System.out.println(arrayList.toString());//输出:1 2 3 4 5 6 7 8 9
}
图例:
缺点:在上图,排序好1和2的位置后,对其余关键字的排序没有什么帮助(数字3反而还被换到了最后一位)。这个算法的效率非常低。
4、正宗的冒泡排序算法
思路:两两比较相邻关键字,如果反序列则交换,差异在于内循环采用的是反向循环。
图例说明:
序列[9,1,5,8,3,7,4,6,2],长9,下标从0到8;
第一次循环:变量 i=0,变量 j=7,变量j从7反向循环到0,逐个比较,将较小值交换到前面,直到最后找到最小的值放置在第0位上。同时我们还把关键字2从第8位提到第2位置上,在很多数据排序过程中,这种差异会明显体现出来。看下图较小的数字如同气泡般慢慢浮到上面,因此该算法叫冒泡算法。
第二次循环:变量 i=1,变量 j=7,变量j从7*反向循环*到1,逐个比较,将较小值交换到前面,关键字4和3有所提升,如下图:
代码:
// 输入: 9 1 5 8 3 7 4 6 2
public void bubbleSort(ArrayList arrayList){
for(int i=0;i<arrayList.getLength();i++){
//每次都从倒数第二位开始遍历(反向遍历)
for(int j=arrayList.getLength()-2;j>=i;j--){
if(arrayList.getNote(j)>arrayList.getNote(j+1)){
//一直保证当前循环中的i是最小的
arrayList.swap(j,j+1);
}
}
}
}
System.out.println(arrayList.toString());//输出:1 2 3 4 5 6 7 8 9
}
5、冒泡排序算法优化
思路:代码的改动就在于加了一个标识flag,在移动之前判断flag是否为false。经过这样的改动,冒泡排序在性能上就有了一些提示,可以避免因已经有序的情况下的无意义的循环判断
代码:
// 输入: 9 1 5 8 3 7 4 6 2
public void bubbleSort(ArrayList arrayList){
boolean flag = true;
for(int i=0;i<arrayList.getLength();i++){
if(!flag) break;
flag = false;
for(int j=arrayList.getLength()-2;j>=i;j--){ //每次都从倒数第二位开始遍历
if(arrayList.getNote(j)>arrayList.getNote(j+1)){
arrayList.swap(j,j+1);
flag = true;
}
}
}
System.out.println(arrayList.toString());//输出:1 2 3 4 5 6 7 8 9
}
6、冒泡排序复杂度分析
n是表的长度,当最好的情况,也就是要排序的表本身就是有序的,根据算法“冒泡排序优化” 可知我们比较次数是n-2(从0开始)次的比较,没有数据交换,时间复杂度为O[n]。当最坏的情况,即待排序表是逆序的情况下,此时需要比较:
即 n^2 次,并做同等数量级的记录移动,因此总的时间复杂度为O[n^2]。
等式说明:(n-2-i+1)是一次循环的时间复杂度,求和后就是多次循环后的时间复杂度。