冒泡排序
相邻的两个元素比较大小,如果当前元素比右侧元素大的话就交换,否则不交换;
总共排N-1个回合,每一个回合挑选出无序区中最大的元素;
一个回合要比较N-1次,总共有N-1个回合,因此时间复杂度是N*N;
最原始的版本(也是第一次学数据结构试图背下来的算法!)
public static void sort(int array[]){
for(int i = 0; i < array.length - 1; i++)
{
for(int j = 0; j < array.length - i - 1; j++)
{
int tmp = 0;
if(array[j] > array[j+1])
{
tmp = array[j];
array[j] = array[j+1];
array[j+1] = tmp;
}
}
}
}
public static void main(String[] args){
int[] array = new int[]{5,8,6,3,9,2,1,7};
sort(array);
System.out.println(Arrays.toString(array));
}
第一次优化(解决靠左无序区已经有序的问题)
下图在第六轮排序已经有序了,此时其实已经可以提前结束最后一轮排序了。
public static void sort(int array[]) {
for (int i = 0; i < array.length - 1; i++) {
//有序标记,每一轮的初始值都是true
boolean isSorted = true;
for (int j = 0; j < array.length - i - 1; j++) {
int tmp = 0;
if (array[j] > array[j + 1]) {
tmp = array[j];
array[j] = array[j + 1];
array[j + 1] = tmp;
//因为有元素进行交换,所以不是有序的,标记变为false
isSorted = false;
}
}
if (isSorted) {
break;
}
}
}
public static void main(String[] args) {
int[] array = new int[]{5, 8, 6, 3, 9, 2, 1, 7};
sort(array);
System.out.println(Arrays.toString(array));
}
第二次优化(解决靠右侧无序区已经有序的问题)
此时可以结合第一次优化的方法,加上标志位,解决了靠左靠右无序区中有序而多余的比较轮回的问题
public static void sort(int array[])
{
int tmp = 0;
//记录最后一次交换的位置
int lastExchangeIndex = 0;
//无序数列的边界,每次比较只需要比到这里为止
int sortBorder = array.length - 1;
for(int i = 0; i < array.length; i++)
{
//有序标记,每一轮的初始是true
boolean isSorted = true;
for(int j = 0; j < sortBorder; j++)
{
if(array[j] > array[j+1])
{
tmp = array[j];
array[j] = array[j+1];
array[j+1] = tmp;
//有元素交换,所以不是有序,标记变为false
isSorted = false;
//把无序数列的边界更新为最后一次交换元素的位置
lastExchangeIndex = j;
}
}
sortBorder = lastExchangeIndex;
if(isSorted){
break;
}
}
}
public static void main(String[] args){
int[] array = new int[]{3,4,2,1,5,6,7,8};
sort(array);
System.out.println(Arrays.toString(array));
}
第三次优化【鸡尾酒排序】(在大部分元素有序的情况下,解决偶尔因一个元素位置不合适导致多余的比较轮回)
下图可知,1就是罪魁祸首
使用鸡尾酒排序进行优化之后:
这进行了第一轮回(来+回),这一个来回已经相当于原始冒泡排序算法的两个轮回了,所以在最外层循环只需要总数组长度的一半即可;
而奇数和偶数算法的两个轮回中的索引一直控制在i到array.length-i-1之间,随着i的增大,无序区在在中间慢慢消失的,所以随着迭代次数的增加,只需要对中间的无序区进行排序即可。
public static void sort(int array[])
{
int tmp = 0;
for(int i=0; i<array.length/2; i++)
{
//有序标记,每一轮的初始是true
boolean isSorted = true;
//奇数轮,从左向右比较和交换
for(int j=i; j<array.length-i-1; j++)
{
if(array[j] > array[j+1])
{
tmp = array[j];
array[j] = array[j+1];
array[j+1] = tmp;
//有元素交换,所以不是有序,标记变为false
isSorted = false;
}
}
if(isSorted){
break;
}
//偶数轮之前,重新标记为true
isSorted = true;
//偶数轮,从右向左比较和交换
for(int j=array.length-i-1; j>i; j--)
{
if(array[j] < array[j-1])
{
tmp = array[j];
array[j] = array[j-1];
array[j-1] = tmp;
//有元素交换,所以不是有序,标记变为false
isSorted = false;
}
}
if(isSorted){
break;
}
}
}
public static void main(String[] args){
int[] array = new int[]{2,3,4,5,6,7,8,1};
sort(array);
System.out.println(Arrays.toString(array));
}
可以和标志位的优化方法(第一种)结合使用,同样也能和记录无序区域最后一个索引方法(第二种)结合使用。
*例子均来自于《漫画算法》