冒泡排序(JAVA版)

冒泡排序

已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先比较a[1]与a[2]的值，若a[1]大于a[2]则交换两者的值，否则不变。再比较a[2]与a[3]的值，若a[2]大于a[3]则交换两者的值，否则不变。再比较a[3]与a[4]，以此类推，最后比较a[n-1]与a[n]的值。这样处理一轮后，a[n]的值一定是这组数据中最大的。再对a[1]~a[n-1]以相同方法处理一轮，则a[n-1]的值一定是a[1]~a[n-1]中最大的。再对a[1]~a[n-2]以相同方法处理一轮，以此类推。共处理n-1轮后a[1]、a[2]、……a[n]就以升序排列了。

优点：稳定，比较次数已知；

缺点：慢，每次只能移动相邻两个数据，移动数据的次数多。

//bubbleSort.java
//bubble sort


class bubbleSort
{
public static void main(String[] args)
{
int maxSize=100;
ArrayBub arr;
arr=new ArrayBub(maxSize);
arr.insert(77);
arr.insert(99);
arr.insert(44);
arr.insert(55);
arr.insert(22);
arr.insert(88);
arr.insert(11);
arr.insert(00);
arr.insert(66);
arr.insert(33);
arr.display();
arr.bubbleSort();
arr.display();
}
}


//ArrayBub 类用于封装一个整型数组a[]
class ArrayBub
{
private int[] a; //数组a
private int nElems; //数组元素下标

//构造函数
public ArrayBub(int max)
{
a=new int[max];
nElems=0;
}

//插入数据
public void insert(int value)
{
a[nElems]=value;
nElems++;
}

//显示数组数据
public void display()
{
for(int j=0;j<nElems;j++)
System.out.print(a[j]+" ");
System.out.println(" ");
}

//冒泡排序
public void bubbleSort()
{
int out,in;
for(out=nElems-1;out>0;out--)
{
for(in=0;in<out;in++)
if(a[in]>a[in+1])
swap(in,in+1);
}

}

//交换位置
private void swap(int one,int two)
{
int temp=a[one];
a[one]=a[two];
a[two]=temp;
}
}

交换步骤分析：

原数组：  77 99 44 55 22 88 11  0 66 33 

交换第1趟：77 44 55 22 88 11  0  66 33 99   比较9次 

交换第2趟：44 55 22 77 11  0  66 33 88 99   比较8次

交换第3趟：44 22 55 11  0  66 33 77 88 99   比较7次

交换第4趟：22 44 11 0   55 33 66 77 88 99   比较6次

交换第5趟：22 11 0  44  33 55 66 77 88 99   比较5次

交换第6趟：11  0 22 33  44 55 66 77 88 99   比较4次

交换第7趟：0  11 22 33  44 55 66 77 88 99   比较3次

交换第8趟：0  11 22 33  44 55 66 77 88 99   比较2次

交换第9趟：0  11 22 33  44 55 66 77 88 99   比较1次

冒泡排序效率分析：

比较的次数：9+8+7+6+5+4+3+2+1=45

当数组大小为N时，比较的次数为：

(N–1) + (N–2) + (N–3) + ... + 1 = N*(N–1)/2

所以比较的次数大概为N*N/2次比较

比较次数为：0(N*N)

交换次数为：0(N*N);

时间复杂度为0（N*N）；