java每轮排序结果,冒泡排序及其优化java

java冒泡排序及其优化##

version1

public static void bubbleSort() {

int[] arr={5，6，1，4，3，2，7，8}；

for (int i = arr.length - 1; i > 0; --i) { // 每次需要排序的长度

for (int j = 0; j < i; ++j) { // 从第一个元素到第i个元素

if (arr[j] > arr[j + 1]) {

temp = arr[j];

arr[j] = arr[j + 1];

arr[j + 1] = temp;

}

}//loop j

}//loop i

}// method bubbleSort

version2

static Integer[] sort1(Integer[] array , int size){

for(int i=0;iarray[j+1]){

int temp=array[j];

array[j] = array[j+1];

array[j+1] = temp;

}

}

}

return array;

}

两个版本原理相同，都是通过每一轮排序找到最大值，放大最后位置。

运行结果：{1，2，3，4，5，6，7，8}

思路解析：设现在要给数组arr[]排序，它有n个元素。

1.如果n=1：显然不用排了。(实际上这个讨论似乎没什么必要)

2.如果n>1：

(1)我们从第一个元素开始，把每两个相邻元素进行比较，如果前面的元素比后面的大，那么在最后的结果里面前者肯定排在后面。所以，我们把这两个元素交换。然后进行下两个相邻的元素的比较。如此直到最后一对元素比较完毕，则第一轮排序完成**。可以肯定，最后一个元素一定是数组中最大的(因为每次都把相对大的放到后面了)。**

(2)重复上述过程，这次我们无需考虑最后一个，因为它已经排好了。

(3)如此直到只剩一个元素，这个元素一定是最小的，那么我们的排序可以结束了。显然，进行了n-1次排序。

上述过程中，每次(或者叫做“轮”)排序都会有一个数从某个位置慢慢“浮动”到最终的位置(画个示意图，把数组画成竖直的就可以看出来)，就像冒泡一样，所以，它被称为“冒泡排序法”。

冒泡排序无论输入数据如何都会进行n-1轮排序，而每轮排序需要比较的次数从n-1递减到0。那么，总的比较次数即是 (n-1)+(n-2)+…+2+1 = (n-1)n/2≈(n^2)/2。赋值次数，这里的赋值是指其中的交换操作，对于上述代码，1次交换等于三次赋值。由于并非每次都必须交换，因此，赋值操作的次数与输入数据有关。最佳情况(best case)下，即一开始就是有序的情况下，赋值次数为0。 而最坏情况(worst case)下，赋值次数为(n-1)n/2。假设输入数据平均(或者说“完全随机”)分布，那么大约有交换次数为比较次数的一半。由上面的结果，可以得到平均情况(average case)下，赋值次数为 (1/23+1/20)(n^2)/2)=3/2 * (n^2)/2 = 3/4(n^2).

时间复杂度O(n^2),空间复杂度O(1),稳定性算法。

优化１：每一轮排序选择一个剩余的最大值，共排序n-1轮；有一轮排序时若有序，则剩下的数据是有序的，不需要进行下一轮排序

注意到每一轮排序只要记下最后一次的排序数组的下标，下一次排序只要排到此下标位置即可。如下

//待排序部分每一轮有序

static Integer[] sort2(Integer[] array , int size){

for(int i=0;iarray[j+1]){

int temp=array[j];

array[j] = array[j+1];

array[j+1] = temp;

flag = true;

}

}

if(!flag)break;

}

return array;

}

优化2: 每一轮排序的后半部分若是有序的，择下一轮排序从有序的前一个位置对应的排序开始

//待排序部分每一轮部分有序

static Integer[] sort3(Integer[] array , int size){

for(int i=0;iarray[j+1]){

int temp=array[j];

array[j] = array[j+1];

array[j+1] = temp;

flag = true;

pos=j;

}

}

k= pos;

if(!flag)break;

}

return array;

}